Solium - personal research and development

DaveTheCoder

Tomcat one “pushing” leg

When I would pick up Reuven, the cat pictured in my avatar, he had the unusual habit of helping me by pushing off with both rear legs.

kuligs2

Somewhat got what i want..

Has few bugs where at the end you can see the footing gets messed up for some reason.. need to figure out for to detect the "window" where you can request jump and after the foot was placed on ground so that it does not try to switch state to jump at the wrong moment.

At the moment in the run state i have this:

func physics_update(delta:float) ->void:
		
	animation_speed_for_unit = (step_travel_length / frames_for_one_step) * animation_fps 
	animation_speed_scale = player.velocity.length() / animation_speed_for_unit
	player.anim_player.speed_scale = animation_speed_scale
	
	
	if player.is_sprinting:
		player.move(player.speed,player.acceleration,delta)
	else:
		_current_animation_position = player.anim_player.current_animation_position
		state_machine.change_state("walk")
	
	# Handle jump.
	if player.jump_request and player.right_foot_down and player.anim_player.current_animation_position  <= 0.1:
		_current_animation_position = player.anim_player.current_animation_position
		
		state_machine.change_state("runjumpr")
	
	#if player.jump_request and !player.right_foot_down and player.anim_player.current_animation_position in range((player.anim_player.current_animation_length / 2) - 0.05,(player.anim_player.current_animation_length / 2) + 0.05) :
	if player.jump_request and !player.right_foot_down and player.anim_player.current_animation_position <= (player.anim_player.current_animation_length / 2) + 0.1:
		_current_animation_position = player.anim_player.current_animation_position
		
		state_machine.change_state("runjumpl")

I left anim_player.current_animation_position <= 0.1 window, so that the blending could happen more naturally.. i tested with hardcoded 0.0 and half positions and it was doing weird things.

In my case the run animation has both feet pushing - right, left. Animation start on right leg landing and ends on right leg landing.

I have two other runjump animations that have the starting different starting legs. And they end in half cycle - jump off one leg, land on the other.

So when i switch state from runjump back to run, after the jump, i check what was the previous state:

run.gd

func enter(_previous_state:State=null) -> void:

	previous_state = _previous_state
	player.anim_player.speed_scale = animation_speed_scale
	player.speed = char_speed
	
	player.anim_player.play("Run_32_G",custom_blend) 
	
	if previous_state != null:
		match previous_state.name:
			"RunJumpL":
				seek_to_pos = 0.0
			"RunJumpR":
				seek_to_pos = 0.5334 # halfpoint of the run animation
				
		player.anim_player.play("Run_32_G",custom_blend)
		player.anim_player.seek(seek_to_pos,false)

And i also need to figure out why there are multiple frames where it just hangs in the end of start animation frame position right in the middle of state change.. and so it looks choppy if you speed it up...

Also need to detect better way when animation stopped playing. Seems like the signal takes a little time to fire and change states.

xyz

kuligs2 Why do it in slo-mo? In animation, you can get away with with a lot when things are happening fast. And the jump in a typical game will likely happen fast. It may even not need any blending. An abrupt change may look more energetic and feel more responsive.

kuligs2

xyz slow mo for debugging, to see transitions, the speed in video was 0.25, normal speed for this animation should be 3.

Now im thinking, this is useless..

Sure it looks fancy and maybe for a short jump, but in game the jump is usually unrealistically high, with low effort from character..

So back to animation board.. gotta make the usual sequance that games have:

JumpStart, MidAir, Falling, Land.

With these i could control how long the jump is, and ho high i can jump..

You only realize the failure once you see it with your own eyes 😃...

EDIT:
Oh and blender does export all the frames even outside the render region that were set up for the animation..

So my guess is that instead of having animation start and end on the same frame, i need to key-in the one frame before the last, and delete the last frame.. need to test this out.. maybe this will get rid of that choppyness when its looping.. maybe not.. idk..

kuligs2

Has anyone had problem like this?

Notice input Dir

Whenever i land with character, it rotates in 3.14 direction for some reason..

Doesnt happen when i switch from walk/run/idle only when i switch from midair to landed.

My code is not complex, it just in many files.. and i cant find why does it rotate when landed..

What my statemachine does, is this..

Idle > jump
idle.gd

extends State

@onready var player: Player = get_parent().get_parent()
@onready var debug_ui: DebugUI = $"../../DebugUI"

var slow_down_acceleration:float = 20
var custom_blend:float = 0.5
var animation_speed_scale := 1.0

