How can I get a 2D sprite to slow to a stop? - sprite

Question

I'm trying to create a playable sprite in Godot using GDScript. I've got my character moving left and right and then coming to a halt when no input is being pressed.
However, instead of coming to a dead stop, I want the sprite to slow down. How would I write that?
extends KinematicBody2D
var motion = Vector2()
func _physics_process(delta):
if Input.is_action_pressed("ui_right"):
motion.x = 250
elif Input.is_action_pressed("ui_left"):
motion.x = -250
else:
motion.x = 0
move_and_slide(motion)
pass

Answer 1

Okay I figured it out:
extends KinematicBody2D
var motion = Vector2()
func _physics_process(delta):
if Input.is_action_pressed("ui_right"):
motion.x = 250
elif Input.is_action_pressed("ui_left"):
motion.x = -250
else:
motion.x = motion.x * .9
move_and_slide(motion)

Answer 2

A very simple method is to dampen the speed at every update - a concept borrowed from physical drag.
extends KinematicBody2D
var motion = Vector2()
func _physics_process(delta):
if Input.is_action_pressed("ui_right"):
motion.x = 250
elif Input.is_action_pressed("ui_left"):
motion.x = -250
else:
motion.x *= 0.95 # slow down by 5% each frame - play with this value
# i.e. make it dependent on delta to account for different fps
# or slow down faster each frame
# or clamp to zero under a certain threshold
move_and_slide(motion)
pass
Again this is very simple. To tune the drag value can be quite finicky if you want to give certain guarantees (like the player should come to a complete stop after 6 frames) especially when you're dealing with unlocked fps.
In such cases instead of having a single motion vector, have a last_motion and a target_motion vector and interpolate between them accordingly to get the current motion vector each frame (you can do this for acceleration too). This requires you to think about state transitions like "when a player stops pressing a button", starting timers to track the progress between the start and the target frame for the interpolation, etc... What kind of interpolation function you choose will affect how responsive or sluggish the movement feels to the player.
Here's an example of slowing down within 0.2 seconds using linear interpolation:
enum MotionState {IDLE, MOVING, DECELERATING}
extends KinematicBody2D
var state = IDLE
var last_motion = Vector2()
var time_motion = 0.0
func _physics_process(delta):
var motion = Vector2();
if Input.is_action_pressed("ui_right"):
motion.x = 250
state = MOVING
last_motion = motion
elif Input.is_action_pressed("ui_left"):
motion.x = -250
state = MOVING
last_motion = motion
elif state == IDLE
motion.x = 0
else:
if state == MOVING:
# start a smooth transition from MOVING through DECELERATING to IDLE
state = DECELERATING
# last_motion already holds last motion from latest MOVING state
time_motion = 0.2
# accumulate frame times
time_motion -= delta
if time_motion < 0.0:
# reached last frame of DECELERATING, transitioning to IDLE
state = IDLE
motion.x = 0
else:
var t = (0.2 - time_motion) / 0.2 # t goes from 0 to 1
# we're linearly interpolating between last_motion.x and 0 here
motion.x = (1 - t) * last_motion.x
move_and_slide(motion)
pass
Linear deceleration will feel off, but you can easily replace that with any other function, e.g. try cubic for faster deceleration and thus more responsive slow-down: motion.x = (1 - (t * t * t)) * last_motion.x