Why is the player speed not changing?

Benkeldev

I'm new to Godot and have only about a year of experience of coding within Unreal Engine. I'm attempting to make a player controller similar to Deus Ex's as a starting off point to make a larger project down the line. So far, the only mechanics that I have are the basic movements (W forward, A left, D right, S backward, and mouse to look), crouching, jumping, and leaning - all of which were from many different youtube tutorials.
The issue at hand is adding a walk/sprint function in GDscript. My entire player script is this:

`extends CharacterBody3D

Export a variable to adjust sensitivity from the editor

@export var sensitivity: float = 0.002
@export var jog_speed = 5
@export var walk_speed = 3.5
@export var sprint_speed = 6
@export var crouch_speed = 3
@export var crouch_height = 0.90
@export var stand_height = 1.9
@export var jump_velocity = 4
var target_speed
var crouching = false
var is_moving = false
var is_walking = false
var is_sprinting = false

Leaning vars

var lean_angle : float = 15.0
var lean_offset : float = 0.35
var lean_speed : float = 8.0
var target_lean : float = 0.0 # -1 = Left, 1 = Right
var current_lean : float = 0.0

Define a reference to the vertical pivot node (e.g., a "Head" Node3D)

@onready var collision_shape = $CollisionShape3D
@onready var head = $Node3D
@onready var bonker = $HeadBonker
@onready var camera_3d = $Node3D/Camera3D
var camera_rotation_x: float = 0.0

Get gravity from project settings to keep consistent

var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")

Hide cursor

func _ready():
Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

func _unhandled_input(event: InputEvent) -> void:

Check for mouse motion events

if event is InputEventMouseMotion:

Horizontal rotation (Y-axis) applied to the main body

rotation.y -= event.relative.x * sensitivity

	# Vertical rotation (X-axis) applied to the head/camera pivot
	camera_rotation_x -= event.relative.y * sensitivity
	# Clamp the vertical rotation to prevent the camera from flipping upside down
	camera_rotation_x = clampf(camera_rotation_x, deg_to_rad(-90), deg_to_rad(80))
	head.rotation.x = camera_rotation_x
	
	# Optional: You can also use the mouse's relative movement in _process or _physics_process
	# by accumulating the event.relative value in a variable

func _input(event : InputEvent) -> void:
if Input.is_action_pressed("lean_left"):
if !crouching and is_moving:
target_lean = 0.0
else:
target_lean = -1.0
elif Input.is_action_pressed("lean_right"):
if !crouching and is_moving:
target_lean = 0.0
else:
target_lean = 1.0
else:
target_lean = 0.0

func _physics_process(delta):

target_speed = jog_speed

var head_bonked = false

if bonker.is_colliding():
	head_bonked = true

# Jump
if not is_on_floor():
	velocity.y -= gravity * delta
if Input.is_action_just_pressed("jump") and is_on_floor() and !crouching:
	velocity.y = jump_velocity
	if head_bonked:
		velocity.y = -2


# Crouch/Stand mechanism

if Input.is_action_pressed("crouch"):
	collision_shape.shape.height -= crouch_speed * delta
	target_speed = crouch_speed
	crouching = true
elif not head_bonked:
	collision_shape.shape.height += crouch_speed * delta
	crouching = false
if crouching:
	target_speed = crouch_speed
collision_shape.shape.height = clamp(collision_shape.shape.height, crouch_height, stand_height)

if Input.is_action_just_pressed("walk") and !is_walking:
	if !crouching:
		target_speed = walk_speed
		is_walking = true
		print(target_speed)
elif is_walking:
	target_speed = jog_speed
	is_walking = false
	print(target_speed)
	
# Get input direction
var input_dir = Input.get_vector("move_left", "move_right", "move_forward", "move_backward")
# Calculate movement relative to the player's current rotation
var direction = (head.global_transform.basis * Vector3(input_dir.x, 0, input_dir.y))
direction.y = 0

if direction:
	velocity.x = direction.x * target_speed
	velocity.z = direction.z * target_speed
	is_moving = true
else:
	velocity.x = move_toward(velocity.x, 0, target_speed)
	velocity.z = move_toward(velocity.z, 0, target_speed)
	is_moving = false

# Head lean
current_lean = lerp(current_lean, target_lean, delta * lean_speed)

var target_tilt : float = deg_to_rad(-lean_angle) * current_lean
var target_offset : float = lean_offset * current_lean

camera_3d.rotation.z = lerp(camera_3d.rotation.z, target_tilt, delta * lean_speed)
camera_3d.position.x = lerp(camera_3d.position.x, target_offset, delta * lean_speed)

move_and_slide()`

When testing the "walk" function, I print the target_speed, which should change the speed of the player when the "walk" button is just pressed. The print shows that it is successfully changing the target_speed from the jog_speed (5) to the walk_speed (3.5), but there is no change of speed in the preview window.

