lib/classes/movement_state_receiver.gd

@@ -154,12 +154,22 @@ func _on_modifiers_updated(_modifier_type :int, _modifier_action :int, _merged_m
 #var calc_inertia = velocity.abs()
 #var calc_inertial_dir :Vector2
 var debug_speed_tracker :Vector2
-var impulse_applied_dir :float = 0.0
-var impulse_applied :bool = false
 func new_move_actor_as_desired(_delta :float,
 		_state :StateAnimatedActor,
 		_movement_override_normal := Vector2(0,0),
 		_velocity_override := Vector2(0,0)) -> Vector2:
+	## Calculated movement speed.
+	# var movement_params :Dictionary = {
+	# 	"_base_h_move_speed" : _state.horizontal_speed,
+	# 	"_base_h_move_acceleration" : _state.horizontal_acceleration,
+	# 	"_base_h_move_speed_modifier" : _state.horizontal_speed_offset,
+	# 	"_base_h_move_modifier_move_acceleration" : _state.horizontal_speed_offset_acceleration,
+	# 	"_jerk_factor" : _state.jerk_factor,
+	# 	"_gravity" : _state.gravity
+	# }
+	var movement_parameters :MovementParameters = _state.get_movement_parameters()
+	if modifier:
+		movement_parameters.apply_state_modifier(modifier)
 
 	var calc_velocity = Vector2.ZERO
 	if _velocity_override.x != 0.0:
@@ -173,18 +183,21 @@ func new_move_actor_as_desired(_delta :float,
 
 	var calc_acceleration = Vector2.ZERO
 	var calc_inertia :Vector2
-	#calc_inertia.x = abs(calc_velocity.x)
+	calc_inertia.x = abs(calc_velocity.x)
-	## We're now toing to preserve inertia direction
-	calc_inertia.x = calc_velocity.x
 	calc_inertia.y = calc_velocity.y
 	
 	var calc_inertial_dir = Vector2(sign(calc_velocity.x),sign(calc_velocity.y))
-	#var calc_friction :Vector2 = Vector2.ZERO
+	var calc_friction :Vector2 = Vector2.ZERO
 	
-	## Determine movement direction
+	## Inertia only applies if there is a difference between the 
-	# If there is an inertia direction from existing velocity and 
+	# base move speed and a derived move speed. This makes it so all you
-	# no desired movement we'll continue to travel in that direction.
+	# have to do is provide a move speed and that is the speed we will travel.
+	# but if a modifier applies, or an accelleration is given.
+	# an entirely differant process occurs.
 	##
+	var h_speed = resolve_h_speed(movement_parameters)
+	#if h_speed != Vector2.ZERO:
+	#	pass
 	## If an override has been passed (we're ignoring input direction
 	var move_direction = Vector2.ZERO
 	if _movement_override_normal != Vector2.ZERO:
@@ -192,106 +205,96 @@ func new_move_actor_as_desired(_delta :float,
 	else:
 		move_direction = resolve_move_direction(calc_inertial_dir, desired_movement_vector)
 
-	if move_direction.x != 0.0 or sign(calc_velocity.x) != impulse_applied_dir:
+	## Which direction will acceleration be applied. 
-		impulse_applied = false
+	calc_acceleration.x = resolve_h_acceleration(movement_parameters, calc_velocity, move_direction.x)
-		impulse_applied_dir = sign(calc_velocity.x)
-		
-
-	var movement_parameters :MovementParameters = _state.get_movement_parameters()
-	if modifier and modifier.is_active:
-		movement_parameters.apply_state_modifier(modifier)
-
-	## Inertia only applies if there is a difference between the 
-	# base move speed and a derived move speed. This makes it so all you
-	# have to do is provide a move speed and that is the speed we will travel.
-	# but if a modifier applies, or an accelleration is given.
-	# an entirely differant process occurs.
-	# h_speed.x can be thought of as impulse speed. While h_speed.y
-	# is the destination speed. 
-	# We move towards h_speed.y at the acceleration rate
-	##
-	var h_speed = resolve_h_speed(movement_parameters)
-	## Speed will now be expected to move in the direction of travel
-	h_speed *= move_direction.x
-	
-	## We don't want to be able to scoot our impulse speed to cheat the movement
-	# Any non zero speed that goes opposite to our inertial direction
-	# should only be allowed once. 
-
-	## Acceleration is always postive because we use the 
-	# move toward functions.
-	calc_acceleration.x = abs(resolve_h_acceleration(movement_parameters, move_direction.x))
 
 	## Direction of inertia not equal to move direction
 	## If inertia is applying in a direction
-#	if calc_inertial_dir.x: 
+	if calc_inertial_dir.x: 
-#		## And it doesn't apply in the same direction as our movement direction
+		## And it doesn't apply in the same direction as our movement direction
-#		if calc_inertial_dir.x != sign(move_direction.x):
+		if calc_inertial_dir.x != sign(move_direction.x):
-#			## Apply the direction of acceleration and apply as friction
+			## Apply the direction of acceleration and apply as friction
-#			# Friction allows the inertia to trend toward 0 instead of the
+			# Friction allows the inertia to trend toward 0 instead of the
-#			# 'To' direction of speed.
+			# 'To' direction of speed.
-#			##
+			##
-#			#calc_friction.x = calc_acceleration.x * -1
+			#calc_friction.x = calc_acceleration.x * -1
-#			calc_friction.x = abs(calc_acceleration.x)
+			calc_friction.x = abs(calc_acceleration.x)
-#			calc_acceleration.x = 0.0
+			calc_acceleration.x = 0.0
 			
 
 	## We are always moving from h_speed.x towards y at a given rate
-	## if we have a difference of speed and an acceleration
+	## if we have a difference of speed
-	if h_speed.x != h_speed.y and calc_acceleration.x != 0.0:
+	if h_speed.x != h_speed.y:
-
-		## Start speed really shouldn't be less than zero (modifiers can do this)
-		## If we have mismatched signs we'll get really bad behavior
-		if sign(h_speed.y) != sign(h_speed.x):
-			if h_speed.x < h_speed.y:
-				h_speed.x = clamp(h_speed.x, 0.0, h_speed.y)
-			else:
-				h_speed.y = clamp(h_speed.y, 0.0, h_speed.x)
-
-		##TODO: Find a better way to apply impulse on target velocity changes.
-		## Determine whether we should apply impulse
-		## If there is currently no inertia apply the base h_speed
-		## If the direction of our inertia is different to our intended speed direction
-		# and the inertia is not already in range of the movement speed, apply impulse.
-		# range part is working but we need to also apply it when we have zero 
-		# velocity, hopefully we're at full stop at this point
-		##
-		if sign(calc_inertia.x) != sign(h_speed.x):
-			## Only if inertia is not already in range. 
-#			if calc_inertia.x <= h_speed.x or calc_inertia.x >= h_speed.y:
-			if is_out_of_range(calc_inertia.x, h_speed.x, h_speed.y) or h_speed != debug_speed_tracker:
-				## ? But we only want to do this once though. 
-				if impulse_applied == false:
-					print("Movement Impulse applied: ", h_speed.x)
-					calc_inertia.x += h_speed.x
-					impulse_applied = true
-					impulse_applied_dir = move_direction.x
 		debug_speed_tracker = h_speed
-#		elif calc_inertia.x != 0.0:
+		## Clamp inertia to in between speed.
-#			##WIP: attempts to apply start speed only once
+		# Problem is that we can suddenly gain or lose inertia.
-#			if h_speed.x < h_speed.y:
+		##
-#				if calc_inertia.x < h_speed.x and sign(move_direction.x) == calc_inertial_dir.x:
+#		calc_inertia.x = clamp( calc_inertia.x + (calc_acceleration.x * _delta),
-#					calc_inertia.x = h_speed.x
+#							h_speed.x , h_speed.y)
-#			elif h_speed.x > h_speed.y:
+		## Start speed really shouldn't be less than zero (modifiers can do this)
-#				if calc_inertia.x > h_speed.x and sign(move_direction.x) == calc_inertial_dir.x:
+		if h_speed.x < h_speed.y:
-#					calc_inertia.x = h_speed.x
+			h_speed.x = clamp(h_speed.x,0.0,h_speed.y)
+		## If there is currently no inertia apply the base h_speed
+		if calc_inertia.x == 0.0:
+			calc_inertia.x = h_speed.x
+		elif calc_inertia.x != 0.0:
+			##WIP: attempts to apply start speed only once
+			if h_speed.x < h_speed.y:
+				if calc_inertia.x < h_speed.x and sign(move_direction.x) == calc_inertial_dir.x:
+					calc_inertia.x = h_speed.x
+			elif h_speed.x > h_speed.y:
+				if calc_inertia.x > h_speed.x and sign(move_direction.x) == calc_inertial_dir.x:
+					calc_inertia.x = h_speed.x
+
+		## Apply acceleration 
+		calc_inertia.x = move_toward(calc_inertia.x, h_speed.y, abs(calc_acceleration.x * _delta))
+		## Apply friction
+		calc_inertia.x = move_toward(calc_inertia.x, 0, abs(calc_friction.x * _delta))
 		
 		if modifier and modifier.is_active:
 			var foo = 2+2 # breakpoint check
 		
-		## Apply acceleration 
+		## Working but trying something new:
-		calc_inertia.x = move_toward(calc_inertia.x, h_speed.y, calc_acceleration.x * _delta)
+#		if h_speed.y > h_speed.x:
-		## Apply friction
+#			calc_inertia.x = move_toward(calc_inertia.x, h_speed.y, (calc_acceleration.x * _delta))
-		#calc_inertia.x = move_toward(calc_inertia.x, 0, abs(calc_friction.x * _delta))
+#		else:
+#			## use of move_toward forcing need to apply negative accel as postitive.
+#			#calc_inertia.x = move_toward(calc_inertia.x, h_speed.y, abs(calc_acceleration.x * _delta))
+#			calc_inertia.x = clamp( calc_inertia.x + (calc_acceleration.x * _delta),
+#									h_speed.y , h_speed.x)
 
 			
-			
+	elif calc_inertia.x != 0.0: ## We still have inertia but no difference in movement
-	elif calc_inertia.x != 0.0 and calc_acceleration.x != 0.0: ## We still have inertia but no difference in movement
 		if h_speed.x < h_speed.y:
 			h_speed.x = clamp(h_speed.x,0.0,h_speed.y)
 
-		## Move back towards the base speed
+		if calc_acceleration.x != 0.0: # We are applying acceleration
-		calc_inertia.x = move_toward(calc_inertia.x, h_speed.x, calc_acceleration.x * _delta)
+			## Move back towards the base speed
+			calc_inertia.x = move_toward(calc_inertia.x, h_speed.x, abs(calc_acceleration.x * _delta))
+			## This was working but trying to simplify with just move_toward
+#			if calc_inertia.x < h_speed.x:
+#				calc_inertia.x = clamp( calc_inertia.x +  ( calc_acceleration.x * _delta),
+#										calc_inertia.x, h_speed.x)
+#			else:
+#				calc_inertia.x = clamp( calc_inertia.x +  ( calc_acceleration.x * _delta),
+#										h_speed.x, calc_inertia.x)
+		else: ## No longer applying acceleration
+			## Neutralize the inertia? but how?
+			## Recalc the acceleration with inertia 
+			#var friction :Vector2
+			calc_friction.x =  resolve_h_acceleration(movement_parameters,Vector2(calc_inertia.x, h_speed.x),  move_direction.x)
+			if calc_friction.x != 0.0: ## No dapening acceleration applies
+				#calc_inertia.x = move_toward(calc_inertia.x, h_speed.x, ( calc_friction.x * _delta))
+				## Apply friction
+				calc_inertia.x = move_toward(calc_inertia.x, 0, abs(calc_friction.x * _delta))
+#				if calc_inertia.x < 0:
+#					calc_inertia.x = move_toward(calc_inertia.x, 0, abs(calc_friction.x * _delta))
+#				if calc_inertia.x > 0:
+#					calc_inertia.x = move_toward(calc_inertia.x, 0, abs(calc_friction.x * _delta) * -1)
+			else:
+				## no residual acceleration (friction) applies, kill the momentum
+				calc_inertia.x = 0.0
+				calc_inertial_dir.x = 0.0
 
 #		if (h_speed != debug_speed_tracker):
 #			print("Inertia SpeedShift: ", debug_speed_tracker, h_speed, (0.0 == -0.0))
@@ -317,12 +320,10 @@ func new_move_actor_as_desired(_delta :float,
 	#calc_velocity.x = calc_inertia.x * move_direction.x
 	
 	## Control, direction can only be controlled when overcome inertia direction.
-#	if calc_inertial_dir.x != 0:
+	if calc_inertial_dir.x != 0:
-#		calc_velocity.x = calc_inertia.x * calc_inertial_dir.x
+		calc_velocity.x = calc_inertia.x * calc_inertial_dir.x
-#	else:
+	else:
-#		calc_velocity.x = calc_inertia.x * move_direction.x
+		calc_velocity.x = calc_inertia.x * move_direction.x
-	
-	calc_velocity.x = calc_inertia.x
 	
 	## Attempting to move this to the top
 	#calc_inertial_dir = Vector2(sign(calc_velocity.x),sign(calc_velocity.y))
@@ -332,7 +333,7 @@ func new_move_actor_as_desired(_delta :float,
 		"\nVelocity_Calc:   {0}, {1}".format({"0":"%5.2f" % calc_velocity.x, "1":"%5.2f" % calc_velocity.y}) +
 		"\nInertia_Calc:   {0}, {1}".format({"0":"%5.2f" % calc_inertia.x, "1":"%5.2f" % calc_inertia.y}) +
 		"\nVelocity_Real:   {0}, {1}".format({"0":"%5.2f" % velocity.x, "1":"%5.2f" % velocity.y}) +
-		#"\nFriction:   {0}, {1}".format({"0":"%5.2f" % calc_friction.x, "1":"%5.2f" % calc_friction.y}) +
+		"\nFriction:   {0}, {1}".format({"0":"%5.2f" % calc_friction.x, "1":"%5.2f" % calc_friction.y}) +
 		"\nAccelCalc   :   {0}, {1}".format({"0":"%5.2f" % calc_acceleration.x, "1":"%5.2f" % calc_acceleration.y}) +
 
 		#"\nLength: " + str(velocity.length()) +
@@ -341,11 +342,6 @@ func new_move_actor_as_desired(_delta :float,
 		
 	return calc_velocity
 
-func is_out_of_range(value: float, a: float, b: float) -> bool:
-	var lower = min(a, b)
-	var upper = max(a, b)
-	return value < lower or value > upper
-
 ## Passed in acceleration, vel, etc is applied to whatever
 ## the parent is. If Kinematic then move_and_slide, otherwise manually adjusted
 func apply_movement_to_parent( _velocity :Vector2) -> void:
@@ -364,7 +360,7 @@ func resolve_h_speed(_params :MovementParameters) -> Vector2:
 		return(Vector2(base_speed, speed_differance))
 	return Vector2(base_speed,base_speed)
 
-func resolve_h_acceleration(_params :MovementParameters, _move_direction :float) -> float:
+func resolve_h_acceleration(_params :MovementParameters, _inertia :Vector2, _move_direction :float) -> float:
 	## TODO: Adjust for jerk, determine if we're currently experiencing accel
 	## if a speed difference applies
 	var _acceleration :float =  0.0

src/actors/players/playerE/PlayerE.gd

@@ -16,7 +16,6 @@ const state_stamina_cost :Dictionary = {
 	"attack_sword":20,
 	"attack_punch":10,
 	"roll":40,
-	#"roll":4,
 	"ledge_climb":10
 }