Merge pull request #51645 from fabriceci/improve-physics-api

API improvement on the physics (CharacterBody and related classes)

4 files changed, 208 insertions, 141 deletions

diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
index d52c293763..00da94c3b0 100644
--- a/scene/2d/physics_body_2d.cpp
+++ b/scene/2d/physics_body_2d.cpp
@@ -102,21 +102,21 @@ bool PhysicsBody2D::move_and_collide(const Vector2 &p_motion, PhysicsServer2D::M
 			}
 
 			// Check depth of recovery.
-			real_t projected_length = r_result.motion.dot(motion_normal);
-			Vector2 recovery = r_result.motion - motion_normal * projected_length;
+			real_t projected_length = r_result.travel.dot(motion_normal);
+			Vector2 recovery = r_result.travel - motion_normal * projected_length;
 			real_t recovery_length = recovery.length();
 			// Fixes cases where canceling slide causes the motion to go too deep into the ground,
 			// because we're only taking rest information into account and not general recovery.
 			if (recovery_length < (real_t)p_margin + precision) {
 				// Apply adjustment to motion.
-				r_result.motion = motion_normal * projected_length;
-				r_result.remainder = p_motion - r_result.motion;
+				r_result.travel = motion_normal * projected_length;
+				r_result.remainder = p_motion - r_result.travel;
 			}
 		}
 	}
 
 	if (!p_test_only) {
-		gt.elements[2] += r_result.motion;
+		gt.elements[2] += r_result.travel;
 		set_global_transform(gt);
 	}
 