func enter(_previous_state:State=null) -> void:
	previous_state = _previous_state
	player.anim_player.speed_scale = animation_speed_scale
	player.anim_player.play("Idle_90",custom_blend)


func physics_update(delta:float) ->void:
	
	if player.input_dir != Vector2.ZERO:
		state_machine.change_state("walk")
	
	if player.is_crouching:
		state_machine.change_state("crouch")
		
	if player.velocity.length() >= 0.01:
		player.move(0,slow_down_acceleration,delta)
		
	if player.jump_request:
		state_machine.change_state("jump")
		player.jump_request = false
		
	player.move_and_slide()

jump.dg

extends State

@onready var player: Player = get_parent().get_parent()
@onready var debug_ui: DebugUI = $"../../DebugUI"

var slow_down_acceleration:float = 20
var custom_blend:float = 0.1
var custom_speed:float = 2.0

var animation_speed_scale := 0.6

func enter(_previous_state:State=null) -> void:
	previous_state = _previous_state
	debug_ui.add_label("jump")
	player.anim_player.play("JumpAscend_9_G",custom_blend,custom_speed)
	player.anim_player.animation_finished.connect(animation_done)
	player.anim_player.speed_scale = animation_speed_scale


func physics_update(delta:float) ->void:

	debug_ui.update_label("jump","Jump: %s / %s" % [player.anim_player.current_animation_length,player.anim_player.current_animation_position] )

	player.move(player.speed,player.acceleration,delta)
	player.move_and_slide()
	
	
func animation_done(animation_name:String=""):
	if animation_name != "":
		print("animation done: by signal")
	else:
		print("animation done: by anim track")
	player.velocity.y = player.jump_velocity
	player.anim_player.animation_finished.disconnect(animation_done)
	state_machine.change_state("jumpmidair", self)

midair.gd

extends State

@onready var player: Player = get_parent().get_parent()
@onready var debug_ui: DebugUI = $"../../DebugUI"

var slow_down_acceleration:float = 20
var custom_blend:float = 0.1
var custom_speed:float = 1.0

var animation_speed_scale := 1.0

func enter(_previous_state:State=null) -> void:
	previous_state = _previous_state
	player.anim_player.play("JumpMidair_66_G",custom_blend,custom_speed)
	player.anim_player.speed_scale = animation_speed_scale

func physics_update(delta:float) ->void:
	
	player.move(player.speed,player.acceleration,delta)
	player.move_and_slide()

	if player.is_on_floor():
		state_machine.change_state("jumplanded")

landed.gd

extends State

@onready var player: Player = get_parent().get_parent()
@onready var debug_ui: DebugUI = $"../../DebugUI"

var slow_down_acceleration:float = 20
var custom_blend:float = 0.1
var custom_speed:float = 3.0

var animation_speed_scale := 0.6

func enter(_previous_state:State=null) -> void:
	previous_state = _previous_state
	player.anim_player.play("JumpLanded_13_G",custom_blend,custom_speed)
	print("Jump landed Start")
	player.anim_player.animation_finished.connect(animation_done)
	player.anim_player.speed_scale = animation_speed_scale
	
func physics_update(_delta:float) ->void:
	
	player.move_and_slide()

func animation_done(animation_name:String=""):
	if animation_name != "":
		print("animation done: by signal")
	else:
		print("animation done: by anim track")
	player.anim_player.animation_finished.disconnect(animation_done)
	print("Jump landed finished")

	if player.input_dir == Vector2.ZERO and player.is_sprinting == false and !player.is_midair:
		state_machine.change_state("idle")
		
	if player.input_dir != Vector2.ZERO and !player.is_midair:
		state_machine.change_state("walk")
		
	if player.is_sprinting and !player.is_midair:
		state_machine.change_state("run")
		
	if player.is_crouching and !player.is_midair:
		state_machine.change_state("crouch")

and here is walk state

walk.gd

extends State

@onready var player: Player = get_parent().get_parent()
@onready var debug_ui: DebugUI = $"../../DebugUI"

var custom_blend:float = 0.2
var char_speed :float = 1.4

var frames_for_one_step := 16
var animation_fps := 30
var step_travel_length := 0.82
var animation_speed_for_unit :=0.0
var animation_speed_scale := 1.0

func enter(_previous_state:State=null) -> void:
	previous_state = _previous_state
	player.anim_player.speed_scale = animation_speed_scale
	player.speed = char_speed
	player.anim_player.play("Walking_32_G",custom_blend)

