lib/classes/movement_parameters.gd

@@ -42,19 +42,12 @@ func apply_state_modifier(_modifier :StateModifierMovement, _movement_direction
 			##TODO: Um, modifiers are a little weirder for this
 			move_speed_modifier.x += _modifier.horizontal_speed_offset
 			move_speed_modifier_acceleration.x += _modifier.horizontal_speed_offset_acceleration
-			move_speed_modifier.y += _modifier.vertical_speed_offset
-			move_speed_modifier_acceleration.y += _modifier.vertical_speed_offset_acceleration
 		_:
 			base_move_speed.x += _modifier.horizontal_speed
 			base_move_acceleration.x += _modifier.horizontal_acceleration
 			move_speed_modifier.x += _modifier.horizontal_speed_offset
 			move_speed_modifier_acceleration.x += _modifier.horizontal_speed_offset_acceleration
 
-			base_move_speed.y += _modifier.vertical_speed
-			base_move_acceleration.y += _modifier.vertical_acceleration
-			move_speed_modifier.y += _modifier.vertical_speed_offset
-			move_speed_modifier_acceleration.y += _modifier.vertical_speed_offset_acceleration
-
 	
 	
 # var movement_params :Dictionary = {

lib/classes/movement_state_receiver.gd

@@ -23,9 +23,9 @@ onready var desired_movement_vector: Vector2 = Vector2(0,0)
 # Since animactor state machine can actually view properties from this type
 # I'm thinking about moving the velocity tracker in here instead of player.
 var velocity = Vector2(0,0)
-#var momentum = Vector2(0,0)
-#var inertia = Vector2(0,0)
-#var acceleration = Vector2(0,0)
+var momentum = Vector2(0,0)
+var inertia = Vector2(0,0)
+var acceleration = Vector2(0,0)
 
 #Removing Probably not used
 #var sim_velocity = Vector2(0,0)
@@ -61,8 +61,8 @@ func process_physics(delta):
 	physics_delta = delta
 	if has_method('_state_process_physics_' + current_state.name):
 		call('_state_process_physics_' + current_state.name)
-#	else:
-#		move_actor_as_desired()
+	else:
+		move_actor_as_desired()
 
 # more likely needed for Players
 func process_physics_input(delta):
@@ -191,15 +191,15 @@ func new_move_actor_as_desired(_delta :float,
 	## If an override has been passed (we're ignoring input direction
 	var move_direction = Vector2.ZERO
 	if _movement_override_normal != Vector2.ZERO:
-		move_direction = resolve_move_direction(calc_inertia, _movement_override_normal)
+		move_direction = resolve_move_direction(calc_inertial_dir, _movement_override_normal)
 	else:
-		move_direction = resolve_move_direction(calc_inertia, desired_movement_vector)
+		move_direction = resolve_move_direction(calc_inertial_dir, desired_movement_vector)
 
-	##WIP: the impulse logic just doesn't work still, below is another attempt
-#	if impulse_applied_dir != move_direction.x and sign(calc_velocity.x) != impulse_applied_dir:
-#		print("resetting impulse")
-#		impulse_applied = false
-#		impulse_applied_dir = sign(move_direction.x)
+	##TODO: the impulse logic just doesn't work still
+	if sign(calc_velocity.x) != move_direction.x and sign(calc_velocity.x) != impulse_applied_dir:
+		print("resetting impulse")
+		impulse_applied = false
+		impulse_applied_dir = sign(move_direction.x)
 		
 
 	var modifier_indicator := ''
@@ -221,17 +221,8 @@ func new_move_actor_as_desired(_delta :float,
 	# We move towards h_speed.y at the acceleration rate
 	##
 	var h_speed = resolve_h_speed(movement_parameters)
-	var v_speed = resolve_v_speed(movement_parameters)
 	## Speed will now be expected to move in the direction of travel
 	h_speed *= move_direction.x
-	v_speed *= move_direction.y
-
-	## Reset the impulse when back in range
-	# may also want to reset when hspeed is static
-	if (is_out_of_range(calc_inertia.x, h_speed.x, h_speed.y) == false and 
-			impulse_applied == true	):
-		print("resetting impulse")
-		impulse_applied = false
 	
 	## 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
@@ -261,7 +252,7 @@ func new_move_actor_as_desired(_delta :float,
 
 		## 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 (h_speed.x != 0 and h_speed.y != 0  ) and sign(h_speed.y) != sign(h_speed.x):
+		if h_speed.x != 0 and 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:
@@ -281,10 +272,10 @@ func new_move_actor_as_desired(_delta :float,
 			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
-					print(impulse_applied_dir, " Movement Impulse applied: ", h_speed.x)
 		debug_speed_tracker = h_speed
 #		elif calc_inertia.x != 0.0:
 #			##WIP: attempts to apply start speed only once
@@ -327,22 +318,9 @@ func new_move_actor_as_desired(_delta :float,
 		
 	## Another idea, just return the calculated velocity in PPS	
 	## For now, y component of velocity is just gravity
-	if v_speed.x != v_speed.y: ## For now gravity is just the default acceleration
-		if (v_speed.x != 0 and v_speed.y != 0) and sign(v_speed.y) != sign(v_speed.x):
-			if v_speed.x < v_speed.y:
-				v_speed.x = clamp(v_speed.x, 0.0, v_speed.y)
-			else:
-				v_speed.y = clamp(v_speed.y, 0.0, v_speed.x)
-		#print (is_out_of_range(calc_inertia.y, v_speed.x - sign(v_speed.x), v_speed.y - sign(v_speed.y)))
-		if is_out_of_range(calc_inertia.y, v_speed.x , v_speed.y):
-			## ? But we only want to do this once though. 
-			calc_inertia.y += v_speed.x
-		## Apply acceleration 
-		calc_inertia.y = move_toward(calc_inertia.y, v_speed.y, movement_parameters.gravity * _delta)
-	else:
-		## The previous vertical movement methods
-		calc_inertia.y += movement_parameters.gravity * _delta
+	#calc_velocity.y = movement_params["_gravity"] * Vector2.DOWN.y
 
+	calc_inertia.y += movement_parameters.gravity * _delta
 	calc_velocity.y = calc_inertia.y
 	
 	## calc  x component of felicty 
@@ -362,7 +340,6 @@ func new_move_actor_as_desired(_delta :float,
 
 	UiManager.debug_text =	( #"H_Speed x Dir: " + str(h_speed) + str('duh') +
 		modifier_indicator + "H_Speed  Fm:{0} To:{1}".format({"0":"%5.2f" % h_speed.x, "1":"%5.2f" % h_speed.y}) + 
-		"\nV_Speed  Fm:{0} To:{1}".format({"0":"%5.2f" % v_speed.x, "1":"%5.2f" % v_speed.y}) + 
 		"\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}) +
@@ -378,7 +355,7 @@ func new_move_actor_as_desired(_delta :float,
 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
+	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
@@ -401,15 +378,6 @@ func resolve_h_speed(_params :MovementParameters) -> Vector2:
 		return(Vector2(base_speed, speed_differance))
 	return Vector2(base_speed,base_speed)
 
-func resolve_v_speed(_params :MovementParameters) -> Vector2:
-	var base_speed :float = _params.base_move_speed.y
-	## if a speed difference applies
-	if _params.move_speed_modifier.y != 0:
-		var speed_differance = base_speed + _params.move_speed_modifier.y
-		
-		return(Vector2(base_speed, speed_differance))
-	return Vector2(base_speed,base_speed)
-
 func resolve_h_acceleration(_params :MovementParameters, _move_direction :float) -> float:
 	## TODO: Adjust for jerk, determine if we're currently experiencing accel
 	## if a speed difference applies
@@ -448,204 +416,198 @@ func resolve_move_direction(_momentum :Vector2,
 	elif sign(_momentum.x): ## We still have momentum but not trying to move
 		horizontal_movement_direction = sign(_momentum.x)
 	
-	var vertical_movement_direction:float
-	if sign(_movement_direction.y):
-		vertical_movement_direction = sign(_movement_direction.y)
-	elif sign(_momentum.y):
-		vertical_movement_direction = sign(_momentum.y)
-	
-	return Vector2(horizontal_movement_direction, vertical_movement_direction)
+	return Vector2(horizontal_movement_direction,0)
 
 
 ## About to DEPR this one for redesigned one above
-#func move_actor_as_desired( x_move_direction_override: float = 0):
-#	var delta:float = physics_delta
-#	var _move_speed = current_state.horizontal_speed
-#	var _move_acceleration = current_state.horizontal_acceleration
-#	var _move_speed_modifier = current_state.horizontal_speed_offset
-#	var _move_modifier_move_acceleration = current_state.horizontal_speed_offset_acceleration
-#	var _jerk_factor = current_state.jerk_factor
-#	var _gravity = current_state.gravity
-#
-##	if current_state.physics_modifier:
-##		#physics_modifier.modifier_properties.jerk_factor
-##		#print(physics_modifier.name)
-##		#UiManager.debug_text = physics_modifier.name + str(round(adjusted_move_speed))
-##		var mod_props :ModifierProperties = current_state.physics_modifier.get_modifier_properties()
-##		if mod_props.move_speed != 0 and mod_props.directional_modifier == false:
-##			_move_speed = mod_props.move_speed
-##		_move_speed_modifier += mod_props.move_speed_modifier
-##		_move_acceleration += mod_props.move_acceleration
-##		_move_modifier_move_acceleration += mod_props.move_modifier_move_acceleration
-##		_jerk_factor += mod_props.jerk_factor
-#
-#	var help_me_not_be_dumb = ''
-#
-#	# Allow us to bump out of halt.
-#	if _move_speed == 0 and desired_movement_vector.x != 0:
-#		_move_speed = abs(desired_movement_vector.x)
-#
-#	# Determine or physics movement direction	
-#	var current_x_velocity = velocity.x #move_component.velocity.x
-#	var move_direction = 0.0
-#	# Determine movement direction if we have momentum
-#	if momentum.x != 0:
-#		if x_move_direction_override == 0:
-#			move_direction = sign(current_x_velocity)
-##			if move_component.desired_movement_vector.x != 0:
-##				# set the move direction to the desired direction
-##				move_direction = move_component.desired_movement_vector.x
-##			else:
-##				# Set move direction to the transform direction 
-##				move_direction = parent.transform.x.x
+func move_actor_as_desired( x_move_direction_override: float = 0):
+	var delta:float = physics_delta
+	var _move_speed = current_state.horizontal_speed
+	var _move_acceleration = current_state.horizontal_acceleration
+	var _move_speed_modifier = current_state.horizontal_speed_offset
+	var _move_modifier_move_acceleration = current_state.horizontal_speed_offset_acceleration
+	var _jerk_factor = current_state.jerk_factor
+	var _gravity = current_state.gravity
+	
+#	if current_state.physics_modifier:
+#		#physics_modifier.modifier_properties.jerk_factor
+#		#print(physics_modifier.name)
+#		#UiManager.debug_text = physics_modifier.name + str(round(adjusted_move_speed))
+#		var mod_props :ModifierProperties = current_state.physics_modifier.get_modifier_properties()
+#		if mod_props.move_speed != 0 and mod_props.directional_modifier == false:
+#			_move_speed = mod_props.move_speed
+#		_move_speed_modifier += mod_props.move_speed_modifier
+#		_move_acceleration += mod_props.move_acceleration
+#		_move_modifier_move_acceleration += mod_props.move_modifier_move_acceleration
+#		_jerk_factor += mod_props.jerk_factor
+
+	var help_me_not_be_dumb = ''
+
+	# Allow us to bump out of halt.
+	if _move_speed == 0 and desired_movement_vector.x != 0:
+		_move_speed = abs(desired_movement_vector.x)
+
+	# Determine or physics movement direction	
+	var current_x_velocity = velocity.x #move_component.velocity.x
+	var move_direction = 0.0
+	# Determine movement direction if we have momentum
+	if momentum.x != 0:
+		if x_move_direction_override == 0:
+			move_direction = sign(current_x_velocity)
+#			if move_component.desired_movement_vector.x != 0:
+#				# set the move direction to the desired direction
+#				move_direction = move_component.desired_movement_vector.x
 #			else:
-#			move_direction = x_move_direction_override
-#	else: # No current momentum in place
-#		if x_move_direction_override == 0:
-#			move_direction = desired_movement_vector.x
+#				# Set move direction to the transform direction 
+#				move_direction = parent.transform.x.x
+		else:
+			move_direction = x_move_direction_override
+	else: # No current momentum in place
+		if x_move_direction_override == 0:
+			move_direction = desired_movement_vector.x
+		else:
+			move_direction = x_move_direction_override
+
+## TODO: I hate that I have to do this check again.
+#	if current_state.physics_modifier:
+#		var mod_props :ModifierProperties = current_state.physics_modifier.get_modifier_properties()
+#		if mod_props.move_speed != 0 and mod_props.directional_modifier == true:
+#			# Since move_direction is always positive
+#			if sign(move_direction) == sign(mod_props.move_speed):
+#				_move_speed += mod_props.move_speed				
 #			else:
-#			move_direction = x_move_direction_override
-#
-### TODO: I hate that I have to do this check again.
-##	if current_state.physics_modifier:
-##		var mod_props :ModifierProperties = current_state.physics_modifier.get_modifier_properties()
-##		if mod_props.move_speed != 0 and mod_props.directional_modifier == true:
-##			# Since move_direction is always positive
-##			if sign(move_direction) == sign(mod_props.move_speed):
-##				_move_speed += mod_props.move_speed				
-##			else:
-##				_move_speed -= mod_props.move_speed
-##				if sign(move_direction) == 0:
-##					move_direction = sign(mod_props.move_speed) * -1
-##					#print("doing this? ")
-#
-#
-#	# Determine the maximum move speed
-#	var MAX_SPEED :float = 0
-#	var MIN_SPEED :float = 0
-#	if sign(_move_speed_modifier) == -1: # decreased speed modifier
-#		help_me_not_be_dumb += '-SpeedMod'
-#		# Move speed cannot go below zero with modifier applied 
+#				_move_speed -= mod_props.move_speed
+#				if sign(move_direction) == 0:
+#					move_direction = sign(mod_props.move_speed) * -1
+#					#print("doing this? ")
+
+
+	# Determine the maximum move speed
+	var MAX_SPEED :float = 0
+	var MIN_SPEED :float = 0
+	if sign(_move_speed_modifier) == -1: # decreased speed modifier
+		help_me_not_be_dumb += '-SpeedMod'
+		# Move speed cannot go below zero with modifier applied 
+		MIN_SPEED = _move_speed + _move_speed_modifier
+		# Poor man's clamp
+		if MIN_SPEED < 0:
+			MIN_SPEED = 0
+		MAX_SPEED = _move_speed
+	elif sign(_move_speed_modifier) == +1: # increased speed modifier
+		help_me_not_be_dumb += '+SpeedMod'
+		MIN_SPEED = _move_speed
+		MAX_SPEED = _move_speed + _move_speed_modifier
+	else: # physics won't apply here
+		help_me_not_be_dumb += '_Speed' # Neutral Speed
+		MIN_SPEED = _move_speed
+		MAX_SPEED = _move_speed
+
+	# get the latest aggregate acceleration
+	# If we have any acceleration applying
+	if (_move_modifier_move_acceleration + _move_acceleration) != 0:
+		# The acceleration is differant
+		# Perhaps it would be better to trigger this on a difference in modifier but they usually go together.
+		if abs(acceleration.x) != abs(_move_modifier_move_acceleration + _move_acceleration):
+			if move_direction:
+				#print("Acceleration changed.", abs(acceleration.x), "-", (_move_modifier_move_acceleration + _move_acceleration))
+				acceleration.x = _move_modifier_move_acceleration + _move_acceleration
+
+	# If we're no longer tryingg to move int the direction of our movement and momentum.
+	if (sign(current_x_velocity) != sign(desired_movement_vector.x) and momentum.x != 0):
+		if sign(_move_speed_modifier) == -1 : # decreased speed modifier
+			# Maybe we can compare the direction of the acceleration
+			# The direction of the acceleration should usually be positive at this point.
+			# when the modifier is negative. 
+			if sign(move_direction) == sign(current_x_velocity): 
+				if sign(acceleration.x) == sign(momentum.x):
+					acceleration.x *= -1
+					# print("Whoh Woah")
+					# Flip the direction of the acceleration 
+			if (sign(desired_movement_vector.x) == -1 and 
+				sign(current_x_velocity) == 1) or (sign(desired_movement_vector.x) == -1 and 
+				sign(current_x_velocity) == -1):
+				print_debug("be more opposite")
+
+	elif (sign(desired_movement_vector.x) == sign(current_x_velocity) and momentum.x != 0):
+		print('why')
+		if (sign(acceleration.x) != sign(momentum.x) and x_move_direction_override == 0):
+			#print("Step it up!")
+			# Flip the direction of the acceleration 
+			acceleration.x *= -1
+
+	# Apply momentum and acceleration if a modifer exists
+	if momentum.x <= 0 and _move_speed_modifier !=0:
+		#if we're trying to move but we have no momentum applied currently
+		#if move_component.desired_movement_vector.x != 0:
+		if move_direction:
+			acceleration.x = _move_modifier_move_acceleration + _move_acceleration
+			##TODO: I don't know where I should actually set the momentum. :
+			if sign(_move_speed_modifier) == -1: # decreased speed modifier
+				momentum.x = 0
+			elif sign(_move_speed_modifier) == +1: # increased speed modifier
+				##TODO: in most cases this should only be applied once. need to find a way to warn against this.
+				momentum.x = abs(_move_speed_modifier)
+				print("momentum applied!")
+
+	# Reverse the accelerations if we carry over momentum but the modifier no longer applies. 
+	if momentum.x > 0 and _move_speed_modifier == 0:
+		if sign(acceleration.x) == sign(momentum.x):
+			print("Whoh Woah your done.")
+			# Flip the direction of the acceleration 
+			acceleration.x *= -1
+
+		
+	# We're going to adjust our move speed only to the modifier 
+	momentum.x += acceleration.x * delta
+	##TODO: Apparently I disabled jerk some time ago for some reason.
+	current_state.jerk += _jerk_factor * delta
+	
+
+	var new_move_speed :float = 0
+	if sign(_move_speed_modifier) == -1: # decreased speed modifier
 #		MIN_SPEED = _move_speed + _move_speed_modifier
-#		# Poor man's clamp
-#		if MIN_SPEED < 0:
-#			MIN_SPEED = 0
 #		MAX_SPEED = _move_speed
-#	elif sign(_move_speed_modifier) == +1: # increased speed modifier
-#		help_me_not_be_dumb += '+SpeedMod'
+		momentum.x = clamp(momentum.x, 0, abs(_move_speed_modifier))
+#		new_move_speed = (_move_speed + _move_speed_modifier ) + (sign(_move_speed_modifier) * -1 * move_component.momentum.x) # + jerk
+		new_move_speed = MIN_SPEED + (sign(_move_speed_modifier) * -1 * momentum.x) # + jerk
+	elif sign(_move_speed_modifier) == +1: # increased speed modifier
 #		MIN_SPEED = _move_speed
 #		MAX_SPEED = _move_speed + _move_speed_modifier
-#	else: # physics won't apply here
-#		help_me_not_be_dumb += '_Speed' # Neutral Speed
-#		MIN_SPEED = _move_speed
-#		MAX_SPEED = _move_speed
-#
-#	# get the latest aggregate acceleration
-#	# If we have any acceleration applying
-#	if (_move_modifier_move_acceleration + _move_acceleration) != 0:
-#		# The acceleration is differant
-#		# Perhaps it would be better to trigger this on a difference in modifier but they usually go together.
-#		if abs(acceleration.x) != abs(_move_modifier_move_acceleration + _move_acceleration):
-#			if move_direction:
-#				#print("Acceleration changed.", abs(acceleration.x), "-", (_move_modifier_move_acceleration + _move_acceleration))
-#				acceleration.x = _move_modifier_move_acceleration + _move_acceleration
-#
-#	# If we're no longer tryingg to move int the direction of our movement and momentum.
-#	if (sign(current_x_velocity) != sign(desired_movement_vector.x) and momentum.x != 0):
-#		if sign(_move_speed_modifier) == -1 : # decreased speed modifier
-#			# Maybe we can compare the direction of the acceleration
-#			# The direction of the acceleration should usually be positive at this point.
-#			# when the modifier is negative. 
-#			if sign(move_direction) == sign(current_x_velocity): 
-#				if sign(acceleration.x) == sign(momentum.x):
-#					acceleration.x *= -1
-#					# print("Whoh Woah")
-#					# Flip the direction of the acceleration 
-#			if (sign(desired_movement_vector.x) == -1 and 
-#				sign(current_x_velocity) == 1) or (sign(desired_movement_vector.x) == -1 and 
-#				sign(current_x_velocity) == -1):
-#				print_debug("be more opposite")
-#
-#	elif (sign(desired_movement_vector.x) == sign(current_x_velocity) and momentum.x != 0):
-#		print('why')
-#		if (sign(acceleration.x) != sign(momentum.x) and x_move_direction_override == 0):
-#			#print("Step it up!")
-#			# Flip the direction of the acceleration 
-#			acceleration.x *= -1
-#
-#	# Apply momentum and acceleration if a modifer exists
-#	if momentum.x <= 0 and _move_speed_modifier !=0:
-#		#if we're trying to move but we have no momentum applied currently
-#		#if move_component.desired_movement_vector.x != 0:
-#		if move_direction:
-#			acceleration.x = _move_modifier_move_acceleration + _move_acceleration
-#			##TODO: I don't know where I should actually set the momentum. :
-#			if sign(_move_speed_modifier) == -1: # decreased speed modifier
-#				momentum.x = 0
-#			elif sign(_move_speed_modifier) == +1: # increased speed modifier
-#				##TODO: in most cases this should only be applied once. need to find a way to warn against this.
-#				momentum.x = abs(_move_speed_modifier)
-#				print("momentum applied!")
-#
-#	# Reverse the accelerations if we carry over momentum but the modifier no longer applies. 
-#	if momentum.x > 0 and _move_speed_modifier == 0:
-#		if sign(acceleration.x) == sign(momentum.x):
-#			print("Whoh Woah your done.")
-#			# Flip the direction of the acceleration 
-#			acceleration.x *= -1
-#
-#
-#	# We're going to adjust our move speed only to the modifier 
-#	momentum.x += acceleration.x * delta
-#	##TODO: Apparently I disabled jerk some time ago for some reason.
-#	current_state.jerk += _jerk_factor * delta
-#
-#
-#	var new_move_speed :float = 0
-#	if sign(_move_speed_modifier) == -1: # decreased speed modifier
-##		MIN_SPEED = _move_speed + _move_speed_modifier
-##		MAX_SPEED = _move_speed
-#		momentum.x = clamp(momentum.x, 0, abs(_move_speed_modifier))
-##		new_move_speed = (_move_speed + _move_speed_modifier ) + (sign(_move_speed_modifier) * -1 * move_component.momentum.x) # + jerk
-#		new_move_speed = MIN_SPEED + (sign(_move_speed_modifier) * -1 * momentum.x) # + jerk
-#	elif sign(_move_speed_modifier) == +1: # increased speed modifier
-##		MIN_SPEED = _move_speed
-##		MAX_SPEED = _move_speed + _move_speed_modifier
-#		momentum.x = clamp(momentum.x, 0, _move_speed_modifier )
-#		new_move_speed = _move_speed + momentum.x # + jerk
-#	else: # physics won't apply here
-##		move_component.acceleration.x = 0
-##		move_component.momentum.x = 0
-##		new_move_speed = _move_speed 
-#		momentum.x = clamp(momentum.x, 0, MIN_SPEED )
-#		new_move_speed = _move_speed + momentum.x # + jerk
-#
-#	#new_move_speed = clamp(new_move_speed, MIN_SPEED, MAX_SPEED)
-#
-#	var sim_move_speed = (MIN_SPEED + (sign(_move_speed_modifier) * -1 * momentum.x))
-#
-##	if move_component.momentum.x != 0:
-#	if debug_component == true:
-#		UiManager.debug_text = ( "Mod(" + str(sign(_move_speed_modifier)) + ") Dir(" + str(move_direction) + ") Vel(" + str(sign(current_x_velocity)) + ") Mov(" + str(sign(desired_movement_vector.x)) +
-#			")\nNS:" + str(round(sim_move_speed))  + #" Z:" + str(sign(_move_speed_modifier) * -1 * move_component.momentum.x) + 
-#			"\nS:" + str(round(_move_speed + _move_speed_modifier)) + ",M" + str(round(momentum.x)) +  
-#			",A" + str(round(acceleration.x)) +
-#			"\nVel:" + str(round(velocity.x)) + "Min:" + str(round(MIN_SPEED)) + ",Max:" + str(round(MAX_SPEED))
-#		) # str(round(jerk))
-#
-#	#sim_velocity.x = move_direction * sim_move_speed
-#	#print(adjusted_move_speed, ",", new_move_speed, ",", jerk)
-#
-#	#print(new_move_speed, " ", adjusted_move_speed)
-#
-#	velocity.y += _gravity * delta
-#	#parent.velocity = parent.move_and_slide(parent.velocity, Vector2(0, -1))
-#	#print(speed_multiplier)
-##	move_component.velocity.x = move_component.desired_movement_vector.x * _move_speed
-#	velocity.x = move_direction * new_move_speed
-#	#move_component.velocity = parent.move_and_slide(move_component.velocity, Vector2.UP)
-#	var snap = Vector2.DOWN * 8
-#	if velocity.y < -8:
-#		snap = Vector2.ZERO
-#	velocity = parent.move_and_slide_with_snap(velocity, snap , Vector2.UP, true)
+		momentum.x = clamp(momentum.x, 0, _move_speed_modifier )
+		new_move_speed = _move_speed + momentum.x # + jerk
+	else: # physics won't apply here
+#		move_component.acceleration.x = 0
+#		move_component.momentum.x = 0
+#		new_move_speed = _move_speed 
+		momentum.x = clamp(momentum.x, 0, MIN_SPEED )
+		new_move_speed = _move_speed + momentum.x # + jerk
+
+	#new_move_speed = clamp(new_move_speed, MIN_SPEED, MAX_SPEED)
+
+	var sim_move_speed = (MIN_SPEED + (sign(_move_speed_modifier) * -1 * momentum.x))
+
+#	if move_component.momentum.x != 0:
+	if debug_component == true:
+		UiManager.debug_text = ( "Mod(" + str(sign(_move_speed_modifier)) + ") Dir(" + str(move_direction) + ") Vel(" + str(sign(current_x_velocity)) + ") Mov(" + str(sign(desired_movement_vector.x)) +
+			")\nNS:" + str(round(sim_move_speed))  + #" Z:" + str(sign(_move_speed_modifier) * -1 * move_component.momentum.x) + 
+			"\nS:" + str(round(_move_speed + _move_speed_modifier)) + ",M" + str(round(momentum.x)) +  
+			",A" + str(round(acceleration.x)) +
+			"\nVel:" + str(round(velocity.x)) + "Min:" + str(round(MIN_SPEED)) + ",Max:" + str(round(MAX_SPEED))
+		) # str(round(jerk))
+		
+	#sim_velocity.x = move_direction * sim_move_speed
+	#print(adjusted_move_speed, ",", new_move_speed, ",", jerk)
+
+	#print(new_move_speed, " ", adjusted_move_speed)
+
+	velocity.y += _gravity * delta
+	#parent.velocity = parent.move_and_slide(parent.velocity, Vector2(0, -1))
+	#print(speed_multiplier)
+#	move_component.velocity.x = move_component.desired_movement_vector.x * _move_speed
+	velocity.x = move_direction * new_move_speed
+	#move_component.velocity = parent.move_and_slide(move_component.velocity, Vector2.UP)
+	var snap = Vector2.DOWN * 8
+	if velocity.y < -8:
+		snap = Vector2.ZERO
+	velocity = parent.move_and_slide_with_snap(velocity, snap , Vector2.UP, true)
 

lib/classes/state_animated_actor.gd

@@ -15,7 +15,7 @@ export var horizontal_acceleration: float = 0
 export var horizontal_speed_offset: float = 0
 ## Applies only if offset applies
 export var horizontal_speed_offset_acceleration: float = 0
-export var jerk_factor: float = 1.0
+export var jerk_factor: float = 0
 
 export var vertical_speed: float = 0
 export var vertical_acceleration: float = 0
@@ -60,11 +60,6 @@ func get_movement_parameters() -> MovementParameters:
 	movement_parameters.base_move_acceleration.x = horizontal_acceleration
 	movement_parameters.move_speed_modifier.x = horizontal_speed_offset
 	movement_parameters.move_speed_modifier_acceleration.x = horizontal_speed_offset_acceleration
-	movement_parameters.base_move_speed.y = vertical_speed
-	movement_parameters.base_move_acceleration.y = vertical_acceleration
-	movement_parameters.move_speed_modifier.y = vertical_speed_offset
-	movement_parameters.move_speed_modifier_acceleration.y = vertical_speed_offset_acceleration
-
 
 	return movement_parameters
 

lib/classes/state_modifier_movement.gd

@@ -67,9 +67,5 @@ func merge(_merge_from_modifier: StateModifier):
 				horizontal_acceleration += _merge_from_modifier.horizontal_acceleration
 				horizontal_speed_offset += _merge_from_modifier.horizontal_speed_offset
 				horizontal_speed_offset_acceleration += _merge_from_modifier.horizontal_speed_offset_acceleration
-				vertical_speed += _merge_from_modifier.vertical_speed
-				vertical_acceleration += _merge_from_modifier.vertical_acceleration
-				vertical_speed_offset += _merge_from_modifier.vertical_speed_offset
-				vertical_speed_offset_acceleration += _merge_from_modifier.vertical_speed_offset_acceleration
 				direction = _merge_from_modifier.direction
 				only_grounded = _merge_from_modifier.only_grounded

src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd

@@ -42,7 +42,6 @@ func wants_jump() -> bool:
 		##Bugfix: Both players jump.
 		#desired_movement_vector.y = UP
 		_wants_jump = true
-		desired_movement_vector.y = UP
 		return true
 	else:
 		_wants_jump = false
@@ -250,8 +249,7 @@ func _state_process_physics_enter_right():
 
 	# Force role in facing direction 
 	#	instead of movement direction
-	#move_actor_as_desired(parent.transform.x.x)
-	apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state, parent.transform.x ))
+	move_actor_as_desired(parent.transform.x.x)
 
 func _state_process_physics_land():
 	$"%LedgeDetector".set_enabled(true)
@@ -261,8 +259,7 @@ func _state_process_physics_land():
 	if !parent.is_on_floor():
 		#return fall_state
 		request_state_change.call_func('fall')
-	#move_actor_as_desired()
-	apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state ))
+	move_actor_as_desired()
 
 func _state_process_physics_hurt():
 	if current_state.state_timeout.time_left == 0:
@@ -295,8 +292,7 @@ func _state_process_physics_fall():
 		#idle_state.modifier = landing_modifier
 		request_state_change.call_func('land')
 	
-	#move_actor_as_desired()
-	apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state ))
+	move_actor_as_desired()
 
 func _state_process_physics_jump():
 	
@@ -309,7 +305,6 @@ func _state_process_physics_jump():
 #		request_state_change.call_func('idle')
 	if velocity.y > 0:
 		request_state_change.call_func('fall')
-	desired_movement_vector.y = UP
 	#move_actor_as_desired()
 	apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state ))
 
@@ -443,15 +438,14 @@ func _state_process_physics_crouch_move():
 	elif _wants_crouch != true and desired_movement_vector.x != 0:
 		request_state_change.call_func('move')
 
-	#move_actor_as_desired()
-	apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state ))
+	move_actor_as_desired()
 
 #func _on_state_entered_idle():
 #	print("Movement State Idle State Entered!")
 
