diff --git a/lib/classes/movement_state_receiver.gd b/lib/classes/movement_state_receiver.gd index b3b20ac..ca1e74a 100644 --- a/lib/classes/movement_state_receiver.gd +++ b/lib/classes/movement_state_receiver.gd @@ -21,8 +21,8 @@ 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 foo_velocity = preload("res://src/classes/velocity_calculations.gd").new() +#var velocity = Vector2(0,0) +var velocity :VelocityCalculations = VelocityCalculations.new() #Removing Probably not used #var sim_velocity = Vector2(0,0) @@ -40,7 +40,7 @@ const LEFT = -1.0 const RIGHT = 1.0 func _ready(): - foo_velocity.debug = true + #velocity.debug = true ## FuncRef to request state machine change state request_state_change = funcref(get_node(callable_state_machine), 'change_to_known_state') @@ -159,303 +159,5 @@ func apply_movement_to_parent( _velocity :Vector2) -> void: 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, - WITHIN_RANGE = 0, - PAST_RANGE = 1 -} - -## Side effects for these variables -# velocity - doesn't change but uses it to set base calculations -# accepts the state to determine movement, the deltatime, and an optional direction -# Update: Actually should just return movement in PPS -## - -## Could these be datatypes or a class? Sure -var _h_impulse_applied :bool = false -var _h_impulse_speed_tracking :Vector2 -var _v_impulse_applied :bool = false -var _v_impulse_speed_tracking :Vector2 - -func new_move_actor_as_desired(_delta :float, - _state :StateAnimatedActor, - _movement_override_normal := Vector2(0,0), - _velocity_override := Vector2(0,0)) -> Vector2: - - var calc_velocity = Vector2.ZERO - if _velocity_override.x != 0.0: - calc_velocity.x = _velocity_override.x - else: - calc_velocity.x = velocity.x - if _velocity_override.y != 0.0: - calc_velocity.y = _velocity_override.y - else: - calc_velocity.y = velocity.y - - var calc_acceleration = Vector2.ZERO - var calc_inertia :Vector2 - #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 - - ## Determine movement direction - # If there is an inertia direction from existing velocity and - # no desired movement we'll continue to travel in that direction. - ## - ## 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) - else: - move_direction = resolve_move_direction(calc_inertia, desired_movement_vector) - - var modifier_indicator := '' - var movement_parameters :MovementParameters = _state.get_movement_parameters() - - - ## 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) - 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 - - ## Now determine placement of current velocity to speed range - var h_range_placement = placement_to_speed_range(calc_velocity.x, h_speed) - var v_range_placement = placement_to_speed_range(calc_velocity.y, v_speed) - - ## 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. - ## Reset the impulse when back in range - # may also want to reset when hspeed is static - if (h_range_placement == RANGE_PLACEMENT.WITHIN_RANGE and - _h_impulse_applied == true ): - print("resetting H impulse") - _h_impulse_applied = false - if (v_range_placement == RANGE_PLACEMENT.WITHIN_RANGE and - _v_impulse_applied == true ): - print("resetting V impulse") - _v_impulse_applied = false - - ## Acceleration is always postive because we use the - # move toward functions. - calc_acceleration.x = abs(resolve_h_acceleration(movement_parameters, move_direction.x)) - - ## We are always moving from h_speed.x towards y at a given rate - ## if we have a difference of speed and an acceleration - ##TODO: The Min Max could be augmented to just be h_speed.x and prevent the sliding. - if h_speed.x != h_speed.y and calc_acceleration.x != 0.0: - var direction_accel :float = calc_acceleration.x * _delta #* move_direction.x - if h_speed.x > h_speed.y: - direction_accel *= -1 - match h_range_placement: - RANGE_PLACEMENT.BEFORE_RANGE: - ## Also apply impulse here - if _h_impulse_applied == false: - calc_inertia.x += h_speed.x - _h_impulse_applied = true - #impulse_applied_dir = move_direction.x - calc_inertia.x = clamp(calc_inertia.x + direction_accel, - min(calc_inertia.x, h_speed.y), - max(calc_inertia.x, h_speed.y)) - RANGE_PLACEMENT.WITHIN_RANGE: - ## If we're within the range but our speed has just changed - if _h_impulse_applied == false and _h_impulse_speed_tracking != h_speed: - ## Set inertia to starting speed, we're already in range - calc_inertia.x = h_speed.x - _h_impulse_applied = true - calc_inertia.x = clamp(calc_inertia.x + direction_accel, - min(h_speed.x, h_speed.y), - max(h_speed.x, h_speed.y)) - RANGE_PLACEMENT.PAST_RANGE: - calc_inertia.x = clamp(calc_inertia.x - direction_accel, # Friction - min(calc_inertia.x, h_speed.y), - max(calc_inertia.x, h_speed.y)) - - - 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 - calc_inertia.x = move_toward(calc_inertia.x, h_speed.x, calc_acceleration.x * _delta) - - else: - ## inertia is just base speed - calc_inertia.x = h_speed.x - calc_inertial_dir.x = 0.0 # sign(calc_inertia.x) - - ## 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 - var direction_accel :float = movement_parameters.gravity * _delta #* move_direction.x - if v_speed.x > v_speed.y: - direction_accel *= -1 - match v_range_placement: - RANGE_PLACEMENT.BEFORE_RANGE: - ## Also apply impulse here - if _v_impulse_applied == false: - calc_inertia.y += v_speed.x - _v_impulse_applied = true - #impulse_applied_dir = move_direction.x - calc_inertia.y = clamp(calc_inertia.y + direction_accel, - min(calc_inertia.x, v_speed.y), - max(calc_inertia.x, v_speed.y)) - RANGE_PLACEMENT.WITHIN_RANGE: - ## If we're within the range but our speed has just changed - if _v_impulse_applied == false and _v_impulse_speed_tracking != v_speed: - ## Set inertia to starting speed, we're already in range - calc_inertia.y = v_speed.x - _v_impulse_applied = true - calc_inertia.y = clamp(calc_inertia.y + direction_accel, - min(v_speed.x, v_speed.y), - max(v_speed.x, v_speed.y)) - RANGE_PLACEMENT.PAST_RANGE: - calc_inertia.y = clamp(calc_inertia.y - direction_accel, # Friction - min(calc_inertia.y, v_speed.y), - max(calc_inertia.y, v_speed.y)) - - else: - ## The previous vertical movement methods - calc_inertia.y += movement_parameters.gravity * _delta - - ## Track or last speed for in range impulses - _h_impulse_speed_tracking = h_speed - _v_impulse_speed_tracking = v_speed - - calc_velocity.y = calc_inertia.y - calc_velocity.x = calc_inertia.x - - if debug_component: - 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}) + - "\nSpeedRange : {0}, {1}".format({"0":"%5.2f" % h_range_placement, "1":"%5.2f" % v_range_placement}) + - "\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}) + - "\nAccelCalc : {0}, {1}".format({"0":"%5.2f" % calc_acceleration.x, "1":"%5.2f" % calc_acceleration.y}) + - # h_range_placement - #"\nLength: " + str(velocity.length()) + - "\nMoveDir: {0}, {1}".format({"0":"%4.1f" % move_direction.x, "1":"%4.1f" % move_direction.y}) - ) - - 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 - -## Determine the trend of direction and where our current speed is -# in relation to it. This should help determine the direction of -# acceleration and whether we speed up or slow down. -## -func placement_to_speed_range(speed: float, speed_range: Vector2) -> int: - ## Actually we don't care about mix or min - #var range_start :float = min(speed_range.x, speed_range.y) - #var range_end :float = max(speed_range.x, speed_range.y) - - ## We can be at the base range to ensure impulse can happen - ## Direction <-- that way - if speed_range.x > speed_range.y: - if speed < speed_range.x and speed >= speed_range.y: - return RANGE_PLACEMENT.WITHIN_RANGE - elif speed < speed_range.y: - return RANGE_PLACEMENT.PAST_RANGE - else: - return RANGE_PLACEMENT.BEFORE_RANGE - else: ## Direction --> that way - if speed > speed_range.x and speed <= speed_range.y: - return RANGE_PLACEMENT.WITHIN_RANGE - elif speed > speed_range.y: - return RANGE_PLACEMENT.PAST_RANGE - else: - return RANGE_PLACEMENT.BEFORE_RANGE - return 0 - - - - -## Returns an Vector where x is MIN_SPEED and y is MAX_SPEED -func resolve_h_speed(_params :MovementParameters) -> Vector2: - var base_speed :float = _params.base_move_speed.x - ## if a speed difference applies - if _params.move_speed_modifier.x != 0: - var speed_differance = base_speed + _params.move_speed_modifier.x - - 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 - var _acceleration :float = 0.0 - var base_speed :float = _params.base_move_speed.x - if _params.move_speed_modifier.x != 0: - var speed_differance = base_speed + _params.move_speed_modifier.x - _acceleration = _params.base_move_acceleration.x + _params.move_speed_modifier_acceleration.x - ##WIP: Add part where offset acceleration only applies until the inertia equals the offset or whatever -# if sign(_params["_base_h_move_modifier_move_acceleration"]) == -1 and abs(_inertia.x) >= speed_differance: -# #print("I should add the modifier acceleration maybe?") -# _acceleration += _params["_base_h_move_modifier_move_acceleration"] -# else: -# print ("not yet.") - else: - _acceleration = _params.base_move_acceleration.x - - ## This works but I want to try something differant. -# if _inertia.x != 0.0 and sign(_inertia.x) != sign(_move_direction): -# return _acceleration * -1 -# elif sign(_move_direction) != 0: -# ## If no velocity or it matches just return as is. -# return _acceleration - - if sign(_move_direction) != 0: - return _acceleration - - # No accel returned unless intended - return 0.0 - -func resolve_move_direction(_momentum :Vector2, - _movement_direction :Vector2) -> Vector2: - var horizontal_movement_direction:float - if sign(_movement_direction.x): ## We're trying to move - horizontal_movement_direction = sign(_movement_direction.x) - 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) - + velocity.velocity = parent.move_and_slide_with_snap(_velocity, snap , Vector2.UP, true) diff --git a/project.godot b/project.godot index 506729d..949d7ae 100644 --- a/project.godot +++ b/project.godot @@ -163,6 +163,11 @@ _global_script_classes=[ { "class": "UIComponent", "language": "GDScript", "path": "res://src/ui/HUD.gd" +}, { +"base": "Reference", +"class": "VelocityCalculations", +"language": "GDScript", +"path": "res://src/classes/velocity_calculations.gd" } ] _global_script_class_icons={ "Actor": "", @@ -195,7 +200,8 @@ _global_script_class_icons={ "StateModifier": "", "StateModifierAnimatedActor": "", "StateModifierMovement": "", -"UIComponent": "" +"UIComponent": "", +"VelocityCalculations": "" } [application] diff --git a/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd b/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd index 87af940..eb86d2f 100644 --- a/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd +++ b/src/actors/players/playerE/PlayerE-Movement_StateReceiver.gd @@ -162,8 +162,12 @@ func _state_process_physics_idle(): # 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) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + desired_movement_vector ) + ) func attack_primary(): ##Another thing I wish I could avoid the funcref or string call @@ -222,8 +226,13 @@ func _state_process_physics_roll(): # 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 )) - + #apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state, parent.transform.x )) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + parent.transform.x ) + ) if !parent.is_on_floor(): #return fall_state request_state_change.call_func('fall') @@ -253,7 +262,12 @@ 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 )) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + parent.transform.x ) + ) func _state_process_physics_land(): $"%LedgeDetector".set_enabled(true) @@ -264,7 +278,12 @@ func _state_process_physics_land(): #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 )) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + desired_movement_vector ) + ) func _state_process_physics_hurt(): if current_state.state_timeout.time_left == 0: @@ -280,7 +299,7 @@ func _state_process_physics_hurt(): # parent.velocity.x = 1 * move_speed # else: # parent.velocity.x = -1 * move_speed - velocity = parent.move_and_slide(velocity, Vector2(0, -1)) + velocity.velocity = parent.move_and_slide(velocity.velocity, Vector2(0, -1)) func _state_process_physics_fall(): @@ -298,7 +317,12 @@ func _state_process_physics_fall(): request_state_change.call_func('land') #move_actor_as_desired() - apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state )) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + desired_movement_vector ) + ) func _state_process_physics_jump(): @@ -309,11 +333,16 @@ func _state_process_physics_jump(): # #modifier.reference() # #idle_state.modifier = landing_modifier # request_state_change.call_func('idle') - if velocity.y > 0: + if velocity.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 )) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + desired_movement_vector ) + ) func _state_process_physics_move(): # flip sprite in direction @@ -337,7 +366,7 @@ func _state_process_physics_move(): #apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state )) apply_movement_to_parent( - foo_velocity.calculate_velocity( + velocity.calculate_velocity( physics_delta , apply_state_modifier(current_state.get_movement_parameters()), desired_movement_vector ) @@ -452,7 +481,12 @@ func _state_process_physics_crouch_move(): request_state_change.call_func('move') #move_actor_as_desired() - apply_movement_to_parent(new_move_actor_as_desired( physics_delta , current_state )) + apply_movement_to_parent( + velocity.calculate_velocity( + physics_delta , + apply_state_modifier(current_state.get_movement_parameters()), + desired_movement_vector ) + ) #func _on_state_entered_idle(): # print("Movement State Idle State Entered!") diff --git a/src/classes/velocity_calculations.gd b/src/classes/velocity_calculations.gd index ca23485..6b4106e 100644 --- a/src/classes/velocity_calculations.gd +++ b/src/classes/velocity_calculations.gd @@ -1,3 +1,4 @@ +class_name VelocityCalculations var velocity :Vector2 var debug :bool = false