func physics_update(delta:float) ->void:

	animation_speed_for_unit = (step_travel_length / frames_for_one_step) * animation_fps 
	animation_speed_scale = player.velocity.length() / animation_speed_for_unit
	player.anim_player.speed_scale = animation_speed_scale

	if player.input_dir == Vector2.ZERO and player.is_sprinting == false:
		state_machine.change_state("idle")
		
	if player.is_sprinting:
		state_machine.change_state("run")
		
	if player.is_crouching:
		state_machine.change_state("crouch")
	
	if player.jump_request:
		state_machine.change_state("jump")
		player.jump_request = false
		
		
	player.move(player.speed,player.acceleration,delta)
	player.move_and_slide()

Node tree

statemachine.gd

extends Node

class_name StateMachine


@export var inital_state:State
@onready var debug_ui: DebugUI = $"../DebugUI"

var current_state:State
var states: Dictionary[String,State]={}

func _ready() -> void:
	debug_ui.add_label("statemachine")
	
	for child in get_children():
		if child is State:
			child.state_machine = self
			states[child.name.to_lower()] = child
	print("State machine loaded: ",states.size())
			
	if inital_state:
		print("State: [", inital_state.name,"] loaded")
		inital_state.enter()
		current_state = inital_state
		
	

func _process(delta: float) -> void:
	if current_state:
		current_state.update(delta)

func _physics_process(delta: float) -> void:
	if current_state:
		current_state.physics_update(delta)

func change_state(new_state_name:String, previous_state:State=null)->void:
	var new_state: State = states.get(new_state_name.to_lower())

	assert(new_state,"State not found: " + new_state_name)
	if current_state:
		current_state.exit()

	new_state.enter(previous_state)
	debug_ui.update_label("statemachine", "State: " + new_state_name.to_lower(),true)

	
	current_state = new_state

player.gd

extends CharacterBody3D

class_name Player

@onready var player_camera: PlayerCamera = $PlayerCamera
@onready var coyote_timer: Timer = $CoyoteTimer
@export var anim_player:AnimationPlayer
@onready var debug_ui: DebugUI = $DebugUI


var jump_velocity = 9
var coyote_time = 0.15
var jump_count: int = 0
var max_jump_count = 2
var is_sprinting = false

#--------- NEW ----------
var input_dir :Vector2
var direction :Vector3
var speed = 1.0
#var sprint_speed = 4.1
var acceleration = 3.0
var fps: float
var is_crouching = false
var is_ascending = false
var is_falling = false
var is_midair = false
var jump_request = false
var right_foot_down = true

signal set_foot_down

func _unhandled_input(_event: InputEvent) -> void:
	input_Action_watcher()

func _ready() -> void:
	#DisplayServer.window_set_vsync_mode(DisplayServer.VSYNC_DISABLED)
	#Engine.physics_ticks_per_second=32

	coyote_timer.one_shot = true
	coyote_timer.wait_time = coyote_time
	debug_ui.add_label("velocity")
	debug_ui.add_label("inputdir")
	debug_ui.add_label("rotation_y")
	debug_ui.add_label("button_sprint")
	debug_ui.add_label("is_ascending")
	debug_ui.add_label("is_falling")
	debug_ui.add_label("is_midair")
	debug_ui.add_label("right_foot_down")
	debug_ui.add_label("current_animation")
	debug_ui.add_label("animation_position")
	debug_ui.add_label("jump_request")
	