-##WIP: Make this a state export variable
-#func _on_state_entered_jump():
-#	# I used to call it 'jump_force' like an idiot.
-#	velocity.y = -200
+func _on_state_entered_jump():
+	##TODO: Make this a state export variable
+	# I used to call it 'jump_force' like an idiot.
+	velocity.y = -200
 
 

src/actors/players/playerE/states/fall.tres

@@ -13,7 +13,7 @@ horizontal_speed = 90.0
 horizontal_acceleration = 0.0
 horizontal_speed_offset = 0.0
 horizontal_speed_offset_acceleration = 0.0
-jerk_factor = 1.0
+jerk_factor = 0.0
 vertical_speed = 0.0
 vertical_acceleration = 0.0
 vertical_speed_offset = 0.0

src/actors/players/playerE/states/idle.tres

@@ -10,14 +10,8 @@ debug_state = false
 timeout_seconds = 0.0
 name = "idle"
 horizontal_speed = 1.36422e-12
-horizontal_acceleration = 300.0
+horizontal_acceleration = -60.0
 horizontal_speed_offset = 0.0
 horizontal_speed_offset_acceleration = 0.0
-jerk_factor = 1.0
-vertical_speed = 0.0
-vertical_acceleration = 0.0
-vertical_speed_offset = 0.0
-vertical_speed_offset_acceleration = 0.0
-preserve_inertia = true
-is_grounded = true
+jerk_factor = 0.0
 animation_sequence = [ "idle" ]

