Add latest changes added in the 3D version

1 files changed, 84 insertions, 28 deletions

diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
index d34a1e1c62..09bcbdbf0f 100644
--- a/scene/2d/physics_body_2d.cpp
+++ b/scene/2d/physics_body_2d.cpp
@@ -1052,6 +1052,8 @@ bool CharacterBody2D::move_and_slide() {
 	double delta = Engine::get_singleton()->is_in_physics_frame() ? get_physics_process_delta_time() : get_process_delta_time();
 
 	Vector2 current_platform_velocity = platform_velocity;
+	Transform2D gt = get_global_transform();
+	previous_position = gt.elements[2];
 
 	if ((on_floor || on_wall) && platform_rid.is_valid()) {
 		bool excluded = false;
@@ -1064,7 +1066,6 @@ bool CharacterBody2D::move_and_slide() {
 			//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);
 			if (bs) {
-				Transform2D gt = get_global_transform();
 				Vector2 local_position = gt.elements[2] - bs->get_transform().elements[2];
 				current_platform_velocity = bs->get_velocity_at_local_position(local_position);
 			}
@@ -1074,6 +1075,7 @@ bool CharacterBody2D::move_and_slide() {
 	}
 
 	motion_results.clear();
+	last_motion = Vector2();
 
 	bool was_on_floor = on_floor;
 	on_floor = false;
@@ -1096,16 +1098,24 @@ bool CharacterBody2D::move_and_slide() {
 		_move_and_slide_free(delta);
 	}
 
-	if (!on_floor && !on_wall) {
+	// Compute real velocity.
+	real_velocity = get_position_delta() / delta;
+
+	if (moving_platform_apply_velocity_on_leave != PLATFORM_VEL_ON_LEAVE_NEVER) {
 		// Add last platform velocity when just left a moving platform.
-		linear_velocity += current_platform_velocity;
+		if (!on_floor && !on_wall) {
+			if (moving_platform_apply_velocity_on_leave == PLATFORM_VEL_ON_LEAVE_UPWARD_ONLY && current_platform_velocity.dot(up_direction) < 0) {
+				current_platform_velocity = current_platform_velocity.slide(up_direction);
+			}
+			motion_velocity += current_platform_velocity;
+		}
 	}
 
 	return motion_results.size() > 0;
 }
 
 void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_floor, const Vector2 &p_prev_platform_velocity) {
-	Vector2 motion = linear_velocity * p_delta;
+	Vector2 motion = motion_velocity * p_delta;
 	Vector2 motion_slide_up = motion.slide(up_direction);
 
 	Vector2 prev_floor_normal = floor_normal;
@@ -1122,7 +1132,7 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 	// Constant speed can be applied only the first time sliding is enabled.
 	bool can_apply_constant_speed = sliding_enabled;
 	bool first_slide = true;
-	bool vel_dir_facing_up = linear_velocity.dot(up_direction) > 0;
+	bool vel_dir_facing_up = motion_velocity.dot(up_direction) > 0;
 	Vector2 last_travel;
 
 	for (int iteration = 0; iteration < max_slides; ++iteration) {
@@ -1131,18 +1141,20 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 		Vector2 prev_position = get_global_transform().elements[2];
 
 		bool collided = move_and_collide(motion, result, margin, false, !sliding_enabled);
+		last_motion = result.travel;
 
 		if (collided) {
 			motion_results.push_back(result);
 			_set_collision_direction(result);
 
-			if (on_floor && floor_stop_on_slope && (linear_velocity.normalized() + up_direction).length() < 0.01) {
+			if (on_floor && floor_stop_on_slope && (motion_velocity.normalized() + up_direction).length() < 0.01) {
 				Transform2D gt = get_global_transform();
 				if (result.travel.length() <= margin + CMP_EPSILON) {
 					gt.elements[2] -= result.travel;
 				}
 				set_global_transform(gt);
-				linear_velocity = Vector2();
+				motion_velocity = Vector2();
+				last_motion = Vector2();
 				motion = Vector2();
 				break;
 			}
@@ -1168,7 +1180,8 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 					platform_layer = prev_platform_layer;
 					platform_velocity = p_prev_platform_velocity;
 					floor_normal = prev_floor_normal;
-					linear_velocity = Vector2();
+					motion_velocity = Vector2();
+					last_motion = Vector2();
 					motion = Vector2();
 					break;
 				}
@@ -1189,7 +1202,7 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 			// Regular sliding, the last part of the test handle the case when you don't want to slide on the ceiling.
 			else if ((sliding_enabled || !on_floor) && (!on_ceiling || slide_on_ceiling || !vel_dir_facing_up)) {
 				Vector2 slide_motion = result.remainder.slide(result.collision_normal);
-				if (slide_motion.dot(linear_velocity) > 0.0) {
+				if (slide_motion.dot(motion_velocity) > 0.0) {
 					motion = slide_motion;
 				} else {
 					motion = Vector2();
@@ -1197,10 +1210,10 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 				if (slide_on_ceiling && on_ceiling) {
 					// Apply slide only in the direction of the input motion, otherwise just stop to avoid jittering when moving against a wall.
 					if (vel_dir_facing_up) {
-						linear_velocity = linear_velocity.slide(result.collision_normal);
+						motion_velocity = motion_velocity.slide(result.collision_normal);
 					} else {
 						// Avoid acceleration in slope when falling.
-						linear_velocity = up_direction * up_direction.dot(linear_velocity);
+						motion_velocity = up_direction * up_direction.dot(motion_velocity);
 					}
 				}
 			}
@@ -1208,7 +1221,7 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 			else {
 				motion = result.remainder;
 				if (on_ceiling && !slide_on_ceiling && vel_dir_facing_up) {
-					linear_velocity = linear_velocity.slide(up_direction);
+					motion_velocity = motion_velocity.slide(up_direction);
 					motion = motion.slide(up_direction);
 				}
 			}
@@ -1242,12 +1255,12 @@ void CharacterBody2D::_move_and_slide_grounded(double p_delta, bool p_was_on_flo
 
 	// Reset the gravity accumulation when touching the ground.
 	if (on_floor && !vel_dir_facing_up) {
-		linear_velocity = linear_velocity.slide(up_direction);
+		motion_velocity = motion_velocity.slide(up_direction);
 	}
 }
 
 void CharacterBody2D::_move_and_slide_free(double p_delta) {
-	Vector2 motion = linear_velocity * p_delta;
+	Vector2 motion = motion_velocity * p_delta;
 
 	platform_rid = RID();
 	floor_normal = Vector2();
@@ -1258,12 +1271,18 @@ void CharacterBody2D::_move_and_slide_free(double p_delta) {
 		PhysicsServer2D::MotionResult result;
 
 		bool collided = move_and_collide(motion, result, margin, false, false);
+		last_motion = result.travel;
 
 		if (collided) {
 			motion_results.push_back(result);
 			_set_collision_direction(result);
 
-			if (free_mode_min_slide_angle != 0 && result.get_angle(-linear_velocity.normalized()) < free_mode_min_slide_angle + FLOOR_ANGLE_THRESHOLD) {
+			if (result.remainder.is_equal_approx(Vector2())) {
+				motion = Vector2();
+				break;
+			}
+
+			if (free_mode_min_slide_angle != 0 && result.get_angle(-motion_velocity.normalized()) < free_mode_min_slide_angle + FLOOR_ANGLE_THRESHOLD) {
 				motion = Vector2();
 			} else if (first_slide) {
 				Vector2 motion_slide_norm = result.remainder.slide(result.collision_normal).normalized();
@@ -1272,16 +1291,16 @@ void CharacterBody2D::_move_and_slide_free(double p_delta) {
 				motion = result.remainder.slide(result.collision_normal);
 			}
 
-			if (motion.dot(linear_velocity) <= 0.0) {
+			if (motion.dot(motion_velocity) <= 0.0) {
 				motion = Vector2();
 			}
 		}
 
-		first_slide = false;
-
 		if (!collided || motion.is_equal_approx(Vector2())) {
 			break;
 		}
+
+		first_slide = false;
 	}
 }
 
@@ -1349,6 +1368,7 @@ void CharacterBody2D::_set_collision_direction(const PhysicsServer2D::MotionResu
 		on_ceiling = true;
 	} else {
 		on_wall = true;
+		wall_normal = p_result.collision_normal;
 		// Don't apply wall velocity when the collider is a CharacterBody2D.
 		if (Object::cast_to<CharacterBody2D>(ObjectDB::get_instance(p_result.collider_id)) == nullptr) {
 			_set_platform_data(p_result);
@@ -1362,12 +1382,12 @@ void CharacterBody2D::_set_platform_data(const PhysicsServer2D::MotionResult &p_
 	platform_layer = PhysicsServer2D::get_singleton()->body_get_collision_layer(platform_rid);
 }
 
-const Vector2 &CharacterBody2D::get_linear_velocity() const {
-	return linear_velocity;
+const Vector2 &CharacterBody2D::get_motion_velocity() const {
+	return motion_velocity;
 }
 
-void CharacterBody2D::set_linear_velocity(const Vector2 &p_velocity) {
-	linear_velocity = p_velocity;
+void CharacterBody2D::set_motion_velocity(const Vector2 &p_velocity) {
+	motion_velocity = p_velocity;
 }
 
 bool CharacterBody2D::is_on_floor() const {
@@ -1394,16 +1414,32 @@ bool CharacterBody2D::is_on_ceiling_only() const {
 	return on_ceiling && !on_floor && !on_wall;
 }
 
-Vector2 CharacterBody2D::get_floor_normal() const {
+const Vector2 &CharacterBody2D::get_floor_normal() const {
 	return floor_normal;
 }
 
+const Vector2 &CharacterBody2D::get_wall_normal() const {
+	return wall_normal;
+}
+
+const Vector2 &CharacterBody2D::get_last_motion() const {
+	return last_motion;
+}
+
+Vector2 CharacterBody2D::get_position_delta() const {
+	return get_global_transform().elements[2] - previous_position;
+}
+
+const Vector2 &CharacterBody2D::get_real_velocity() const {
+	return real_velocity;
+}
+
 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 {
+const Vector2 &CharacterBody2D::get_platform_velocity() const {
 	return platform_velocity;
 }
 
@@ -1503,6 +1539,14 @@ CharacterBody2D::MotionMode CharacterBody2D::get_motion_mode() const {
 	return motion_mode;
 }
 
+void CharacterBody2D::set_moving_platform_apply_velocity_on_leave(MovingPlatformApplyVelocityOnLeave p_on_leave_apply_velocity) {
+	moving_platform_apply_velocity_on_leave = p_on_leave_apply_velocity;
+}
+
+CharacterBody2D::MovingPlatformApplyVelocityOnLeave CharacterBody2D::get_moving_platform_apply_velocity_on_leave() const {
+	return moving_platform_apply_velocity_on_leave;
+}
+
 int CharacterBody2D::get_max_slides() const {
 	return max_slides;
 }
@@ -1563,8 +1607,8 @@ void CharacterBody2D::_notification(int p_what) {
 void CharacterBody2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("move_and_slide"), &CharacterBody2D::move_and_slide);
 
-	ClassDB::bind_method(D_METHOD("set_linear_velocity", "linear_velocity"), &CharacterBody2D::set_linear_velocity);
-	ClassDB::bind_method(D_METHOD("get_linear_velocity"), &CharacterBody2D::get_linear_velocity);
+	ClassDB::bind_method(D_METHOD("set_motion_velocity", "motion_velocity"), &CharacterBody2D::set_motion_velocity);
+	ClassDB::bind_method(D_METHOD("get_motion_velocity"), &CharacterBody2D::get_motion_velocity);
 
 	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);
@@ -1594,6 +1638,8 @@ void CharacterBody2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_up_direction", "up_direction"), &CharacterBody2D::set_up_direction);
 	ClassDB::bind_method(D_METHOD("set_motion_mode", "mode"), &CharacterBody2D::set_motion_mode);
 	ClassDB::bind_method(D_METHOD("get_motion_mode"), &CharacterBody2D::get_motion_mode);
+	ClassDB::bind_method(D_METHOD("set_moving_platform_apply_velocity_on_leave", "on_leave_apply_velocity"), &CharacterBody2D::set_moving_platform_apply_velocity_on_leave);
+	ClassDB::bind_method(D_METHOD("get_moving_platform_apply_velocity_on_leave"), &CharacterBody2D::get_moving_platform_apply_velocity_on_leave);
 
 	ClassDB::bind_method(D_METHOD("is_on_floor"), &CharacterBody2D::is_on_floor);
 	ClassDB::bind_method(D_METHOD("is_on_floor_only"), &CharacterBody2D::is_on_floor_only);
@@ -1602,6 +1648,10 @@ 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_wall_normal"), &CharacterBody2D::get_wall_normal);
+	ClassDB::bind_method(D_METHOD("get_last_motion"), &CharacterBody2D::get_last_motion);
+	ClassDB::bind_method(D_METHOD("get_position_delta"), &CharacterBody2D::get_position_delta);
+	ClassDB::bind_method(D_METHOD("get_real_velocity"), &CharacterBody2D::get_real_velocity);
 	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_collision_count"), &CharacterBody2D::get_slide_collision_count);
@@ -1609,10 +1659,11 @@ void CharacterBody2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_last_slide_collision"), &CharacterBody2D::_get_last_slide_collision);
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "motion_mode", PROPERTY_HINT_ENUM, "Grounded,Free", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), "set_motion_mode", "get_motion_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "linear_velocity"), "set_linear_velocity", "get_linear_velocity");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "up_direction"), "set_up_direction", "get_up_direction");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "motion_velocity", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_motion_velocity", "get_motion_velocity");
 	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_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("Free Mode", "free_mode_");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "free_mode_min_slide_angle", PROPERTY_HINT_RANGE, "0,180,0.1,radians", PROPERTY_USAGE_DEFAULT), "set_free_mode_min_slide_angle", "get_free_mode_min_slide_angle");
 	ADD_GROUP("Floor", "floor_");
@@ -1622,12 +1673,17 @@ void CharacterBody2D::_bind_methods() {
 	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,32,0.1,or_greater"), "set_floor_snap_length", "get_floor_snap_length");
 	ADD_GROUP("Moving platform", "moving_platform");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "moving_platform_apply_velocity_on_leave", PROPERTY_HINT_ENUM, "Always,Upward Only,Never", PROPERTY_USAGE_DEFAULT), "set_moving_platform_apply_velocity_on_leave", "get_moving_platform_apply_velocity_on_leave");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "moving_platform_floor_layers", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_moving_platform_floor_layers", "get_moving_platform_floor_layers");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "moving_platform_wall_layers", PROPERTY_HINT_LAYERS_2D_PHYSICS), "set_moving_platform_wall_layers", "get_moving_platform_wall_layers");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "collision/safe_margin", PROPERTY_HINT_RANGE, "0.001,256,0.001"), "set_safe_margin", "get_safe_margin");
 
 	BIND_ENUM_CONSTANT(MOTION_MODE_GROUNDED);
 	BIND_ENUM_CONSTANT(MOTION_MODE_FREE);
+
+	BIND_ENUM_CONSTANT(PLATFORM_VEL_ON_LEAVE_ALWAYS);
+	BIND_ENUM_CONSTANT(PLATFORM_VEL_ON_LEAVE_UPWARD_ONLY);
+	BIND_ENUM_CONSTANT(PLATFORM_VEL_ON_LEAVE_NEVER);
 }
 
 void CharacterBody2D::_validate_property(PropertyInfo &property) const {