func _physics_process(delta: float) -> void:
	
	
	# Add the gravity.
	is_falling = velocity.y < 0 and !is_on_floor()
	is_ascending = velocity.y > 0 and !is_on_floor()
	
	debug_ui.update_label("is_falling","Falling: %s" % is_falling)
	debug_ui.update_label("is_ascending","Ascending: %s" % is_ascending)
	debug_ui.update_label("current_animation","Current animation: " + anim_player.current_animation)
	debug_ui.update_label("jump_request","Jump request: %s" % jump_request)
	debug_ui.update_label("animation_position","Current animation pos: %.4f" % anim_player.current_animation_position)
	
	if not is_on_floor():
		velocity += get_gravity() * delta
		is_midair = true
	else:
		is_midair = false
		
	debug_ui.update_label("is_midair","Midair: %s" % is_midair)
	
	# Handle jump.
	if Input.is_action_just_pressed("action_jump") and (is_on_floor() || (!coyote_timer.is_stopped() || jump_count < max_jump_count ) ):
		#velocity.y = jump_velocity
		jump_count +=1
		jump_request = true
		print("Jump button: ")

	input_dir = Input.get_vector("action_move_left", "action_move_right", "action_move_forward", "action_move_backward")
	direction = (player_camera.transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
	rotation.y=lerp_angle(rotation.y,atan2(-velocity.x,-velocity.z),0.2)
	
	# DEBUG VALUES ON SCREEN
	var vel = "Velocity len: %.2f" % velocity.length()
	debug_ui.update_label("velocity",vel)
	var inpt_dir_string = "Input dir: %.2v" % input_dir
	debug_ui.update_label("inputdir",inpt_dir_string)
	var rotation_y_string = "Input dir: %.2v" % rotation
	debug_ui.update_label("rotation_y",rotation_y_string)
	
	
	var was_on_floor = is_on_floor()
	
	if was_on_floor && !is_on_floor():
		coyote_timer.start()

	if is_on_floor() and jump_count !=0:
		jump_count = 0
		#jump_request = false

	
func input_Action_watcher():
	character_states()
	
func character_states():
	if Input.is_action_just_pressed("action_sprint"):
		is_sprinting = true
		debug_ui.update_label("button_sprint","Sprint: On")
	if Input.is_action_just_released("action_sprint"):
		is_sprinting = false
		debug_ui.update_label("button_sprint","Sprint: Off")
	if Input.is_action_just_pressed("action_crouch"):
		is_crouching = true
		debug_ui.update_label("button_sprint","Crouch: On")
	if Input.is_action_just_released("action_crouch"):
		is_crouching = false
		debug_ui.update_label("button_sprint","Crouch: Off")

func move(move_speed:float, move_acc:float, delta:float) -> void:
	
	velocity.x =  lerp(velocity.x,direction.x * move_speed,delta * move_acc)
	velocity.z = lerp(velocity.z,direction.z * move_speed,delta * move_acc)		
	
func set_foot(_foot:String):
	match _foot:
		"right":
			right_foot_down = true
		"left":
			right_foot_down = false
	#right_foot_down = !right_foot_down
	
	set_foot_down.emit(right_foot_down)
	
	if right_foot_down:
		debug_ui.update_label("right_foot_down","Foot down: Right")
	else:
		debug_ui.update_label("right_foot_down","Foot down: Left")

Maybe yaal can see what im missing here..

DaveTheCoder

kuligs2 rotates in 3.14 direction

Just in case you weren't aware, 180 degrees is equivalent to PI (approximately 3.14) radians.

xyz

kuligs2 Never lerp euler angles. Slerp bases (or quaternions) instead. In fact we should never see a thing like rotation.y = ... in your movement code. Unless you absolutely know what you're doing.

kuligs2

DaveTheCoder where in my code i do 180 deg, and its relative to world xyz.. i dont see it.

DaveTheCoder

kuligs2 where in my code i do 180 deg

In your images, is the second input_dir intended to be direction?

I don't know why the 180-degree flip occurs in your code, but it's a common problem in 3D.
https://docs.godotengine.org/en/4.5/tutorials/3d/using_transforms.html#problems-of-euler-angles

kuligs2

DaveTheCoder that is an input direction

player.gd

func _physics_process(delta: float) -> void:
	input_dir = Input.get_vector("action_move_left", "action_move_right", "action_move_forward", "action_move_backward")
	direction = (player_camera.transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()

and i think you wanted to link this paragraph

https://docs.godotengine.org/en/4.5/tutorials/3d/using_transforms.html#say-no-to-euler-angles

i guess i could try transforms

Not sure how tho.. need to think about it..

player.gd

func _physics_process(delta: float) -> void:
        rotation.y=lerp_angle(rotation.y,atan2(-velocity.x,-velocity.z),0.2)

func move(move_speed:float, move_acc:float, delta:float) -> void:
	
	velocity.x =  lerp(velocity.x,direction.x * move_speed,delta * move_acc)
	velocity.z = lerp(velocity.z,direction.z * move_speed,delta * move_acc)

xyz

kuligs2 atan is mathematically undefined if both arguments are zero.

DaveTheCoder

kuligs2 that is an input direction

Maybe I wasn't clear. How can input_dir have two values?

kuligs2

xyz

player.gd

	if velocity.x != 0.0 and velocity.z != 0.0:
		rotation.y=lerp_angle(rotation.y,atan2(-velocity.x,-velocity.z),0.2)

thanks, this fixed it.

But, now i got other problems..

Kinda fixed with this:

	input_dir = Input.get_vector("action_move_left", "action_move_right", "action_move_forward", "action_move_backward")
	direction = (player_camera.transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
	
	if direction:
		rotation.y=lerp_angle(rotation.y,atan2(-velocity.x,-velocity.z),0.2)

But you can see that when i first apply direction to right in the video, the character spazzes out like rotates wrongfully in opposite direction and then in the correct right direction.. hmm... but i think im close ..

But do i need to use transforms instead of rotation properties for character orientation in 3D space?? That doc explanatory says i do.. but im not sure..

xyz

kuligs2 thanks, this fixed it.

No it didn't. You're using operator == on floating point numbers. It's like chanting for bugs to come to you in the future.

And you're still calling unchecked atan in another place in the code.

As I said. No rotations, no atans. Work directly with a basis that stores the orientation at all times. Deducing orientation from velocity is not wise in any case.

kuligs2

DaveTheCoder

THanks for noticing,

As you can see one is rotation and the other is input dir.. copy paste error

	# DEBUG VALUES ON SCREEN
	var vel = "Velocity len: %.2f" % velocity.length()
	debug_ui.update_label("velocity",vel)
	var inpt_dir_string = "Input dir: %.2v" % input_dir
	debug_ui.update_label("inputdir",inpt_dir_string)
	var rotation_y_string = "Input dir: %.2v" % rotation

xyz As I said. No rotations, no atans. Work directly with a basis that stores the orientation at all times. Deducing orientation from velocity is not wise in any case.

Ill see what i can come up with today..

xyz It's like chanting for bugs to come to you in the future.

Yes that happens to me alot, but its not like im chanting on purpose..
debug_ui.update_label("rotation_y",rotation_y_string)

DaveTheCoder

xyz No it didn't. You're using operator == on floating point numbers.

Proper replacements:
https://docs.godotengine.org/en/4.5/classes/class_%40globalscope.html#class-globalscope-method-is-equal-approx
https://docs.godotengine.org/en/4.5/classes/class_%40globalscope.html#class-globalscope-method-is-zero-approx

xyz It's like chanting for bugs to come to you in the future.

😆

kuligs2

Asked a duck to fix for me, but it dont work as i wanted it to.. back to square one..

Atleast didnt waste too much time "prompting", interesting that the character material changes when transforms are working..

kuligs2

OK so something like this?

func _physics_process(delta: float) -> void:

	input_dir = Input.get_vector("action_move_left", "action_move_right", "action_move_forward", "action_move_backward")
	direction = (player_camera.transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()

	if direction:
		var up := Vector3.UP
		# Recompute orthonormal basis: forward, right, up
		var forward := -direction   # Godot's Basis.forward is -Z (so basis.z = -forward)
		var right := up.cross(forward).normalized()
		var corrected_up := forward.cross(right).normalized()
		var target_basis := Basis(right, corrected_up, forward).orthonormalized() 
		
		# Convert basis to quaternion, keep in mind scale is lost
		var a = transform.basis.get_rotation_quaternion()
		var b = target_basis.get_rotation_quaternion()
		# Interpolate using spherical-linear interpolation (SLERP).
		var c = a.slerp(b,0.2) # find halfway point between a and b
		# Apply back
		transform.basis = Basis(c).orthonormalized()

Idk.. feels not right.. no errors.. but playing feels too slippery..

xyz

kuligs2 Do you rotate character body or the rig? Or both? Ideally, you don't want to rotate the body, only the visual representation.

And that code looks vibe coded. You don't really need to use quaternions. Godot can interpolate bases. You also should always use global basis. transform.basis is Godot 3 code. Godot 4 exposes basis directly. Spend more time with Transform3D class reference and less with prompting.

Oh and interpolation towards wanted basis should happen always, not only when controls are held down. Otherwise the interpolation may stop halfway when player releases the controls. It should also be framerate independent.

kuligs2

xyz funny you say "vibe coded", its actually from godot documentation.. https://docs.godotengine.org/en/4.5/tutorials/3d/using_transforms.html#interpolating-with-quaternions i guess they use vibers to create docs. no wonder its sometimes not too clear to understand. The quternion class was giving me erros and error said i need to use get rotation so i modified that part.

And i apply these transforms on Character3D node, why would i want to rotate only visual node? How the hell would i move the character node if only visuals are moving?

kuligs2

kuligs2 And i cannot set the transform all the time because, if direction is zero then it throws me errors.

if direction:
		var up := Vector3.UP
		# Recompute orthonormal basis: forward, right, up
		var forward := -direction   # <-----------------------------------------------------------------
		var right := up.cross(forward).normalized()
		var corrected_up := forward.cross(right).normalized()
		var target_basis := Basis(right, corrected_up, forward).orthonormalized()

xyz

kuligs2 And i apply these transforms on Character3D node, why would i want to rotate only visual node? How the hell would i move the character node if only visuals are moving?

Only move character body, only rotate visual representation. But this is not issue here.