Godot jump animation starting after a slight delay from the input - 2d-games

Question

this is one of my first projects and i'm writing this code following a tutorial on YT. This tutorial does not include stuff about animation as far as i've seen, so i tried getting it done myself and the idle and run animations work. The jump also works but it starts after a slight delay and doesn't complete its cycle because the character lands too soon (for this last problem i'll try adjusting the speed of the animation)
extends Actor
func _physics_process(delta):
var direction = get_direction()
velocity = calculate_move_velocity(velocity, direction, maxSpeed)
velocity = move_and_slide(velocity, FLOOR_NORMAL) #Funzione che permette il movimento del personaggio
func get_direction() -> Vector2:
return Vector2(
Input.get_action_strength("right") - Input.get_action_strength("left"),
-1.0 if Input.is_action_just_pressed("jump") and is_on_floor() else 0.0
)
func calculate_move_velocity( #Movimento e Animazioni
linear_velocity: Vector2,
direction: Vector2,
maxSpeed: Vector2
) -> Vector2:
var new_velocity = linear_velocity #la new_velocity sarà il movimento lineare del personaggio
new_velocity.x = maxSpeed.x * direction.x
new_velocity.x = lerp(new_velocity.x, 0, 0.1)
if is_on_floor() and direction.x == 1.0: #muoversi verso destra
$AnimationPlayer.play("run")
$Sprite.scale.x = 1
elif is_on_floor() and direction.x == -1.0: #muoversi verso sinistra
$AnimationPlayer.play("run")
$Sprite.scale.x = -1
if is_on_floor() and direction.x == 0.0: #stare fermi
$AnimationPlayer.play("idle")
new_velocity.y += gravity * get_physics_process_delta_time()
if direction.y == -1.0: #saltare
new_velocity.y = maxSpeed.y * direction.y
if !is_on_floor() == false and Input.is_action_just_pressed("jump"):
$AnimationPlayer.play("jump")
return new_velocity

Answer 1

I see a lot of little things, will go over them one by one.
Is on floor?
The value is_on_floor() is updated when you call move_and_slide(...). But you are calling is_on_floor() before calling move_and_slide(...), which means it is operating the value of the prior physics frame. In fact, you want move_and_slide(...) to hit the ground (and thus, you probably want to apply gravity first).
This by it self is not a big deal. It is mostly noticeable for frame perfect jump, but still.
Lerp?
I'm looking at this line:
new_velocity.x = lerp(new_velocity.x, 0, 0.1)
Let us see the official documentation for lerp. It says the signature of lerp is:
Variant lerp ( Variant from, Variant to, float weight )
So we are interpolating from new_velocity.x to 0 with a weight of 0.1. I believe that is the same as:
new_velocity.x *= 0.9
Considering that other line also:
new_velocity.x = maxSpeed.x * direction.x
new_velocity.x = lerp(new_velocity.x, 0, 0.1)
We have:
new_velocity.x = maxSpeed.x * direction.x * 0.9
And considering that direction.x goes from -1 to 1, we have that new_velocity.x never reaches maxSpeed.x.
Why you want to do that? What do you think you are accomplishing?
Scale sprite?
You use $Sprite.scale.x = 1 and $Sprite.scale.x = -1. Sprites have a flip_h property strongly encouraged for this use.
Double negative?
You have this little nugget of code: !is_on_floor() == false.
Let us make a truth table:
is_on_floor() │ !is_on_floor() │ !is_on_floor() == false
──────────────┼────────────────┼──────────────────────────
false │ true │ false
true │ false │ true
As you can see, !is_on_floor() == false is the same as is_on_floor(). By the way, it returns bool, not Variant, in case that is your concern.
Playing animation multiple times
As you must be aware, calling AnimationPlayer.play multiple times with the same animation, is no problem at all. Which also means you don't need to check if the jump action was just pressed.
Separation of concerns
On one hand we have the concern of moving the kinematic body. On the other we have the concern of playing the animations. The first concern is a physics concern. It make sense to do it in _physics_process. The second concern is a visual concern. It makes sense to do it in _process instead.
Bringing it all together.
func _physics_process(delta:float) -> void:
velocity.y += gravity * delta
velocity = move_and_slide(velocity, Vector2.UP)
var h_direction = Input.get_action_strength("right") - Input.get_action_strength("left")
velocity.x = maxSpeed.x * h_direction
if Input.is_action_just_pressed("jump") and is_on_floor():
velocity.y = -maxSpeed.y
func _process(_delta:float) -> void:
if is_on_floor():
if velocity.x == 0.0:
$AnimationPlayer.play("idle")
$Sprite.flip_h = false
else:
$AnimationPlayer.play("run")
$Sprite.flip_h = velocity.x < 0.0
else:
$AnimationPlayer.play("jump")
Short and sweet.
Note: I replaced FLOOR_NORMAL with Vector2.UP. Also I removed the 0.9 introduced by lerp. Otherwise this should be the same, minus is_on_floor and animation play timing issues (I think this also differs on walls, there is is_on_wall() if that is an issue). However, we are talking of issues that at most expand one physics frame.
One more thing
Given that you are working with sprites in 2D. Consider using AnimatedSprite for the sprite animations instead of AnimationPlayer.
By the way, the timing of the animation may be the causing an apparent delay. For example if the first sprite of the jump animation matches - say - a frame of the idle animation. That is one whole frame that has to pass before we see a jump sprite. Double check that.