@@ -1043,14 +1043,14 @@ void RigidBody2D::_reload_physics_characteristics() {
 // So, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
 #define FLOOR_ANGLE_THRESHOLD 0.01
 
-void CharacterBody2D::move_and_slide() {
+bool CharacterBody2D::move_and_slide() {
 	// Hack in order to work with calling from _process as well as from _physics_process; calling from thread is risky.
 	float delta = Engine::get_singleton()->is_in_physics_frame() ? get_physics_process_delta_time() : get_process_delta_time();
 
 	Vector2 current_platform_velocity = platform_velocity;
 
 	if ((on_floor || on_wall) && platform_rid.is_valid()) {
-		bool excluded = (exclude_body_layers & platform_layer) != 0;
+		bool excluded = (moving_platform_ignore_layers & platform_layer) != 0;
 		if (!excluded) {
 			// This approach makes sure there is less delay between the actual body velocity and the one we saved.
 			PhysicsDirectBodyState2D *bs = PhysicsServer2D::get_singleton()->body_get_direct_state(platform_rid);
@@ -1095,7 +1095,7 @@ void CharacterBody2D::move_and_slide() {
 
 	// No sliding on first attempt to keep floor motion stable when possible,
 	// When stop on slope is enabled or when there is no up direction.
-	bool sliding_enabled = !stop_on_slope || up_direction == Vector2();
+	bool sliding_enabled = !floor_stop_on_slope || up_direction == Vector2();
 	// Constant speed can be applied only the first time sliding is enabled.
 	bool can_apply_constant_speed = sliding_enabled;
 	bool first_slide = true;
@@ -1115,12 +1115,12 @@ void CharacterBody2D::move_and_slide() {
 			motion_results.push_back(result);
 			_set_collision_direction(result);
 
-			if (on_floor && stop_on_slope && (linear_velocity.normalized() + up_direction).length() < 0.01) {
+			if (on_floor && floor_stop_on_slope && (linear_velocity.normalized() + up_direction).length() < 0.01) {
 				Transform2D gt = get_global_transform();
-				if (result.motion.length() > margin) {
-					gt.elements[2] -= result.motion.slide(up_direction);
+				if (result.travel.length() > margin) {
+					gt.elements[2] -= result.travel.slide(up_direction);
 				} else {
-					gt.elements[2] -= result.motion;
+					gt.elements[2] -= result.travel;
 				}
 				set_global_transform(gt);
 				linear_velocity = Vector2();
@@ -1134,14 +1134,14 @@ void CharacterBody2D::move_and_slide() {
 			}
 
 			// Move on floor only checks.
-			if (move_on_floor_only && on_wall && motion_slide_up.dot(result.collision_normal) <= 0) {
-				// Avoid to move forward on a wall if move_on_floor_only is true.
+			if (floor_block_on_wall && on_wall && motion_slide_up.dot(result.collision_normal) <= 0) {
+				// Avoid to move forward on a wall if floor_block_on_wall is true.
 				if (was_on_floor && !is_on_floor_only() && !vel_dir_facing_up) {
 					// If the movement is large the body can be prevented from reaching the walls.
-					if (result.motion.length() <= margin) {
+					if (result.travel.length() <= margin) {
 						// Cancels the motion.
 						Transform2D gt = get_global_transform();
-						gt.elements[2] -= result.motion;
+						gt.elements[2] -= result.travel;
 						set_global_transform(gt);
 					}
 					on_floor = true;
@@ -1163,11 +1163,11 @@ void CharacterBody2D::move_and_slide() {
 				}
 			}
 			// Constant Speed when the slope is upward.
-			else if (constant_speed_on_floor && is_on_floor_only() && can_apply_constant_speed && was_on_floor && motion.dot(result.collision_normal) < 0) {
+			else if (floor_constant_speed && is_on_floor_only() && can_apply_constant_speed && was_on_floor && motion.dot(result.collision_normal) < 0) {
 				can_apply_constant_speed = false;
 				Vector2 motion_slide_norm = result.remainder.slide(result.collision_normal).normalized();
 				if (!motion_slide_norm.is_equal_approx(Vector2())) {
-					motion = motion_slide_norm * (motion_slide_up.length() - result.motion.slide(up_direction).length() - last_travel.slide(up_direction).length());
+					motion = motion_slide_norm * (motion_slide_up.length() - result.travel.slide(up_direction).length() - last_travel.slide(up_direction).length());
 				}
 			}
 			// Regular sliding, the last part of the test handle the case when you don't want to slide on the ceiling.
@@ -1197,11 +1197,11 @@ void CharacterBody2D::move_and_slide() {
 				}
 			}
 
-			last_travel = result.motion;
+			last_travel = result.travel;
 		}
 		// When you move forward in a downward slope you don’t collide because you will be in the air.
 		// This test ensures that constant speed is applied, only if the player is still on the ground after the snap is applied.
-		else if (constant_speed_on_floor && first_slide && _on_floor_if_snapped(was_on_floor, vel_dir_facing_up)) {
+		else if (floor_constant_speed && first_slide && _on_floor_if_snapped(was_on_floor, vel_dir_facing_up)) {
 			can_apply_constant_speed = false;
 			sliding_enabled = true;
 			Transform2D gt = get_global_transform();
@@ -1235,6 +1235,8 @@ void CharacterBody2D::move_and_slide() {
 	if (on_floor && !vel_dir_facing_up) {
 		linear_velocity = linear_velocity.slide(up_direction);
 	}
+
+	return motion_results.size() > 0;
 }
 
 void CharacterBody2D::_snap_on_floor(bool was_on_floor, bool vel_dir_facing_up) {
@@ -1246,20 +1248,19 @@ void CharacterBody2D::_snap_on_floor(bool was_on_floor, bool vel_dir_facing_up)
 	PhysicsServer2D::MotionResult result;
 	if (move_and_collide(up_direction * -floor_snap_length, result, margin, true, false)) {
 		bool apply = true;
-		float collision_angle = Math::acos(result.collision_normal.dot(up_direction));
-		if (collision_angle <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+		if (result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
 			on_floor = true;
 			floor_normal = result.collision_normal;
 			platform_velocity = result.collider_velocity;
 			_set_platform_data(result);
 
-			if (stop_on_slope) {
+			if (floor_stop_on_slope) {
 				// move and collide may stray the object a bit because of pre un-stucking,
 				// so only ensure that motion happens on floor direction in this case.
-				if (result.motion.length() > margin) {
-					result.motion = up_direction * up_direction.dot(result.motion);
+				if (result.travel.length() > margin) {
+					result.travel = up_direction * up_direction.dot(result.travel);
 				} else {
-					result.motion = Vector2();
+					result.travel = Vector2();
 				}
 			}
 		} else {
@@ -1267,7 +1268,7 @@ void CharacterBody2D::_snap_on_floor(bool was_on_floor, bool vel_dir_facing_up)
 		}
 
 		if (apply) {
-			gt.elements[2] += result.motion;
+			gt.elements[2] += result.travel;
 			set_global_transform(gt);
 		}
 	}
@@ -1280,7 +1281,7 @@ bool CharacterBody2D::_on_floor_if_snapped(bool was_on_floor, bool vel_dir_facin
 
 	PhysicsServer2D::MotionResult result;
 	if (move_and_collide(up_direction * -floor_snap_length, result, margin, true, false)) {
-		if (Math::acos(result.collision_normal.dot(up_direction)) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+		if (result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
 			return true;
 		}
 	}
@@ -1293,12 +1294,12 @@ void CharacterBody2D::_set_collision_direction(const PhysicsServer2D::MotionResu
 		return;
 	}
 
-	if (Math::acos(p_result.collision_normal.dot(up_direction)) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //floor
+	if (p_result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //floor
 		on_floor = true;
 		floor_normal = p_result.collision_normal;
 		platform_velocity = p_result.collider_velocity;
 		_set_platform_data(p_result);
-	} else if (Math::acos(p_result.collision_normal.dot(-up_direction)) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //ceiling
+	} else if (p_result.get_angle(-up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //ceiling
 		on_ceiling = true;
 	} else {
 		on_wall = true;
@@ -1352,11 +1353,16 @@ Vector2 CharacterBody2D::get_floor_normal() const {
 	return floor_normal;
 }
 
+real_t CharacterBody2D::get_floor_angle(const Vector2 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector2(), 0);
+	return Math::acos(floor_normal.dot(p_up_direction));
+}
+
 Vector2 CharacterBody2D::get_platform_velocity() const {
 	return platform_velocity;
 }
 
-int CharacterBody2D::get_slide_count() const {
+int CharacterBody2D::get_slide_collision_count() const {
 	return motion_results.size();
 }
 
@@ -1380,6 +1386,13 @@ Ref<KinematicCollision2D> CharacterBody2D::_get_slide_collision(int p_bounce) {
 	return slide_colliders[p_bounce];
 }
 
+Ref<KinematicCollision2D> CharacterBody2D::_get_last_slide_collision() {
+	if (motion_results.size() == 0) {
+		return Ref<KinematicCollision2D>();
+	}
+	return _get_slide_collision(motion_results.size() - 1);
+}
+
 void CharacterBody2D::set_safe_margin(real_t p_margin) {
 	margin = p_margin;
 }
@@ -1388,28 +1401,28 @@ real_t CharacterBody2D::get_safe_margin() const {
 	return margin;
 }
 
-bool CharacterBody2D::is_stop_on_slope_enabled() const {
-	return stop_on_slope;
+bool CharacterBody2D::is_floor_stop_on_slope_enabled() const {
+	return floor_stop_on_slope;
 }
 
-void CharacterBody2D::set_stop_on_slope_enabled(bool p_enabled) {
-	stop_on_slope = p_enabled;
+void CharacterBody2D::set_floor_stop_on_slope_enabled(bool p_enabled) {
+	floor_stop_on_slope = p_enabled;
 }
 
-bool CharacterBody2D::is_constant_speed_on_floor_enabled() const {
-	return constant_speed_on_floor;
+bool CharacterBody2D::is_floor_constant_speed_enabled() const {
+	return floor_constant_speed;
 }
 
-void CharacterBody2D::set_constant_speed_on_floor_enabled(bool p_enabled) {
-	constant_speed_on_floor = p_enabled;
+void CharacterBody2D::set_floor_constant_speed_enabled(bool p_enabled) {
+	floor_constant_speed = p_enabled;
 }
 
-bool CharacterBody2D::is_move_on_floor_only_enabled() const {
-	return move_on_floor_only;
+bool CharacterBody2D::is_floor_block_on_wall_enabled() const {
+	return floor_block_on_wall;
 }
 
-void CharacterBody2D::set_move_on_floor_only_enabled(bool p_enabled) {
-	move_on_floor_only = p_enabled;
+void CharacterBody2D::set_floor_block_on_wall_enabled(bool p_enabled) {
+	floor_block_on_wall = p_enabled;
 }
 
 bool CharacterBody2D::is_slide_on_ceiling_enabled() const {
@@ -1420,12 +1433,12 @@ void CharacterBody2D::set_slide_on_ceiling_enabled(bool p_enabled) {
 	slide_on_ceiling = p_enabled;
 }
 
-uint32_t CharacterBody2D::get_exclude_body_layers() const {
-	return exclude_body_layers;
+uint32_t CharacterBody2D::get_moving_platform_ignore_layers() const {
+	return moving_platform_ignore_layers;
 }
 
-void CharacterBody2D::set_exclude_body_layers(uint32_t p_exclude_layers) {
-	exclude_body_layers = p_exclude_layers;
+void CharacterBody2D::set_moving_platform_ignore_layers(uint32_t p_exclude_layers) {
+	moving_platform_ignore_layers = p_exclude_layers;
 }
 
 int CharacterBody2D::get_max_slides() const {
@@ -1484,17 +1497,17 @@ void CharacterBody2D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_safe_margin", "pixels"), &CharacterBody2D::set_safe_margin);
 	ClassDB::bind_method(D_METHOD("get_safe_margin"), &CharacterBody2D::get_safe_margin);
-	ClassDB::bind_method(D_METHOD("is_stop_on_slope_enabled"), &CharacterBody2D::is_stop_on_slope_enabled);
-	ClassDB::bind_method(D_METHOD("set_stop_on_slope_enabled", "enabled"), &CharacterBody2D::set_stop_on_slope_enabled);
-	ClassDB::bind_method(D_METHOD("set_constant_speed_on_floor_enabled", "enabled"), &CharacterBody2D::set_constant_speed_on_floor_enabled);
-	ClassDB::bind_method(D_METHOD("is_constant_speed_on_floor_enabled"), &CharacterBody2D::is_constant_speed_on_floor_enabled);
-	ClassDB::bind_method(D_METHOD("set_move_on_floor_only_enabled", "enabled"), &CharacterBody2D::set_move_on_floor_only_enabled);
-	ClassDB::bind_method(D_METHOD("is_move_on_floor_only_enabled"), &CharacterBody2D::is_move_on_floor_only_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_stop_on_slope_enabled"), &CharacterBody2D::is_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_stop_on_slope_enabled", "enabled"), &CharacterBody2D::set_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_constant_speed_enabled", "enabled"), &CharacterBody2D::set_floor_constant_speed_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_constant_speed_enabled"), &CharacterBody2D::is_floor_constant_speed_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_block_on_wall_enabled", "enabled"), &CharacterBody2D::set_floor_block_on_wall_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_block_on_wall_enabled"), &CharacterBody2D::is_floor_block_on_wall_enabled);
 	ClassDB::bind_method(D_METHOD("set_slide_on_ceiling_enabled", "enabled"), &CharacterBody2D::set_slide_on_ceiling_enabled);
 	ClassDB::bind_method(D_METHOD("is_slide_on_ceiling_enabled"), &CharacterBody2D::is_slide_on_ceiling_enabled);
 
-	ClassDB::bind_method(D_METHOD("set_exclude_body_layers", "exclude_layer"), &CharacterBody2D::set_exclude_body_layers);
-	ClassDB::bind_method(D_METHOD("get_exclude_body_layers"), &CharacterBody2D::get_exclude_body_layers);
+	ClassDB::bind_method(D_METHOD("set_moving_platform_ignore_layers", "exclude_layer"), &CharacterBody2D::set_moving_platform_ignore_layers);
+	ClassDB::bind_method(D_METHOD("get_moving_platform_ignore_layers"), &CharacterBody2D::get_moving_platform_ignore_layers);
 
 	ClassDB::bind_method(D_METHOD("get_max_slides"), &CharacterBody2D::get_max_slides);
 	ClassDB::bind_method(D_METHOD("set_max_slides", "max_slides"), &CharacterBody2D::set_max_slides);
@@ -1512,21 +1525,24 @@ void CharacterBody2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_on_wall"), &CharacterBody2D::is_on_wall);
 	ClassDB::bind_method(D_METHOD("is_on_wall_only"), &CharacterBody2D::is_on_wall_only);
 	ClassDB::bind_method(D_METHOD("get_floor_normal"), &CharacterBody2D::get_floor_normal);
+	ClassDB::bind_method(D_METHOD("get_floor_angle", "up_direction"), &CharacterBody2D::get_floor_angle, DEFVAL(Vector2(0.0, -1.0)));
 	ClassDB::bind_method(D_METHOD("get_platform_velocity"), &CharacterBody2D::get_platform_velocity);
-	ClassDB::bind_method(D_METHOD("get_slide_count"), &CharacterBody2D::get_slide_count);
+	ClassDB::bind_method(D_METHOD("get_slide_collision_count"), &CharacterBody2D::get_slide_collision_count);
 	ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &CharacterBody2D::_get_slide_collision);
+	ClassDB::bind_method(D_METHOD("get_last_slide_collision"), &CharacterBody2D::_get_last_slide_collision);
 
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "linear_velocity"), "set_linear_velocity", "get_linear_velocity");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "stop_on_slope"), "set_stop_on_slope_enabled", "is_stop_on_slope_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "constant_speed_on_floor"), "set_constant_speed_on_floor_enabled", "is_constant_speed_on_floor_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "move_on_floor_only"), "set_move_on_floor_only_enabled", "is_move_on_floor_only_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "slide_on_ceiling"), "set_slide_on_ceiling_enabled", "is_slide_on_ceiling_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_slides", PROPERTY_HINT_RANGE, "1,8,1,or_greater"), "set_max_slides", "get_max_slides");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_slides", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_max_slides", "get_max_slides");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "up_direction"), "set_up_direction", "get_up_direction");
+	ADD_GROUP("Floor", "floor_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_stop_on_slope"), "set_floor_stop_on_slope_enabled", "is_floor_stop_on_slope_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_constant_speed"), "set_floor_constant_speed_enabled", "is_floor_constant_speed_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_block_on_wall"), "set_floor_block_on_wall_enabled", "is_floor_block_on_wall_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "floor_max_angle", PROPERTY_HINT_RANGE, "0,180,0.1,radians"), "set_floor_max_angle", "get_floor_max_angle");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "floor_snap_length", PROPERTY_HINT_RANGE, "0,1000,0.1"), "set_floor_snap_length", "get_floor_snap_length");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "up_direction"), "set_up_direction", "get_up_direction");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "exclude_body_layers", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_exclude_body_layers", "get_exclude_body_layers");
-
+	ADD_GROUP("Moving platform", "moving_platform");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "moving_platform_ignore_layers", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_moving_platform_ignore_layers", "get_moving_platform_ignore_layers");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision/safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), "set_safe_margin", "get_safe_margin");
 }
 
@@ -1553,13 +1569,18 @@ Vector2 KinematicCollision2D::get_normal() const {
 }
 
 Vector2 KinematicCollision2D::get_travel() const {
-	return result.motion;
+	return result.travel;
 }
 
 Vector2 KinematicCollision2D::get_remainder() const {
 	return result.remainder;
 }
 
+real_t KinematicCollision2D::get_angle(const Vector2 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector2(), 0);
+	return result.get_angle(p_up_direction);
+}
+
 Object *KinematicCollision2D::get_local_shape() const {
 	if (!owner) {
 		return nullptr;
@@ -1614,6 +1635,7 @@ void KinematicCollision2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_normal"), &KinematicCollision2D::get_normal);
 	ClassDB::bind_method(D_METHOD("get_travel"), &KinematicCollision2D::get_travel);
 	ClassDB::bind_method(D_METHOD("get_remainder"), &KinematicCollision2D::get_remainder);
+	ClassDB::bind_method(D_METHOD("get_angle", "up_direction"), &KinematicCollision2D::get_angle, DEFVAL(Vector2(0.0, -1.0)));
 	ClassDB::bind_method(D_METHOD("get_local_shape"), &KinematicCollision2D::get_local_shape);
 	ClassDB::bind_method(D_METHOD("get_collider"), &KinematicCollision2D::get_collider);
 	ClassDB::bind_method(D_METHOD("get_collider_id"), &KinematicCollision2D::get_collider_id);
diff --git a/scene/2d/physics_body_2d.h b/scene/2d/physics_body_2d.h
index 3d894416f0..81c5067146 100644
--- a/scene/2d/physics_body_2d.h
+++ b/scene/2d/physics_body_2d.h
@@ -271,16 +271,16 @@ class CharacterBody2D : public PhysicsBody2D {
 private:
 	real_t margin = 0.08;
 
-	bool stop_on_slope = false;
-	bool constant_speed_on_floor = false;
-	bool move_on_floor_only = true;
+	bool floor_stop_on_slope = false;
+	bool floor_constant_speed = false;
+	bool floor_block_on_wall = true;
 	bool slide_on_ceiling = true;
 	int max_slides = 4;
 	int platform_layer;
 	real_t floor_max_angle = Math::deg2rad((real_t)45.0);
 	float floor_snap_length = 0;
 	Vector2 up_direction = Vector2(0.0, -1.0);
-	uint32_t exclude_body_layers = 0;
+	uint32_t moving_platform_ignore_layers = 0;
 	Vector2 linear_velocity;
 
 	Vector2 floor_normal;
@@ -296,14 +296,14 @@ private:
 	void set_safe_margin(real_t p_margin);
 	real_t get_safe_margin() const;
 
-	bool is_stop_on_slope_enabled() const;
-	void set_stop_on_slope_enabled(bool p_enabled);
+	bool is_floor_stop_on_slope_enabled() const;
+	void set_floor_stop_on_slope_enabled(bool p_enabled);
 
-	bool is_constant_speed_on_floor_enabled() const;
-	void set_constant_speed_on_floor_enabled(bool p_enabled);
+	bool is_floor_constant_speed_enabled() const;
+	void set_floor_constant_speed_enabled(bool p_enabled);
 
-	bool is_move_on_floor_only_enabled() const;
-	void set_move_on_floor_only_enabled(bool p_enabled);
+	bool is_floor_block_on_wall_enabled() const;
+	void set_floor_block_on_wall_enabled(bool p_enabled);
 
 	bool is_slide_on_ceiling_enabled() const;
 	void set_slide_on_ceiling_enabled(bool p_enabled);
@@ -317,10 +317,11 @@ private:
 	real_t get_floor_snap_length();
 	void set_floor_snap_length(real_t p_floor_snap_length);
 
-	uint32_t get_exclude_body_layers() const;
-	void set_exclude_body_layers(const uint32_t p_exclude_layer);
+	uint32_t get_moving_platform_ignore_layers() const;
+	void set_moving_platform_ignore_layers(const uint32_t p_exclude_layer);
 
 	Ref<KinematicCollision2D> _get_slide_collision(int p_bounce);
+	Ref<KinematicCollision2D> _get_last_slide_collision();
 	const Vector2 &get_up_direction() const;
 	bool _on_floor_if_snapped(bool was_on_floor, bool vel_dir_facing_up);
 	void set_up_direction(const Vector2 &p_up_direction);
@@ -333,7 +334,7 @@ protected:
 	static void _bind_methods();
 
 public:
-	void move_and_slide();
+	bool move_and_slide();
 
 	const Vector2 &get_linear_velocity() const;
 	void set_linear_velocity(const Vector2 &p_velocity);
@@ -345,9 +346,10 @@ public:
 	bool is_on_ceiling() const;
 	bool is_on_ceiling_only() const;
 	Vector2 get_floor_normal() const;
+	real_t get_floor_angle(const Vector2 &p_up_direction = Vector2(0.0, -1.0)) const;
 	Vector2 get_platform_velocity() const;
 
-	int get_slide_count() const;
+	int get_slide_collision_count() const;
 	PhysicsServer2D::MotionResult get_slide_collision(int p_bounce) const;
 
 	CharacterBody2D();
@@ -370,6 +372,7 @@ public:
 	Vector2 get_normal() const;
 	Vector2 get_travel() const;
 	Vector2 get_remainder() const;
+	real_t get_angle(const Vector2 &p_up_direction = Vector2(0.0, -1.0)) const;
 	Object *get_local_shape() const;
 	Object *get_collider() const;
 	ObjectID get_collider_id() const;
diff --git a/scene/3d/physics_body_3d.cpp b/scene/3d/physics_body_3d.cpp
index aec0b3002c..610974ff90 100644
--- a/scene/3d/physics_body_3d.cpp
+++ b/scene/3d/physics_body_3d.cpp
@@ -140,27 +140,27 @@ bool PhysicsBody3D::move_and_collide(const Vector3 &p_motion, PhysicsServer3D::M
 			}
 
 			// Check depth of recovery.
-			real_t projected_length = r_result.motion.dot(motion_normal);
-			Vector3 recovery = r_result.motion - motion_normal * projected_length;
+			real_t projected_length = r_result.travel.dot(motion_normal);
+			Vector3 recovery = r_result.travel - motion_normal * projected_length;
 			real_t recovery_length = recovery.length();
 			// Fixes cases where canceling slide causes the motion to go too deep into the ground,
 			// because we're only taking rest information into account and not general recovery.
 			if (recovery_length < (real_t)p_margin + precision) {
 				// Apply adjustment to motion.
-				r_result.motion = motion_normal * projected_length;
-				r_result.remainder = p_motion - r_result.motion;
+				r_result.travel = motion_normal * projected_length;
+				r_result.remainder = p_motion - r_result.travel;
 			}
 		}
 	}
 
 	for (int i = 0; i < 3; i++) {
 		if (locked_axis & (1 << i)) {
-			r_result.motion[i] = 0;
+			r_result.travel[i] = 0;
 		}
 	}
 
 	if (!p_test_only) {
-		gt.origin += r_result.motion;
+		gt.origin += r_result.travel;
 		set_global_transform(gt);
 	}
 
@@ -1079,7 +1079,7 @@ void RigidBody3D::_reload_physics_characteristics() {
 //so, if you pass 45 as limit, avoid numerical precision errors when angle is 45.
 #define FLOOR_ANGLE_THRESHOLD 0.01
 
-void CharacterBody3D::move_and_slide() {
+bool CharacterBody3D::move_and_slide() {
 	Vector3 body_velocity_normal = linear_velocity.normalized();
 
 	bool was_on_floor = on_floor;
@@ -1126,7 +1126,7 @@ void CharacterBody3D::move_and_slide() {
 
 	// No sliding on first attempt to keep floor motion stable when possible,
 	// when stop on slope is enabled.
-	bool sliding_enabled = !stop_on_slope;
+	bool sliding_enabled = !floor_stop_on_slope;
 
 	for (int iteration = 0; iteration < max_slides; ++iteration) {
 		PhysicsServer3D::MotionResult result;
@@ -1141,17 +1141,17 @@ void CharacterBody3D::move_and_slide() {
 			motion_results.push_back(result);
 			_set_collision_direction(result);
 
-			if (on_floor && stop_on_slope) {
+			if (on_floor && floor_stop_on_slope) {
 				if ((body_velocity_normal + up_direction).length() < 0.01) {
 					Transform3D gt = get_global_transform();
-					if (result.motion.length() > margin) {
-						gt.origin -= result.motion.slide(up_direction);
+					if (result.travel.length() > margin) {
+						gt.origin -= result.travel.slide(up_direction);
 					} else {
-						gt.origin -= result.motion;
+						gt.origin -= result.travel;
 					}
 					set_global_transform(gt);
 					linear_velocity = Vector3();
-					return;
+					return true;
 				}
 			}
 
@@ -1181,39 +1181,39 @@ void CharacterBody3D::move_and_slide() {
 		linear_velocity += current_floor_velocity;
 	}
 
-	if (!was_on_floor || snap == Vector3()) {
-		return;
-	}
-
-	// Apply snap.
-	Transform3D gt = get_global_transform();
-	PhysicsServer3D::MotionResult result;
-	if (move_and_collide(snap, result, margin, true, false)) {
-		bool apply = true;
-		if (up_direction != Vector3()) {
-			if (Math::acos(result.collision_normal.dot(up_direction)) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
-				on_floor = true;
-				floor_normal = result.collision_normal;
-				on_floor_body = result.collider;
-				floor_velocity = result.collider_velocity;
-				if (stop_on_slope) {
-					// move and collide may stray the object a bit because of pre un-stucking,
-					// so only ensure that motion happens on floor direction in this case.
-					if (result.motion.length() > margin) {
-						result.motion = result.motion.project(up_direction);
-					} else {
-						result.motion = Vector3();
+	if (was_on_floor && snap != Vector3()) {
+		// Apply snap.
+		Transform3D gt = get_global_transform();
+		PhysicsServer3D::MotionResult result;
+		if (move_and_collide(snap, result, margin, true, false)) {
+			bool apply = true;
+			if (up_direction != Vector3()) {
+				if (result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) {
+					on_floor = true;
+					floor_normal = result.collision_normal;
+					on_floor_body = result.collider;
+					floor_velocity = result.collider_velocity;
+					if (floor_stop_on_slope) {
+						// move and collide may stray the object a bit because of pre un-stucking,
+						// so only ensure that motion happens on floor direction in this case.
+						if (result.travel.length() > margin) {
+							result.travel = result.travel.project(up_direction);
+						} else {
+							result.travel = Vector3();
+						}
 					}
+				} else {
+					apply = false; //snapped with floor direction, but did not snap to a floor, do not snap.
 				}
-			} else {
-				apply = false; //snapped with floor direction, but did not snap to a floor, do not snap.
 			}
-		}
-		if (apply) {
-			gt.origin += result.motion;
-			set_global_transform(gt);
+			if (apply) {
+				gt.origin += result.travel;
+				set_global_transform(gt);
+			}
 		}
 	}
+
+	return motion_results.size() > 0;
 }
 
 void CharacterBody3D::_set_collision_direction(const PhysicsServer3D::MotionResult &p_result) {
@@ -1221,12 +1221,12 @@ void CharacterBody3D::_set_collision_direction(const PhysicsServer3D::MotionResu
 		//all is a wall
 		on_wall = true;
 	} else {
-		if (Math::acos(p_result.collision_normal.dot(up_direction)) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //floor
+		if (p_result.get_angle(up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //floor
 			on_floor = true;
 			floor_normal = p_result.collision_normal;
 			on_floor_body = p_result.collider;
 			floor_velocity = p_result.collider_velocity;
-		} else if (Math::acos(p_result.collision_normal.dot(-up_direction)) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //ceiling
+		} else if (p_result.get_angle(-up_direction) <= floor_max_angle + FLOOR_ANGLE_THRESHOLD) { //ceiling
 			on_ceiling = true;
 		} else {
 			on_wall = true;
@@ -1256,23 +1256,40 @@ bool CharacterBody3D::is_on_floor() const {
 	return on_floor;
 }
 
+bool CharacterBody3D::is_on_floor_only() const {
+	return on_floor && !on_wall && !on_ceiling;
+}
+
 bool CharacterBody3D::is_on_wall() const {
 	return on_wall;
 }
 
+bool CharacterBody3D::is_on_wall_only() const {
+	return on_wall && !on_floor && !on_ceiling;
+}
+
 bool CharacterBody3D::is_on_ceiling() const {
 	return on_ceiling;
 }
 
+bool CharacterBody3D::is_on_ceiling_only() const {
+	return on_ceiling && !on_floor && !on_wall;
+}
+
 Vector3 CharacterBody3D::get_floor_normal() const {
 	return floor_normal;
 }
 
-Vector3 CharacterBody3D::get_floor_velocity() const {
+real_t CharacterBody3D::get_floor_angle(const Vector3 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector3(), 0);
+	return Math::acos(floor_normal.dot(p_up_direction));
+}
+
+Vector3 CharacterBody3D::get_platform_velocity() const {
 	return floor_velocity;
 }
 
-int CharacterBody3D::get_slide_count() const {
+int CharacterBody3D::get_slide_collision_count() const {
 	return motion_results.size();
 }
 
@@ -1296,12 +1313,19 @@ Ref<KinematicCollision3D> CharacterBody3D::_get_slide_collision(int p_bounce) {
 	return slide_colliders[p_bounce];
 }
 
-bool CharacterBody3D::is_stop_on_slope_enabled() const {
-	return stop_on_slope;
+Ref<KinematicCollision3D> CharacterBody3D::_get_last_slide_collision() {
+	if (motion_results.size() == 0) {
+		return Ref<KinematicCollision3D>();
+	}
+	return _get_slide_collision(motion_results.size() - 1);
 }
 
-void CharacterBody3D::set_stop_on_slope_enabled(bool p_enabled) {
-	stop_on_slope = p_enabled;
+bool CharacterBody3D::is_floor_stop_on_slope_enabled() const {
+	return floor_stop_on_slope;
+}
+
+void CharacterBody3D::set_floor_stop_on_slope_enabled(bool p_enabled) {
+	floor_stop_on_slope = p_enabled;
 }
 
 int CharacterBody3D::get_max_slides() const {
@@ -1359,8 +1383,8 @@ void CharacterBody3D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_safe_margin", "pixels"), &CharacterBody3D::set_safe_margin);
 	ClassDB::bind_method(D_METHOD("get_safe_margin"), &CharacterBody3D::get_safe_margin);
-	ClassDB::bind_method(D_METHOD("is_stop_on_slope_enabled"), &CharacterBody3D::is_stop_on_slope_enabled);
-	ClassDB::bind_method(D_METHOD("set_stop_on_slope_enabled", "enabled"), &CharacterBody3D::set_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("is_floor_stop_on_slope_enabled"), &CharacterBody3D::is_floor_stop_on_slope_enabled);
+	ClassDB::bind_method(D_METHOD("set_floor_stop_on_slope_enabled", "enabled"), &CharacterBody3D::set_floor_stop_on_slope_enabled);
 	ClassDB::bind_method(D_METHOD("get_max_slides"), &CharacterBody3D::get_max_slides);
 	ClassDB::bind_method(D_METHOD("set_max_slides", "max_slides"), &CharacterBody3D::set_max_slides);
 	ClassDB::bind_method(D_METHOD("get_floor_max_angle"), &CharacterBody3D::get_floor_max_angle);
@@ -1371,20 +1395,26 @@ void CharacterBody3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_up_direction", "up_direction"), &CharacterBody3D::set_up_direction);
 
 	ClassDB::bind_method(D_METHOD("is_on_floor"), &CharacterBody3D::is_on_floor);
+	ClassDB::bind_method(D_METHOD("is_on_floor_only"), &CharacterBody3D::is_on_floor_only);
 	ClassDB::bind_method(D_METHOD("is_on_ceiling"), &CharacterBody3D::is_on_ceiling);
+	ClassDB::bind_method(D_METHOD("is_on_ceiling_only"), &CharacterBody3D::is_on_ceiling_only);
 	ClassDB::bind_method(D_METHOD("is_on_wall"), &CharacterBody3D::is_on_wall);
+	ClassDB::bind_method(D_METHOD("is_on_wall_only"), &CharacterBody3D::is_on_wall_only);
 	ClassDB::bind_method(D_METHOD("get_floor_normal"), &CharacterBody3D::get_floor_normal);
-	ClassDB::bind_method(D_METHOD("get_floor_velocity"), &CharacterBody3D::get_floor_velocity);
+	ClassDB::bind_method(D_METHOD("get_floor_angle", "up_direction"), &CharacterBody3D::get_floor_angle, DEFVAL(Vector3(0.0, 1.0, 0.0)));
+	ClassDB::bind_method(D_METHOD("get_platform_velocity"), &CharacterBody3D::get_platform_velocity);
 
-	ClassDB::bind_method(D_METHOD("get_slide_count"), &CharacterBody3D::get_slide_count);
+	ClassDB::bind_method(D_METHOD("get_slide_collision_count"), &CharacterBody3D::get_slide_collision_count);
 	ClassDB::bind_method(D_METHOD("get_slide_collision", "slide_idx"), &CharacterBody3D::_get_slide_collision);
+	ClassDB::bind_method(D_METHOD("get_last_slide_collision"), &CharacterBody3D::_get_last_slide_collision);
 
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "linear_velocity"), "set_linear_velocity", "get_linear_velocity");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "stop_on_slope"), "set_stop_on_slope_enabled", "is_stop_on_slope_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_slides", PROPERTY_HINT_RANGE, "1,8,1,or_greater"), "set_max_slides", "get_max_slides");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "floor_max_angle", PROPERTY_HINT_RANGE, "0,180,0.1,radians"), "set_floor_max_angle", "get_floor_max_angle");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_slides", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_max_slides", "get_max_slides");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap"), "set_snap", "get_snap");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "up_direction"), "set_up_direction", "get_up_direction");
+	ADD_GROUP("Floor", "floor_");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "floor_max_angle", PROPERTY_HINT_RANGE, "0,180,0.1,radians"), "set_floor_max_angle", "get_floor_max_angle");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "floor_stop_on_slope"), "set_floor_stop_on_slope_enabled", "is_floor_stop_on_slope_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision/safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), "set_safe_margin", "get_safe_margin");
 }
 
@@ -1411,13 +1441,18 @@ Vector3 KinematicCollision3D::get_normal() const {
 }
 
 Vector3 KinematicCollision3D::get_travel() const {
-	return result.motion;
+	return result.travel;
 }
 
 Vector3 KinematicCollision3D::get_remainder() const {
 	return result.remainder;
 }
 
+real_t KinematicCollision3D::get_angle(const Vector3 &p_up_direction) const {
+	ERR_FAIL_COND_V(p_up_direction == Vector3(), 0);
+	return result.get_angle(p_up_direction);
+}
+
 Object *KinematicCollision3D::get_local_shape() const {
 	if (!owner) {
 		return nullptr;
@@ -1472,6 +1507,7 @@ void KinematicCollision3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_normal"), &KinematicCollision3D::get_normal);
 	ClassDB::bind_method(D_METHOD("get_travel"), &KinematicCollision3D::get_travel);
 	ClassDB::bind_method(D_METHOD("get_remainder"), &KinematicCollision3D::get_remainder);
+	ClassDB::bind_method(D_METHOD("get_angle", "up_direction"), &KinematicCollision3D::get_angle, DEFVAL(Vector3(0.0, 1.0, 0.0)));
 	ClassDB::bind_method(D_METHOD("get_local_shape"), &KinematicCollision3D::get_local_shape);
 	ClassDB::bind_method(D_METHOD("get_collider"), &KinematicCollision3D::get_collider);
 	ClassDB::bind_method(D_METHOD("get_collider_id"), &KinematicCollision3D::get_collider_id);
diff --git a/scene/3d/physics_body_3d.h b/scene/3d/physics_body_3d.h
index b076560ead..9c40f92f06 100644
--- a/scene/3d/physics_body_3d.h
+++ b/scene/3d/physics_body_3d.h
@@ -278,7 +278,7 @@ class CharacterBody3D : public PhysicsBody3D {
 private:
 	real_t margin = 0.001;
 
-	bool stop_on_slope = false;
+	bool floor_stop_on_slope = false;
 	int max_slides = 4;
 	real_t floor_max_angle = Math::deg2rad((real_t)45.0);
 	Vector3 snap;
@@ -296,14 +296,15 @@ private:
 	Vector<Ref<KinematicCollision3D>> slide_colliders;
 
 	Ref<KinematicCollision3D> _get_slide_collision(int p_bounce);
+	Ref<KinematicCollision3D> _get_last_slide_collision();
 
 	void _set_collision_direction(const PhysicsServer3D::MotionResult &p_result);
 
 	void set_safe_margin(real_t p_margin);
 	real_t get_safe_margin() const;
 
-	bool is_stop_on_slope_enabled() const;
-	void set_stop_on_slope_enabled(bool p_enabled);
+	bool is_floor_stop_on_slope_enabled() const;
+	void set_floor_stop_on_slope_enabled(bool p_enabled);
 
 	int get_max_slides() const;
 	void set_max_slides(int p_max_slides);
@@ -322,18 +323,22 @@ protected:
 	static void _bind_methods();
 
 public:
-	void move_and_slide();
+	bool move_and_slide();
 
 	virtual Vector3 get_linear_velocity() const override;
 	void set_linear_velocity(const Vector3 &p_velocity);
 
 	bool is_on_floor() const;
+	bool is_on_floor_only() const;
 	bool is_on_wall() const;
+	bool is_on_wall_only() const;
 	bool is_on_ceiling() const;
+	bool is_on_ceiling_only() const;
 	Vector3 get_floor_normal() const;
-	Vector3 get_floor_velocity() const;
+	real_t get_floor_angle(const Vector3 &p_up_direction = Vector3(0.0, 1.0, 0.0)) const;
+	Vector3 get_platform_velocity() const;
 
-	int get_slide_count() const;
+	int get_slide_collision_count() const;
 	PhysicsServer3D::MotionResult get_slide_collision(int p_bounce) const;
 
 	CharacterBody3D();
@@ -356,6 +361,7 @@ public:
 	Vector3 get_normal() const;
 	Vector3 get_travel() const;
 	Vector3 get_remainder() const;
+	real_t get_angle(const Vector3 &p_up_direction = Vector3(0.0, 1.0, 0.0)) const;
 	Object *get_local_shape() const;
 	Object *get_collider() const;
 	ObjectID get_collider_id() const;