From 1f2a5908c9db582641f77ac7ef136dead033631e Mon Sep 17 00:00:00 2001 From: Dustin Date: Sat, 15 Mar 2025 21:08:15 -0700 Subject: [PATCH] Adding movement component state based --- lib/classes/actor.gd | 4 +- lib/classes/movement_state_receiver.gd | 287 +++++++++++++++++++++++++ lib/templates/Actor/ActorTemplate.tscn | 4 +- project.godot | 6 + 4 files changed, 297 insertions(+), 4 deletions(-) create mode 100644 lib/classes/movement_state_receiver.gd diff --git a/lib/classes/actor.gd b/lib/classes/actor.gd index 3e66132..d0ed613 100644 --- a/lib/classes/actor.gd +++ b/lib/classes/actor.gd @@ -14,7 +14,7 @@ export var debug_actor: bool = false onready var sound_effect_player: AudioStreamPlayer = $SE_Player -onready var movement_component: MovementComponent = $movement_component +#onready var movement_component: MovementComponent = $movement_component #onready var movement_state_machine: StateMachineAnimatedActor = $movement_state_machine onready var movement_state_machine: StateMachine = $movement_state_machine @@ -29,7 +29,7 @@ var sound_effects_dict: Dictionary func _ready() -> void: #movement_state_machine.init_animated_actor(self) - movement_component.attack_function = funcref(self, "attack") + #movement_component.attack_function = funcref(self, "attack") # movement_component.player_number = player_number # Experimenting with sound based resources I did this and it worked diff --git a/lib/classes/movement_state_receiver.gd b/lib/classes/movement_state_receiver.gd new file mode 100644 index 0000000..7209874 --- /dev/null +++ b/lib/classes/movement_state_receiver.gd @@ -0,0 +1,287 @@ +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) +var current_movement_state:String + +# 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 acceleration = Vector2(0,0) + +var sim_velocity = Vector2(0,0) + + +#Can't use floats here, switched to constants. +#enum directions {UP = -1, DOWN = 1, LEFT, RIGHT} + +var attack_function: FuncRef + +const UP = -1.0 +const DOWN = 1.0 +const LEFT = -1.0 +const RIGHT = 1.0 + +func _ready(): + pass + +func process_physics(delta): + pass + +# Shouldn't need a proces function +#func process(delta): +# pass + +func process_input(event: InputEvent): + pass + +# 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 move_actor_as_desired(delta: float, x_move_direction_override: float = 0): + + var _move_speed = current_state.move_speed + var _move_speed_modifier = current_state.move_speed_modifier + var _move_modifier_move_acceleration = current_state.move_modifier_move_acceleration + var _move_acceleration = current_state.move_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): + print("Whoh Woah") + # Flip the direction of the acceleration + acceleration.x *= -1 + 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("be more opposite") +# if sign(_move_speed_modifier) == 1: # increased speed modifier +# print("faster faster.") + elif sign(desired_movement_vector.x) == sign(current_x_velocity) and momentum.x != 0: + 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(current_state.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 + 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 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/lib/templates/Actor/ActorTemplate.tscn b/lib/templates/Actor/ActorTemplate.tscn index 95710b9..ef89c21 100644 --- a/lib/templates/Actor/ActorTemplate.tscn +++ b/lib/templates/Actor/ActorTemplate.tscn @@ -4,7 +4,7 @@ [ext_resource path="res://lib/classes/state_machine.gd" type="Script" id=2] [ext_resource path="res://assets/actors/players/playerE/new_spriteframes.tres" type="SpriteFrames" id=3] [ext_resource path="res://lib/classes/state_animated_actor.gd" type="Script" id=4] -[ext_resource path="res://src/classes/movement_component.gd" type="Script" id=5] +[ext_resource path="res://lib/classes/movement_state_receiver.gd" type="Script" id=5] [ext_resource path="res://lib/classes/actor.gd" type="Script" id=8] [sub_resource type="Resource" id=1] @@ -43,7 +43,7 @@ __meta__ = { } callable_state_machine = NodePath("../movement_state_machine") -[node name="movement_component" type="Node" parent="."] +[node name="Movement_StateReceiver" type="Node" parent="."] script = ExtResource( 5 ) [node name="movement_state_machine" type="Node" parent="."] diff --git a/project.godot b/project.godot index 3b046fd..13ab4e1 100644 --- a/project.godot +++ b/project.godot @@ -59,6 +59,11 @@ _global_script_classes=[ { "language": "GDScript", "path": "res://src/classes/movement_component.gd" }, { +"base": "Node", +"class": "Movement_StateReceiver", +"language": "GDScript", +"path": "res://lib/classes/movement_state_receiver.gd" +}, { "base": "Resource", "class": "State", "language": "GDScript", @@ -95,6 +100,7 @@ _global_script_class_icons={ "ModifierProperties": "", "Modifier_Receiver": "", "MovementComponent": "", +"Movement_StateReceiver": "", "State": "", "StateAnimatedActor": "", "StateMachine": "",