Noting that the code for the stand/crouch function works completely as intended and reduces the player's speed to crouch_speed (3), what's different about the walk/jog code that makes it behave differently?

*** I'm "self-taught" from a bunch of stand alone tutorials and have had to figure out the best optimization methods for simply getting things to work. If there are mistakes I've made in the construction of this code that'll make it harder down the line or any important info I may have omitted please let me know 🙂

MikeCL

Benkeldev Hi there. Try using triple back ticks ``` to write out code with multiple lines instead of single back tick. The single back tick (or the insert code button) is mostly best for single-line code.

JosephM

Hello, I have a couple of things you should try to do in your code. First I would give this article a read. It goes over a much better way to handle movement than a list of "if then" statements like you are currently doing. I would also read up on the _physics_process documentation.
I believe your "target_speed" is always at "5" because you set the "target_speed" to the "jog_speed" at the start of every tick since it is in the _physics_process function. It is printing the run speed as 3.5 when you press the walk button because well, for 16 milliseconds or once per tick your speed is set to 3.5 and the print statement executes one time, which prints the current target speed of 3.5 but upon the next tick it is set back to 5 in the following code.

Benkeldev func _physics_process(delta):

target_speed = jog_speed

I believe your crouching mechanic is working as attended because of the following lines

Benkeldev if crouching:
target_speed = crouch_speed
collision_shape.shape.height = clamp(collision_shape.shape.height, crouch_height, stand_height)

Since you have this line in here _physics_process will first set the target speed at 5, then get to this line and set it back to the crouch speed on every tick until the "crouching" variable is no longer true.

Overall I would recommend:

Remove the first "target_speed = jog speed" at the top of your _physics_process function.
Move your movement mechanics into a finite state machine as explained in the first hyperlink
If you want a speed increase from 0 to the final moving speed instead of an instant 0-100% you can try using the lerp function to scale the speed from 0 to 5, like I believe you have done with your lean mechanic.
I'm not very confident on this one, but I think tethering your collision shape to the crouch_speed may be a bad idea in case you want to tweak the crouch animation speed and crouch movement speed independently in the future.

I hope this helps, if anyone has any corrections to my suggestions please let me know!

neropatti

Does the speed only get changed for one tick when you press the walk button, or does the print show the speed being changed for as long as you hold the button?

Benkeldev

neropatti the print is only 1 tick. My thought process was to have the "walk" function on a toggle binded to caps lock. The print is showing this is the case because the print alternates between "5" and "3.5" every time I press caps in the preview.

neropatti

If I understand the code properly, then the is_walking variable will be true for one tick when you press the walk button, and then get set back to false.

I would recommend implementing the walk toggle and choosing the speed like this:

if Input.is_action_just_pressed("walk"):
    is_walking = !is_walking # Toggle walk state

if crouching:
    target_speed = crouch_speed
    # is_walking = false # Optionally toggle walking to the desired state when crouching
elif is_walking:
    target_speed = walk_speed
else:
    target_speed = jog_speed

Note that the order if these if-statements matters! Checking for crouching first means that it will override any later statements. This means that crouching and walking will give you the same result as crouching and not walking.

Benkeldev

This seems to work (in theory) and is in fact changing the 'target_speed' variable successfully, but I'm still on square one. I can't figure out why the target_speed variable is successfully changing the player's speed for the crouch function, but has still has no effect on the walk function. I put a print(target_speed) in the physics_process function and can confirm that it is keeping the target_speed change for every tick "walk" is toggled on, and not just changing for one tick.

To be clearer, my issue is that the variable "target_speed" is changing, but it is only taking effect on the player when it is crouching and not while walking.

In other words, if player is crouched, target_speed = crouch speed. else, target_speed = jog_speed.

neropatti

Welp, I have no idea then. I can take a stab at debugging this if you can upload a project with this issue on Github/Gitlab/somewhere else I can clone it from

Either your current project or a minimum reproduction project would do!

Benkeldev

JosephM Sorry for the late reply, but I found an alternate solution (although now that I have a bit more practice, I believe you were correct in that my _physics_process function was setting target_speed to jog_speed on every tick).

The solution I ended up using was the state charts plug-in to create an organized state machine, in which upon entering the walking_state, sprinting_state, or jogging_state it sends a corresponding function in my player controller.

For example:

class_name PlayerState extends Node

func _on_sprinting_state_processing(delta: float) -> void:
player_controller.sprint()
if not Input.is_action_pressed("sprint"):
player_controller.state_chart.send_event("OnJogging")

and the function in the player controller is:

func sprint():
target_speed = sprint_speed

I don't know if this is a good procedure to follow, but I find it's much easier to code player inputs without accidentally interring with other calculations by organizing them in a state machine to dictate how they interact, then calling a custom function to the player controller when the desired state is achieved.