Movement work into its own class

lib/classes/movement_parameters.gd

@@ -22,7 +22,7 @@ var jerk: float = 0.0
 func modify(_movement_parameters :MovementParameters):
 	pass
 
-func apply_state_modifier(_modifier :StateModifierMovement, _movement_direction :float):
+func apply_state_modifier(_modifier :StateModifierMovement):
 	match _modifier.modifier_type:
 		StateModifierMovement.SUB_TYPE.NEGATIVE_CONSTRAINT:
 			var adjusted_move_speed = base_move_speed.x + _modifier.horizontal_speed

lib/classes/movement_state_receiver.gd

@@ -14,7 +14,6 @@ export var debug_component: bool = false
 onready var current_state = StateAnimatedActor.new()
 onready var parent: KinematicBody2D = get_parent()
 
-
 export var callable_state_machine :NodePath
 var request_state_change: FuncRef
 
@@ -23,9 +22,7 @@ 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 foo_velocity = preload("res://src/classes/velocity_calculations.gd").new()
-#var inertia = Vector2(0,0)
-#var acceleration = Vector2(0,0)
 
 #Removing Probably not used
 #var sim_velocity = Vector2(0,0)
@@ -43,6 +40,8 @@ const LEFT = -1.0
 const RIGHT = 1.0
 
 func _ready():
+	foo_velocity.debug = true
+
 	## FuncRef to request state machine change state
 	request_state_change = funcref(get_node(callable_state_machine), 'change_to_known_state')
 	## Connect signal to get alerted of state change
@@ -144,6 +143,23 @@ func _on_modifiers_updated(_modifier_type :int, _modifier_action :int, _merged_m
 		print("Registered Modifier Movement: ", _merged_modifier.horizontal_speed)
 		modifier = _merged_modifier
 
+func apply_state_modifier(movement_parameters :MovementParameters) -> MovementParameters:
+	if modifier and modifier.is_active:
+		if (current_state.is_grounded and modifier.only_grounded): # Should we skip
+			movement_parameters.apply_state_modifier(modifier)
+	
+	return movement_parameters
+
+
+## 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:
+	var snap = Vector2.DOWN * 8
+	## Disable snap when trying to jump (hacky?)
+	if _velocity.y < -8:
+		snap = Vector2.ZERO
+	if parent is KinematicBody2D:
+		foo_velocity.velocity = parent.move_and_slide_with_snap(_velocity, snap , Vector2.UP, true)
 
 enum RANGE_PLACEMENT {
 	BEFORE_RANGE = -1,
@@ -201,12 +217,7 @@ func new_move_actor_as_desired(_delta :float,
 	
 	var modifier_indicator := ''
 	var movement_parameters :MovementParameters = _state.get_movement_parameters()
-	if modifier and modifier.is_active:
+
-		if (_state.is_grounded and modifier.only_grounded): # Should we skip
-			modifier_indicator = '*'
-			if _state.name == 'jump':
-				var foo = 2+2 # break
-			movement_parameters.apply_state_modifier(modifier, move_direction.x)
 
 	## Inertia only applies if there is a difference between the 
 	# base move speed and a derived move speed. This makes it so all you
@@ -379,15 +390,7 @@ func placement_to_speed_range(speed: float, speed_range: Vector2) -> int:
 			return RANGE_PLACEMENT.BEFORE_RANGE
 	return 0
 
-## 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:
-	var snap = Vector2.DOWN * 8
-	## Disable snap when trying to jump (hacky?)
-	if _velocity.y < -8:
-		snap = Vector2.ZERO
-	if parent is KinematicBody2D:
-		velocity = parent.move_and_slide_with_snap(_velocity, snap , Vector2.UP, true)
 
 
 ## Returns an Vector where x is MIN_SPEED and y is MAX_SPEED
@@ -456,195 +459,3 @@ func resolve_move_direction(_momentum :Vector2,
 	return Vector2(horizontal_movement_direction, vertical_movement_direction)
 
 
-## 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
-#		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_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
-##		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)
-

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

@@ -160,7 +160,9 @@ func _state_process_physics_idle():
 	if $"%LadderDetector".is_colliding() and _wants_climb == true:
 		request_state_change.call_func('climb')
 
-	var _v :Vector2 = new_move_actor_as_desired( physics_delta , current_state )
+#	var _v :Vector2 = new_move_actor_as_desired( physics_delta , current_state )
+#	apply_movement_to_parent(_v)
+	var _v = foo_velocity.calculate_velocity( physics_delta , apply_state_modifier(current_state.get_movement_parameters()), desired_movement_vector )
 	apply_movement_to_parent(_v)
 
 func attack_primary():
@@ -333,7 +335,13 @@ func _state_process_physics_move():
 	#var _v :Vector2 = new_move_actor_as_desired( physics_delta , current_state )
 	#apply_movement_to_parent(_v)
 	
-	apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state ))
+	#apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state ))
+	apply_movement_to_parent(
+		foo_velocity.calculate_velocity( 
+			physics_delta , 
+			apply_state_modifier(current_state.get_movement_parameters()),
+			desired_movement_vector )
+	)
 
 func get_climb_shape_location() -> Vector2:
 	if $"%LadderDetector".is_colliding():