I was just wondering, the player moves horizontally while pressing the "key" down, however, when the player releases the "key" the character comes to a stop, what causes that? Is it the move_and_slide() function?
Thanks in advance!
I thought about it again: It's not the move_and_slide() function, rather it's the when the player releases the "key", the action strength from the method get_action_strength() is reset to zero (direction.x = 0.0), which when multiplied with speed.x the resulting
_velocity.x = speed.x * direction.x = 0.0
Is that the correct reasoning? Although the move_and_slide() function also does reset the _velocity when colliding with an object.
I was trying to see on how to introduce friction, that's why I came across the above question.
It's correct, the direction multiplies the speed by 0.
To introduce friction, instead of instantly setting the velocity, you need to gradually increase or decrease it. People mostly do that using a function called lerp() (it means linear interpolation). It calculates a weighted average between two values.
It works, but I'll recommend steering behaviors. It looks something like this in your case (note: I'm writing the code here and not testing it, but it's the general idea).
var desired_x_velocity = speed.x * direction.x
var steering = _velocity.x - desired_x_velocity
_velocity.x += steering * delta * 8.0
Let me explain how it works and then why it works well in many situations.
You want to treat the currently instant velocity as some target velocity you want to reach over time (desired_x_velocity).
To know how much the velocity has to change, you calculate the difference with the steering variable: it's how much my _velocity.x has to change to become desired_x_velocity.
To get your friction, you add only a portion of that steering to the velocity every frame (that's the 3rd line).
You'll notice I use a value of 8.0 there. It's completely arbitrary. It's just that delta is very small, so multiplying the steering just by delta would make the character accelerate too slowly.
You want to adjust that value depending on how the character feels: it controls how much it accelerates or decelerates.
Why use that steering equation?
There are four reasons I often recommend steering equations:
Here's an example of this steering equation applied to movement like in The Binding of Isaac (top-down view, 8 movement directions):
var desired_velocity = speed * direction
var steering = _velocity - desired_velocity
_velocity += steering * delta * 8.0
It's almost the same!
I hope this help. 🙂
It was a little tricky to figure out how to implement it. at first, the directions of the character got reversed, I did some changes and this is what I came up with: it makes the character slide a little when the button is released, feels like the character has momentum now.
export var slide = 2.0
func _physics_process(delta: float) -> void:
var direction: = Vector2(
Input.get_action_strength("move_right") - Input.get_action_strength("move_left"),
var desired_velocity = speed.x * direction.x
var steering = desired_velocity - velocity.x
velocity.x += steering * delta * slide
velocity = move_and_slide(velocity)