An easy to work with jump in Godot

better_jumping_character_example.gd

extends KinematicBody2D

export var move_speed = 200.0

var velocity := Vector2.ZERO

export var jump_height : float
export var jump_time_to_peak : float
export var jump_time_to_descent : float

onready var jump_velocity : float = ((2.0 * jump_height) / jump_time_to_peak) * -1.0
onready var jump_gravity : float = ((-2.0 * jump_height) / (jump_time_to_peak * jump_time_to_peak)) * -1.0
onready var fall_gravity : float = ((-2.0 * jump_height) / (jump_time_to_descent * jump_time_to_descent)) * -1.0

func _physics_process(delta):
	velocity.y += get_gravity() * delta
	velocity.x = get_input_velocity() * move_speed
	
	if Input.is_action_just_pressed("jump") and is_on_floor():
		jump()
	
	velocity = move_and_slide(velocity, Vector2.UP)

func get_gravity() -> float:
	return jump_gravity if velocity.y < 0.0 else fall_gravity

func jump():
	velocity.y = jump_velocity

func get_input_velocity() -> float:
	var horizontal := 0.0
	
	if Input.is_action_pressed("left"):
		horizontal -= 1.0
	if Input.is_action_pressed("right"):
		horizontal += 1.0
	
	return horizontal

Hi, trying to get this code to work in 4.2.2, but for some reason math isn't working correctly, can't figure out why. Changing "time_to_peak" and "time_to_fall" also seems to affect the jump height, which wasn't supposed to be the case.

Here's my code (with coyote time and jump buffering already implemented, you can ignore those)

extends CharacterBody2D

var speed : float = 200

var jump_height : float = 100
var time_to_peak : float = 0.5
var time_to_fall : float = 0.3

var _coyote_time : float = 0.0
var _jump_buffer : float = 0.0
var _jumped : bool = false

var _jump_velocity : float = ((2.0 * jump_height) / time_to_peak)


func _get_gravity() -> float:
	if velocity.y >= 0 and Input.is_action_pressed("MOVE_JUMP"):
		return ((2.0 * jump_height) / (time_to_peak ** 2))
	else:
		pass
		_jumped = false
		return ((2.0 * jump_height) / (time_to_fall ** 2))

func _jump() -> void:
	velocity.y = -_jump_velocity
	_jumped = true

func _physics_process(delta) -> void:
	if is_on_floor():
		_coyote_time = 0.1
		if Input.is_action_just_pressed("MOVE_JUMP") or _jump_buffer > 0.0:
			_jump()
	else:
		velocity.y += _get_gravity() * delta
		if _coyote_time > 0 and Input.is_action_just_pressed("MOVE_JUMP"):
			_jump()
		elif Input.is_action_just_pressed("MOVE_JUMP"):
			_jump_buffer = 0.2
			
		_coyote_time -= delta
		_jump_buffer -= delta
		
	
	velocity.x = clamp(Input.get_axis("MOVE_LEFT", "MOVE_RIGHT")*100, -1.0, 1.0) * speed
	
	move_and_slide()
	print(velocity)

Thanks in advance

welp, turns out my whole problem was >= instead of <=...

@Intrivus Unfortunately, what you're experiencing is an unavoidable side effect of updating the character movement using these formulas of delta time. This kind of updating is called Euler Integration and it's prone to over or underestimation in physics approximation. Generally, Euler integration behaves more physically accurate at higher framerates, as you noticed. If high precision is important, you should probably just run your project at the higher framerate as it's the easiest solution. Otherwise, you can try using a different integration method, like Runge-Kutta. I will warn that different integration methods tend to be much more complex than Euler and may be difficult to implement if you don't have a good grasp on physics and calculus.

Figure out I changed project settings for the ticks, if I unlock fps by turning off Vsync it still occur even when I have more FPS, I think there is a problem with the math or Godot 4

Physics framerate and rendering framerate are different in Godot. You can render the scene at a higher FPS with Vsync off, but Godot will still update the physics at a fixed interval depending on the project settings

Ik that Godot run at a fixed interval, anyways thanks for replying I will check out the RK method