src/actors/players/playerE/states/jump.tres

@@ -13,10 +13,10 @@ horizontal_speed = 90.0
 horizontal_acceleration = 0.0
 horizontal_speed_offset = 0.0
 horizontal_speed_offset_acceleration = 0.0
-jerk_factor = 1.0
-vertical_speed = 200.0
+jerk_factor = 0.0
+vertical_speed = 0.0
 vertical_acceleration = 0.0
-vertical_speed_offset = -200.0
+vertical_speed_offset = 0.0
 vertical_speed_offset_acceleration = 0.0
 preserve_inertia = true
 is_grounded = false

src/actors/players/playerE/states/move.tres

@@ -14,10 +14,4 @@ horizontal_acceleration = 70.0
 horizontal_speed_offset = 80.0
 horizontal_speed_offset_acceleration = 0.0
 jerk_factor = 0.0
-vertical_speed = 0.0
-vertical_acceleration = 0.0
-vertical_speed_offset = 0.0
-vertical_speed_offset_acceleration = 0.0
-preserve_inertia = true
-is_grounded = true
 animation_sequence = [ "run" ]

src/actors/players/playerE/states/roll.tres

@@ -13,11 +13,5 @@ horizontal_speed = 150.0
 horizontal_acceleration = 1.36422e-12
 horizontal_speed_offset = -140.0
 horizontal_speed_offset_acceleration = -300.0
-jerk_factor = 1.0
-vertical_speed = 0.0
-vertical_acceleration = 0.0
-vertical_speed_offset = 0.0
-vertical_speed_offset_acceleration = 0.0
-preserve_inertia = false
-is_grounded = true
+jerk_factor = 0.0
 animation_sequence = [ "roll" ]