How to implement a dash

I’m very new to godot and programming in general. Basically I want to make a test world with a bunch of random mechanics so I have a foundation for an actual game, whenever I do that. But I can’t learn dashing or find any tutorials for it for 3d anywhere, any help would be appreciated thank you.

Dashing is just running really fast for a really short period of time, isn’t it? Just increase your speed, set up a timer, and set the speed back to normal when the timer runs out.

I guess the approach will be the same regardless if it is 3D or 2D environment.
Other than that it is extremely recommended that you make use of a state machine system.

Getting those of the way it should be more manageable.

I am not that familiar with 3D stuff yet.
But in 2D we can just add more velocity to the direction we want to move in.
We need a way to time the action too, you can use the animation time, which is what I recommend. Or you could use a timer, if the animation is something seamless you should use a timer, but if the animation is well defined with a begin and end, then better use the animation time as the timer, which you can use a signal from the animationplayer to fire when it gets to the end of the animation. Arguably as signal is probably little slower than the timer(not sure).

So the Idea of dash generally in 2D space player should not be able to change the character direction, but this is a feature that you can tweak as you want, it is not a rule. In 3D space also true I guess. That also apply for using gravity or not during the dash.

So what you need is some way to control the variable and the state where the character is in. In this case it will enter in a dash state, whatever skills a character has it generally should be a state. Then you need a way to move the character differently when it is in that state.
If you can move your character around in 3D or 2D you should figure it out if you use a state machine.

Why state machine is so importante? well it dictates when and how the character can or cannot do. When in certain state will do only certain things, while in another state will do other things, so each state will give different behavior as needed.

Highly recommend using state machine system, if you are going complex enough like adding dash skills and such.

Sorry not having a good 3D space examples for you, but maybe this could give you some ideas.

extends State


class_name Dash_State

@export var animation : AnimationPlayer

func on_enter() -> void:
#all of this is needed to lock the direction of the player during the dash
#also to lock the state to not change, maybe redundancy here but it does not do ill.
	can_move = false
	hold_state = true
	character.dashDirection.x = character.direction.x
	playback.travel("roll")
	
	pass

func on_exit():
	can_move = true
	pass

func state_process(delta):
#this is the actual moving part 
	character.global_position.x += 400 * character.dashDirection.x * delta
	character.apply_gravity(delta)
	pass

func _on_animation_tree_animation_finished(anim_name: StringName) -> void:
	hold_state = false
	can_move = true
	if character.in_duck_area: #this is just for another feature in game
		next_state = states.Crouch
	else:#this is the basic you will need
		if character.is_on_floor():
			next_state = states.Ground
		if !character.is_on_floor(): 
			next_state = states.Air
	pass 

the code is all I have inside the state dash in a state machine system, it is responsible to do the action and to change to another state accordingly when it is done.
I like to use my system based on 3 or 4 basic states, Ground, Air, Wall, Water. Other than that, states for specific skills like dash. Not jump, jump is not considered a skill in this context it is just an ability which is used in the ground state.
I think it is easier to deal with lots of possibilities this way.

The application for ability and skills are just a little different, the rules applied are:
If it is a skill it will need to be implemented all of it in its own state.
If it is just an ability the implementation is done in one function from the states that allows this ability.

Like jump, it is called in the ground state and the function not only will change the state to Air state, but it will implement the movement of jump right there too.
While skills like dash we will just call a state change to the dash state in the ground state, the dash state then will handle everything from there.

It can be very confusing if you are not so familiar with state machines and the various ways it can be implemented. But I felt like given some tips from experience.

Quite simple example to work on top of it:

extends CharacterBody2D

const SPEED := 100.0
const DASH := 300.0

var tween: Tween
var dash_velocity := 0.0

func _physics_process(delta):

	if Input.is_action_just_pressed("attack"):
		dash_velocity = DASH
		if tween:
			tween.stop()
		tween = create_tween()
		tween.tween_property(self, "dash_velocity", 0, 0.3).set_ease(Tween.EASE_OUT)
	
	var direction = Input.get_axis("move_left", "move_right")
	
	if direction:
		velocity.x = direction * (SPEED + dash_velocity)
	else:
		velocity.x = move_toward(velocity.x, 0, SPEED)

	move_and_slide()

Hope it helps as starting point.

This is the feature you can rely on for that kind of transitions: Tween — Godot Engine (stable) documentation in English

yep it is, simply put.
Then you made me realize that some people refers to sprinting as dashing.

Those misconceptions are indeed odd.

Dash is more specific as a skill, which generally will behave as such with a cooldown in such.
Where abilities is such walking, running, sprinting(arguably) which will be a constante action with little or not limitations.

Skills generally are more limited.

To the question yes a dash is just a way to more more than you do normally, so bump up the speed. But there are so many consideration to do when and how you implement it.
If the game is so simple you probably will get away just using some bools , timer and bumping the speed.
Other than that state machine is everything.

So just saying the obvious which is to just increase the speed, there are more going on than just that, is it not?

Dashing, if you just bump the speed will not work, you need way to control when to start when to stop , and like said earlier , you say dash but what do you really mean? sprinting? actual dash? If it is a sprint, well it is as easy as you bump the speed while a key is held.
Which can be done with something like adding a speed to the formula of moving while a key is held.
But if it is something else, well it will get more complicated than sprinting

is it not tween used to smooth in and out?

You can use set_ease() method to decide how the interpolation behaves.

See TransitionType and easeType enums Tween — Godot Engine (stable) documentation in English