How would I implement this jump script into my player script with state machine in godot v4.3?

I found an issue in version 4.4. Everything looks normal if no actual jump animation is associated. However, when the animation is added, there is always a delay, causing the player to stay in the air for a while before the animation appears.

class_name Player extends CharacterBody3D

@onready var player_collision: CollisionShape3D = $Collision
@onready var player_body: Node3D = $Body
@onready var player_skin: Node3D = $Body/Skin
@onready var player_camera: PlayerCamera = $Camera
@onready var animation_player: AnimationPlayer = $AnimationPlayer
@onready var animation_tree: AnimationTree = $AnimationTree
@onready var move_state_machine = $AnimationTree.get("parameters/MoveStateMachine/playback")

@export var player_data: Dictionary
@export var body_height: float = 1.7
@export var walk_speed: float = 4.0
@export var run_speed: float = 6.0
@export var jump_height: float = 1.6 
@export var jump_time_to_peak: float = 0.4 
@export var jump_time_to_descent: float = 0.3 
@export var jump_velocity : float = ((body_height * jump_height) / jump_time_to_peak) * -1.0
@export var jump_gravity : float = ((-(body_height) * jump_height) / (jump_time_to_peak * jump_time_to_peak)) * -1.0
@export var fall_gravity : float = ((-(body_height) * jump_height) / (jump_time_to_descent * jump_time_to_descent)) * -1.0

func _ready() -> void:
	print("[player]:_ready")

func _process(_delta: float) -> void:
	pass

func _physics_process(_delta: float) -> void:
	move_logic(_delta)
	jump_logic(_delta)
	move_and_slide()

func set_move_state(state_name: String) -> void:
	move_state_machine.travel(state_name)

func move_logic(_delta: float) -> void:
	var input_direction := Input.get_vector("left", "right", "forward", "backward").rotated(-player_camera.camera_main.global_rotation.y)
	var player_direction = Vector3(input_direction.x, 0, input_direction.y)
	var is_running: bool = Input.is_action_pressed("shift")
	var speed = run_speed if is_running else walk_speed
	if input_direction != Vector2.ZERO:
		velocity.x = player_direction.x * speed
		velocity.z = player_direction.z * speed
		var target_angle = -input_direction.angle() + PI/2
		player_skin.rotation.y = rotate_toward(player_skin.rotation.y, target_angle, 6.0 * _delta)
		set_move_state("default_men_run_loop" if is_running else "default_men_walk_loop")
	else:
		velocity.x = move_toward(velocity.x, 0, speed)
		velocity.z = move_toward(velocity.z, 0, speed)
		set_move_state("default_men_stand_idle_loop")

func jump_logic(_delta: float) -> void:
	if is_on_floor():
		if Input.is_action_just_pressed("jump"):
			velocity.y = -jump_velocity
	else:
		set_move_state("default_men_stand_jump_start")
	var gravity = jump_gravity if velocity.y > 0.0 else fall_gravity
	velocity.y -= gravity * _delta

There something I just can't figure out, my implementation looks fine, but jump height seems to be disregarded completely, in Godot 4.3:

extends CharacterBody2D

@export var speed = 300.0

@export var jump_height : float = 0.5
@export var jump_time_to_peak : float = 1.0
@export var jump_time_to_descent : float = 0.5

@onready var jump_velocity : float = ((2.0 * jump_height) / jump_time_to_peak) * -1.0
@onready var jump_gravity : float = ((-2.0 * jump_height) / (jump_time_to_peak * jump_time_to_peak)) * -1.0
@onready var fall_gravity : float = ((-2.0 * jump_height) / (jump_time_to_descent * jump_time_to_peak)) * -1.0

func get_input():
	return Input.get_axis("player_left", "player_right")

func get_gravity_2D():
	return jump_gravity if velocity.y < 0.0 else fall_gravity

func jump():
	velocity.y = jump_velocity

func _physics_process(delta):
	velocity.y += get_gravity_2D() * delta
	velocity.x = get_input() * speed
	
	if Input.is_action_just_pressed("player_jump") and is_on_floor():
		jump()
	
	move_and_slide()