685 lines
27 KiB
GDScript
685 lines
27 KiB
GDScript
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_inertia, _movement_override_normal)
|
|
else:
|
|
move_direction = resolve_move_direction(calc_inertia, 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)
|
|
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
|
|
|
|
## 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 h_speed.y != 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
|
|
if v_speed.x != v_speed.y: ## For now gravity is just the default acceleration
|
|
if (v_speed.x != 0 and v_speed.y != 0) and sign(v_speed.y) != sign(v_speed.x):
|
|
if v_speed.x < v_speed.y:
|
|
v_speed.x = clamp(v_speed.x, 0.0, v_speed.y)
|
|
else:
|
|
v_speed.y = clamp(v_speed.y, 0.0, v_speed.x)
|
|
#print (is_out_of_range(calc_inertia.y, v_speed.x - sign(v_speed.x), v_speed.y - sign(v_speed.y)))
|
|
if is_out_of_range(calc_inertia.y, v_speed.x , v_speed.y):
|
|
## ? But we only want to do this once though.
|
|
calc_inertia.y += v_speed.x
|
|
## Apply acceleration
|
|
calc_inertia.y = move_toward(calc_inertia.y, v_speed.y, movement_parameters.gravity * _delta)
|
|
else:
|
|
## The previous vertical movement methods
|
|
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}) +
|
|
"\nV_Speed Fm:{0} To:{1}".format({"0":"%5.2f" % v_speed.x, "1":"%5.2f" % v_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
|
|
|
|
enum RANGE_PLACEMENT {
|
|
BEFORE_RANGE,
|
|
WITHIN_RANGE,
|
|
PAST_RANGE
|
|
}
|
|
|
|
## 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
|
|
|
|
## 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_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)
|
|
|
|
|
|
## 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)
|
|
|