diff --git a/lib/classes/movement_parameters.gd b/lib/classes/movement_parameters.gd index 38aae6a..f62b9d4 100644 --- a/lib/classes/movement_parameters.gd +++ b/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 diff --git a/lib/classes/movement_state_receiver.gd b/lib/classes/movement_state_receiver.gd index f810966..b3b20ac 100644 --- a/lib/classes/movement_state_receiver.gd +++ b/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 inertia = Vector2(0,0) -#var acceleration = Vector2(0,0) +var foo_velocity = preload("res://src/classes/velocity_calculations.gd").new() #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) - diff --git a/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd b/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd index f016de0..87af940 100644 --- a/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd +++ b/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():