diff --git a/assets/actors/players/playerE/new_spriteframes.tres b/assets/actors/players/playerE/new_spriteframes.tres index 1d1e9ea..e0b46ed 100644 --- a/assets/actors/players/playerE/new_spriteframes.tres +++ b/assets/actors/players/playerE/new_spriteframes.tres @@ -98,6 +98,6 @@ animations = [ { }, { "frames": [ SubResource( 14 ), SubResource( 15 ), SubResource( 16 ), SubResource( 17 ), SubResource( 17 ), SubResource( 18 ), SubResource( 14 ), SubResource( 19 ), SubResource( 19 ), SubResource( 19 ) ], "loop": true, -"name": "default", +"name": "idle", "speed": 11.0 } ] diff --git a/lib/classes/animated_sprite_state_receiver.gd b/lib/classes/animated_sprite_state_receiver.gd index ea8d041..3c00f76 100644 --- a/lib/classes/animated_sprite_state_receiver.gd +++ b/lib/classes/animated_sprite_state_receiver.gd @@ -28,10 +28,13 @@ var previous_state_frame_number : int var previous_state_name: String var previous_speed_multiplier: float +var show_frame:bool = false + # Called when the node enters the scene tree for the first time. func _ready(): request_state_change = funcref(get_node(callable_state_machine), 'change_to_known_state') get_node(callable_state_machine).connect("state_changed", self,"_on_state_change") + self.connect("animation_finished",self,"_on_animation_finished") # Sprites should only have a process function # but if I have this will the sprite still animate? @@ -40,6 +43,32 @@ func _process(delta): if current_state.state_timeout.time_left == 0: print("You're out of time! I saw it!") request_state_change.call_func('idle') + #play() + process_animations() + + # Need to detect when animation is finished. + # This spit out to the console too many times. +# if (frame + 1) == frames.get_frame_count(animation): +# print("done.") + # asynchronous animation completed check. +# if show_frame: +# print(frame, "-done.") +# show_frame = false + # Turns out frame 0 is when animation get signaled. + + #Disabling for now: +# if frames.get_animation_loop(animation) == false: +# #print("Stop!!!!!", current_state.animation_sequence.size(), " - ", current_state.animation_index) +# if current_state.animation_sequence.size() > 0: +# #print("<-- next anim.") +# current_state.animation_index += 1 +# if current_state.animation_index >= current_state.animation_sequence.size(): +# #print("Stop!!!!!") +# current_state.animation_finished = true + +func _on_animation_finished(): + print(frame, "- Frame done (self signaled)") + show_frame = true # Called every frame. 'delta' is the elapsed time since the previous frame. #func _process(delta): @@ -82,7 +111,7 @@ func update_animation(enter_frame := 0, index := 0, suffix := ''): enter_frame = modifier.starting_frame modifier.TYPE.ANIMATION_SUFFIX: - if self.animations.frames.has_animation(mod_animation_sequence[animation_index] + modifier.animation_name): + if frames.has_animation(mod_animation_sequence[animation_index] + modifier.animation_name): animation_suffix = modifier.animation_name else: print("Warning!: Modifier attempting to apply suffix that doesn't exist ", @@ -103,12 +132,12 @@ func update_animation(enter_frame := 0, index := 0, suffix := ''): animation_index = 0 current_animation_sequence = animation_index - if self.frames.has_animation(mod_animation_sequence[animation_index] + animation_suffix) == false: + if frames.has_animation(mod_animation_sequence[animation_index] + animation_suffix) == false: if current_state.debug_state: print("Warning!: Animation doesn't exist! ") if enter_frame != 0: - if self.animations.frames.get_frame_count(self.animations.animation) != self.animations.frames.get_frame_count(mod_animation_sequence[animation_index] + animation_suffix): + if frames.get_frame_count(animation) != frames.get_frame_count(mod_animation_sequence[animation_index] + animation_suffix): if current_state.debug_state: print("Warning!: attempting to set a mismatched frame ") enter_frame = 0 @@ -116,9 +145,9 @@ func update_animation(enter_frame := 0, index := 0, suffix := ''): if mod_animation_sequence.size() > 0: if current_state.debug_state: print("Starting Animation: " , mod_animation_sequence[animation_index] + animation_suffix) - self.animations.play(mod_animation_sequence[animation_index] + animation_suffix) + play(mod_animation_sequence[animation_index] + animation_suffix) #TODO: maybe check current animatio has this frame - self.animations.frame = enter_frame + frame = enter_frame else: print("Error! Resolved to empty animation sequence!?") return @@ -134,7 +163,7 @@ func process_animations(): modifier.TYPE.ANIMATION_SUFFIX: # Attempt to seemlessly transition animations. modifier = null - update_animation(self.animations.frame,animation_index) + update_animation(frame,animation_index) modifier.TYPE.REPLACE_ANIMATION: if current_state.debug_state: @@ -149,20 +178,20 @@ func process_animations(): # We have no more sequence animations and the current one doesn't loop # we do this to prevent the default idle animation from playing. ##TODO: between this and the signal based iterator I get some really strange behavior - if animation_index >= mod_animation_sequence.size() and self.animations.frames.get_animation_loop( - self.animations.animation) == false: + if animation_index >= mod_animation_sequence.size() and frames.get_animation_loop( + animation) == false: #print(animations.animation, " Animation Stopped") - self.animations.stop() + stop() #animation_finished = true elif mod_animation_sequence.size() > animation_index and current_animation_sequence != animation_index: #TODO: why was I doing this # if animation_index >= mod_animation_sequence.size(): # animation_index = 0 ##TODO: Add a safety check here. - self.animations.play(mod_animation_sequence[animation_index] + animation_suffix) + play(mod_animation_sequence[animation_index] + animation_suffix) if current_state.debug_state: print("An animation sequence: ", mod_animation_sequence[animation_index - 1], " -> ", - self.animations.animation , " (", animation_index, ")") + animation , " (", animation_index, ")") current_animation_sequence = animation_index ##TODO: Could probably add some more checks here. @@ -196,6 +225,7 @@ func _on_state_change(old_state_name:String, new_state :State): ###### State machine if new_state is StateAnimatedActor: #Testing this. Update: It works current_state = new_state + update_animation() print("It's an animated Actor state!") else: push_warning("Received non animated Actor state.") diff --git a/lib/classes/state_animated_actor_txt.gd b/lib/classes/state_animated_actor_txt.gd deleted file mode 100644 index 7f27899..0000000 --- a/lib/classes/state_animated_actor_txt.gd +++ /dev/null @@ -1,438 +0,0 @@ -class_name dmod -extends State -## Animation and movement state class -## -## A state intended to control the movement and animation -## functions of a KinimaticBody2D node. Initialized with a -## player, movement node, and kinematicbody2d -## I think if we also had modifier states that transfered along with the enter and entrance of nodes, that would be helpful. -## -## @WIP - -# export (NodePath) var jump_node - -# onready var jump_state: State = get_node(jump_node) - -## Deprecated -# export var animation_name: String - -# Movement Speed in Pixels Per Second -export var move_speed: float = 60 -export var move_acceleration: float = 0 -export var move_speed_modifier: float = 0 -export var move_modifier_move_acceleration: float = 0 -export var jerk_factor: float = 0 - -#var adjusted_move_speed: float -var jerk: float - -var physics_modifier :StateModifier - -##TODO: Deprecate this useless fool! -var speed_multiplier: float = 1.0 - -export(Array, String) var animation_sequence - -signal frame_reached(state_name, animation_name, frame_number) -export(Dictionary) var emitter_frame_subscriptions -var frame_signal_emitted: bool = false - -var animation_finished: bool = false - - -# this just wouldn't work well. Maybe I can try a resource -# export(Array, NodePath) var transition_state_nodes - -#TODO: I think these two variables accidentally serve the same purpose -# I think one was intended to be a string of the current animation name. -var animation_index: int = 0 -var current_animation_sequence: int = 0 -var animation_suffix: String = ''; - -var mod_animation_sequence = [PoolStringArray()] - -var gravity: int = ProjectSettings.get_setting("physics/2d/default_gravity") - -var animations: AnimatedSprite -var move_component: MovementComponent -var parent: KinematicBody2D - -#animation_name :String, frame_number : int, animation_sequence :Array -var previous_animation_name : String -var previous_state_frame_number : int -var previous_state_name: String -var previous_speed_multiplier: float - -var modifier: StateModifier - - -# If called, this will attempt to make the most appropriate animation change -# would likely be triggered from an animation sequence finishing or a -# modifier being applied/removed outside of enter/exit transitions. -func update_animation(enter_frame := 0, index := 0, suffix := ''): - ## TODO: - # Need to find a way to attempt to keep and transfer the Index or frame -# -# if clear_modifier: -# print("Goodbye Modifiers!") -# modifier = null -# if modifier: -# if modifier.state_timeout and modifier.timeout_seconds == 0: -# modifier = null - - # By Default, we build an animation sequence off of this state's before checking - # for modifiers - mod_animation_sequence.clear() - mod_animation_sequence.append_array(animation_sequence) - # Reset animation suffix in case there isn't one - animation_suffix = suffix - animation_index = index - current_animation_sequence = animation_index - #var enter_animation = '' - #var enter_frame = 0 - - if modifier != null: -# if modifier.modifier_type == modifier.TYPE.EXIT_ANIMATION: -# #print("OHHH Modifier Applies! ", modifier.animation_name) -# mod_animation_sequence.push_front(modifier.animation_name) -# enter_frame = modifier.starting_frame - match modifier.modifier_type: - modifier.TYPE.EXIT_ANIMATION: - mod_animation_sequence.push_front(modifier.animation_name) - enter_frame = modifier.starting_frame - - modifier.TYPE.ANIMATION_SUFFIX: - if animations.frames.has_animation(mod_animation_sequence[animation_index] + modifier.animation_name): - animation_suffix = modifier.animation_name - else: - print("Warning!: Modifier attempting to apply suffix that doesn't exist ", - mod_animation_sequence[animation_index] + modifier.animation_name) - - modifier.TYPE.REPLACE_ANIMATION: - #animations.play(modifier_stack_ref[i].animation_name) - #animations.frame = modifier_stack_ref[i].starting_frame - mod_animation_sequence.clear() - mod_animation_sequence.push_back(modifier.animation_name) - enter_frame = modifier.starting_frame - - # Some safety checks with supplied update parameters - if animation_index != 0: - if mod_animation_sequence.size() < animation_index + 1: - if debug_state: - print("Warning!: attempting to set to non-existant index ") - animation_index = 0 - current_animation_sequence = animation_index - - if animations.frames.has_animation(mod_animation_sequence[animation_index] + animation_suffix) == false: - if debug_state: - print("Warning!: Animation doesn't exist! ") - - if enter_frame != 0: - if animations.frames.get_frame_count(animations.animation) != animations.frames.get_frame_count(mod_animation_sequence[animation_index] + animation_suffix): - if debug_state: - print("Warning!: attempting to set a mismatched frame ") - enter_frame = 0 - - if mod_animation_sequence.size() > 0: - if debug_state: - print("Starting Animation: " , mod_animation_sequence[animation_index] + animation_suffix) - animations.play(mod_animation_sequence[animation_index] + animation_suffix) - #TODO: maybe check current animatio has this frame - animations.frame = enter_frame - else: - print("Error! Resolved to empty animation sequence!?") - return - - -func enter() -> void: - if debug_state: - print(parent.name, " entering State: ", self.name) - move_component.current_movement_state = self.name - emit_signal("state_entered") - #modifier_stack_ref = state_modifiers - update_animation() - - # Reset movespeed counters - #move_component.momentum.x = move_speed_modifier - jerk = 0 - - return - -func exit() -> void: - emit_signal("state_exited") -# animations.disconnect("animation_finished", self, "_on_AnimatedSprite_animation_finished") - #modifier = null - return - -func transfer_modifiers(exiting_state_modifier : StateModifier): - if modifier == null: # We have no existing modifier applied. - match exiting_state_modifier.modifier_type: - exiting_state_modifier.TYPE.ANIMATION_SUFFIX: - if debug_state: - print("Transferring Animation Suffix") - modifier = exiting_state_modifier - exiting_state_modifier.TYPE.EXIT_ANIMATION: - if debug_state: - print("Exit Animation: well this was useless.") - else: - print("Insert modifier merge function here...") - -func process_input(_event: InputEvent) -> String: - return '' - -func process_animations(): - - if modifier != null: - if modifier.state_timeout and modifier.state_timeout.time_left == 0: - print("Expired Modifier, updating animation.") - #modifier = null - match modifier.modifier_type: - - modifier.TYPE.ANIMATION_SUFFIX: - # Attempt to seemlessly transition animations. - modifier = null - update_animation(animations.frame,animation_index) - - modifier.TYPE.REPLACE_ANIMATION: - if debug_state: - print("I don't have anything for replacements yet.") - modifier = null - update_animation() - _: - modifier = null - return - - - # We have no more sequence animations and the current one doesn't loop - # we do this to prevent the default idle animation from playing. - ##TODO: between this and the signal based iterator I get some really strange behavior - if animation_index >= mod_animation_sequence.size() and animations.frames.get_animation_loop( - animations.animation) == false: - #print(animations.animation, " Animation Stopped") - animations.stop() - #animation_finished = true - elif mod_animation_sequence.size() > animation_index and current_animation_sequence != animation_index: - #TODO: why was I doing this -# if animation_index >= mod_animation_sequence.size(): -# animation_index = 0 - ##TODO: Add a safety check here. - animations.play(mod_animation_sequence[animation_index] + animation_suffix) - if debug_state: - print("An animation sequence: ", mod_animation_sequence[animation_index - 1], " -> ", - animations.animation , " (", animation_index, ")") - current_animation_sequence = animation_index - - ##TODO: Could probably add some more checks here. - - # Singal based frame call. - if emitter_frame_subscriptions.has(animations.frame): - if emitter_frame_subscriptions[animations.frame] == animations.animation: - if frame_signal_emitted == false: - emit_signal("frame_reached", self.name, animations.animation, animations.frame) - # Try to only so this once. - frame_signal_emitted = true - else: - frame_signal_emitted = false - -func process_frame(_delta: float) -> String: - return '' - -func process_physics(_delta: float) -> String: - move_actor_as_desired(_delta) - return '' - -#func _on_AnimatedSprite_animation_finished(): -# if animations.frames.get_animation_loop(animations.animation) == false: -# animation_index += 1 - -func move_actor_as_desired(delta: float, x_move_direction_override: float = 0): - - var _move_speed = move_speed - var _move_speed_modifier = move_speed_modifier - var _move_modifier_move_acceleration = move_modifier_move_acceleration - var _move_acceleration = move_acceleration - var _jerk_factor = jerk_factor - var _gravity = gravity - - if 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 = 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 move_component.desired_movement_vector.x != 0: - _move_speed = abs(move_component.desired_movement_vector.x) - - # Determine or physics movement direction - var current_x_velocity = move_component.velocity.x #move_component.velocity.x - var move_direction = 0.0 - # Determine movement direction if we have momentum - if move_component.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 = move_component.desired_movement_vector.x - else: - move_direction = x_move_direction_override - -## TODO: I hate that I have to do this check again. - if physics_modifier: - var mod_props :ModifierProperties = 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(move_component.acceleration.x) != abs(_move_modifier_move_acceleration + _move_acceleration): - if move_direction: - print("Acceleration changed.", abs(move_component.acceleration.x), "-", (_move_modifier_move_acceleration + _move_acceleration)) - move_component.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(move_component.desired_movement_vector.x) and move_component.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(move_component.acceleration.x) == sign(move_component.momentum.x): - print("Whoh Woah") - # Flip the direction of the acceleration - move_component.acceleration.x *= -1 - if (sign(move_component.desired_movement_vector.x) == -1 and - sign(current_x_velocity) == 1) or (sign(move_component.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(move_component.desired_movement_vector.x) == sign(current_x_velocity) and move_component.momentum.x != 0: - if sign(move_component.acceleration.x) != sign(move_component.momentum.x) and x_move_direction_override == 0: - print("Step it up!") - # Flip the direction of the acceleration - move_component.acceleration.x *= -1 - - # Apply momentum and acceleration if a modifer exists - if move_component.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: - move_component.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 - move_component.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. - move_component.momentum.x = abs(move_speed_modifier) - print("momentum applied!") - - # Reverse the accelerations if we carry over momentum but the modifier no longer applies. - if move_component.momentum.x > 0 and _move_speed_modifier == 0: - if sign(move_component.acceleration.x) == sign(move_component.momentum.x): - print("Whoh Woah your done.") - # Flip the direction of the acceleration - move_component.acceleration.x *= -1 - - - # We're going to adjust our move speed only to the modifier - move_component.momentum.x += move_component.acceleration.x * delta - 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 - move_component.momentum.x = clamp(move_component.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 * move_component.momentum.x) # + jerk - elif sign(_move_speed_modifier) == +1: # increased speed modifier -# MIN_SPEED = _move_speed -# MAX_SPEED = _move_speed + _move_speed_modifier - move_component.momentum.x = clamp(move_component.momentum.x, 0, _move_speed_modifier ) - new_move_speed = _move_speed + move_component.momentum.x # + jerk - else: # physics won't apply here -# move_component.acceleration.x = 0 -# move_component.momentum.x = 0 -# new_move_speed = _move_speed - move_component.momentum.x = clamp(move_component.momentum.x, 0, MIN_SPEED ) - new_move_speed = _move_speed + move_component.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 * move_component.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(move_component.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(move_component.momentum.x)) + - ",A" + str(round(move_component.acceleration.x)) + - "\nVel:" + str(round(move_component.velocity.x)) + "Min:" + str(round(MIN_SPEED)) + ",Max:" + str(round(MAX_SPEED)) - ) # str(round(jerk)) - - move_component.sim_velocity.x = move_direction * sim_move_speed - #print(adjusted_move_speed, ",", new_move_speed, ",", jerk) - - #print(new_move_speed, " ", adjusted_move_speed) - - move_component.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 - move_component.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 move_component.velocity.y < -8: - snap = Vector2.ZERO - move_component.velocity = parent.move_and_slide_with_snap(move_component.velocity, snap , Vector2.UP, true) diff --git a/lib/templates/Actor/ActorTemplate.tscn b/lib/templates/Actor/ActorTemplate.tscn index c1a9557..95710b9 100644 --- a/lib/templates/Actor/ActorTemplate.tscn +++ b/lib/templates/Actor/ActorTemplate.tscn @@ -27,6 +27,7 @@ script = ExtResource( 8 ) [node name="AnimatedSprite_StateReceiver" type="AnimatedSprite" parent="."] frames = ExtResource( 3 ) +animation = "idle" script = ExtResource( 1 ) __meta__ = { "_aseprite_wizard_config_": { diff --git a/project.godot b/project.godot index 09f8df3..3b046fd 100644 --- a/project.godot +++ b/project.godot @@ -83,11 +83,6 @@ _global_script_classes=[ { "class": "StateModifier", "language": "GDScript", "path": "res://lib/classes/state_modifier.gd" -}, { -"base": "State", -"class": "dmod", -"language": "GDScript", -"path": "res://lib/classes/state_animated_actor_txt.gd" } ] _global_script_class_icons={ "Actor": "", @@ -104,8 +99,7 @@ _global_script_class_icons={ "StateAnimatedActor": "", "StateMachine": "", "StateMachineAnimatedActor": "", -"StateModifier": "", -"dmod": "" +"StateModifier": "" } [application]