class_name Movement_StateReceiver extends Node ## Movement component # attempts to interact with movement of the scene root without knowing what # it is. It can be perhaps a static body or kinematicbody # it doesn't actually move a node, that's what the state machine does # but it does keep track of velocity # I can't give it an actor node or a direct reference. # It can use a number of detection components to help inform decisions. 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 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) #Removing Probably not used #var sim_velocity = Vector2(0,0) var physics_delta:float var process_delta:float var modifier: StateModifierMovement #Removing Probably not used #var attack_function: FuncRef const UP = -1.0 const DOWN = 1.0 const LEFT = -1.0 const RIGHT = 1.0 func _ready(): ## 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 get_node(callable_state_machine).connect("state_changed", self,"_on_state_change") ## Get notified when modifiers updated get_node(callable_state_machine).connect("modifiers_updated",self,"_on_modifiers_updated") ## A reference to the current state machine state current_state = get_node(callable_state_machine).current_state ## A reference to the state machine merged modifiers #modifier = get_node(callable_state_machine).merged_animation_state_modifiers ############ ## These get called by the parent ############ 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() # more likely needed for Players func process_physics_input(delta): physics_delta = delta if has_method('_state_process_physics_input_' + current_state.name): call('_state_process_physics_input_' + current_state.name) # More likely needed for NPCs func process(delta): process_delta = delta if has_method('_state_process_' + current_state.name): call('_state_process_' + current_state.name) # For event based input polling (Hadouken?) func process_unhandled_input(event: InputEvent): # Reset desired movement vector desired_movement_vector = Vector2(0,0) if has_method('_state_process_input_' + current_state.name): call('_state_process_input_' + current_state.name) ############ ############ ## A Series of helper functions ############ func go_up(): desired_movement_vector.y = UP func go_down(): desired_movement_vector.y = DOWN func go_left(): desired_movement_vector.x = LEFT func go_right(): desired_movement_vector.x = RIGHT func stop(): desired_movement_vector = Vector2(0,0) # Return the desired direction of movement for the character # in the range [-1, 1], where positive values indicate a desire # to move to the right and negative values to the left. func get_movement_direction() -> float: return desired_movement_vector.x # Return a boolean indicating if the character wants to jump func wants_jump() -> bool: return false # Return a boolean indicating if the character wants to attack func wants_shoot() -> bool: return false # Return a boolean indicating if the character wants to dash func wants_dash() -> bool: return false func wants_roll() -> bool: return false func wants_climb() -> bool: return false ############ func get_climb_shape_location() -> Vector2: return Vector2(-1,-1) func _on_state_change(old_state_name:String, new_state :State): ###### State machine if new_state is StateAnimatedActor: #Testing this. Update: It works ## Confirmed that I do neet to update the current_state with the passed state. current_state = new_state if has_method('_on_state_change_' + current_state.name): call('_on_state_change_' + current_state.name) else: push_warning("Received non animated Actor state.") #current_state = new_state func _on_modifiers_updated(_modifier_type :int, _modifier_action :int, _merged_modifier :StateModifier): ## Get reference (subscribe) to the merged modifier for movement if _merged_modifier is StateModifierMovement: print("Registered Modifier Movement: ", _merged_modifier.horizontal_speed) modifier = _merged_modifier ## 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 ## #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: if _state.name == 'jump': var foo = 2+2 # break 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_inertial_dir, _movement_override_normal) else: 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) 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 # 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 ## 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 # 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: # ## And it doesn't apply in the same direction as our movement direction # if calc_inertial_dir.x != sign(move_direction.x): # ## Apply the direction of acceleration and apply as friction # # Friction allows the inertia to trend toward 0 instead of the # # 'To' direction of speed. # ## # #calc_friction.x = calc_acceleration.x * -1 # calc_friction.x = abs(calc_acceleration.x) # 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 h_speed.x != h_speed.y and calc_acceleration.x != 0.0: ## 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 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: 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 # 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 if modifier and modifier.is_active: var foo = 2+2 # breakpoint check ## Apply acceleration calc_inertia.x = move_toward(calc_inertia.x, h_speed.y, calc_acceleration.x * _delta) ## Apply friction #calc_inertia.x = move_toward(calc_inertia.x, 0, abs(calc_friction.x * _delta)) 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) # if (h_speed != debug_speed_tracker): # print("Inertia SpeedShift: ", debug_speed_tracker, h_speed, (0.0 == -0.0)) # debug_speed_tracker = h_speed else: ## inertia is just base speed calc_inertia.x = h_speed.x calc_inertial_dir.x = 0.0 # sign(calc_inertia.x) debug_speed_tracker = h_speed # if move_direction.x == 0: # calc_inertial_dir.x = sign(h_speed.x) ## Another idea, just return the calculated velocity in PPS ## For now, y component of velocity is just gravity #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 ## Can't do it this way when we have initia #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: # calc_velocity.x = calc_inertia.x * calc_inertial_dir.x # else: # 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)) 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}) + "\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}) + #"\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 ## 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 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_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) 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 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)