Character doesn't switch to other animation after stopping moving

Help Animation
1

Godot Version

4.4.1

Question

`Character doesn’t switch to other animation after stopping moving

func _physics_process(delta):
		if current_id_path.is_empty():
			return
		if is_moving == false:
			target_position = tile_map.map_to_local(current_id_path.front())
			is_moving = true
		global_position = global_position.move_toward(target_position, 1)
		if global_position == target_position:
				current_id_path.pop_front() 
				if current_id_path.is_empty() == false:
					target_position = tile_map.map_to_local(current_id_path.front())
				else:
					is_moving = false
		var walking_direction = target_position - global_position
		var facing_direction	
		if (abs(walking_direction.x) > abs(walking_direction.y)):
			if walking_direction.x > 0:											#walking x axis
				facing_direction = FacingDirection.RIGHT
				animation_player.play("walking_right")
			else:
				facing_direction = FacingDirection.LEFT
				animation_player.play("walking_left")
		elif abs(walking_direction.y) > abs(walking_direction.x): 				#walking y axis
			if walking_direction.y > 0:
				facing_direction = FacingDirection.DOWN
				animation_player.play("walking_down")
			else:
				facing_direction = FacingDirection.UP
				animation_player.play("walking_up")

I’ve tried various code but it just doesn’t switch to the idle animation in which direction the character was moving to. Please help thanks
`

2

hi, use an AnimationTree.
an AnimationPlayer is very limited and should only be used for single animations or if you want to manually control the states.

you can use expressions with AnimationTree to have the states changed when you change a variable in your script
https://godotforums.org/d/39521-this-is-how-to-use-animationtree-state-machine-transitions-with-expressions

here you set a facing walk animation. but nowhere in the code do you set an idle animation.
animation_player.play("idle") ?

3

Trying to implement state machine into my game but I just don’t know how to implement directions into my physics function in the state machine itself. At least with the tutorial i watched. With WASD inputs it would be easy but my movement is click to move on a grid so my character needs to spawn facing down and go into the idle state to x,y direction in which it was waking.

extends NodeState

@onready var player : CharacterBody2D
@export var animated_sprite_2d : AnimatedSprite2D

var direction: Vector2

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


func _on_physics_process(_delta : float) -> void:
	#i dont know how to implement direction physics
			if direction == Vector2.DOWN:
				animated_sprite_2d.play("idle_down")
			elif direction == Vector2.UP:
				animated_sprite_2d.play("idle_up")
			elif direction == Vector2.LEFT:
				animated_sprite_2d.play("idle_left")
			elif direction == Vector2.RIGHT:
				animated_sprite_2d.play("idle_right")
			else:
				animated_sprite_2d.play("idle_down")
func _on_next_transitions() -> void:
	pass


func _on_enter() -> void:
	pass


func _on_exit() -> void:
	pass

Now that I think about it do i need to just copy the code I had in player.gd into walking_state.gd and somehow use that to determine the direction in idle_state.gd?

4

let’s start with this. this is bad code.
code should be as simple as possible.

1 - Do as I said, remake your character with a Sprite2D and AnimationPlayer. Do not use AnimatedSprite2D for characters.
you are gonna need all your sprites in a single texture called a spritesheet for this.

2 - use an AnimationTree. in Tree Root, create a state machine.
in the state machine, add a BlendSpace2D as a state, call it “walk”. add a second BlendSpace2D state, call it “idle”.
in walk, add your four walking animations in the four directions.
in idle, add your 4 idle animations in different directions. or, if you only have one animation for idle, don’t use a blend2D and add an animation as the state.

connect the Start to “idle”. then connect idle to walk. then connect walk to idle, so there are arrows going in and out.

3 - select your arrow going from idle to walk, and in expression type “walk”. then in the arrow going from walk to idle type “not walk”.

4 - in the AnimationTree, in the inspector, there’s a field called Advance Expression

AdvanceExpression
AdvanceExpression399×222 14.5 KB

click there and select the node that has the script.
you also need to set Anim Player to your AnimationPlayer

5 - in your script, you need a property walk, that will control the walking state. and a reference to your AnimationTree.

var walk : bool = false
var anim : AnimationTree = $AnimationTree

func _physics_process(_delta : float) -> void:
	if direction:
		anim.set("parameters/walk/blend_amount", direction.normalized())#the path to your blend2D will autocomplete
		anim.set("parameters/idle/etc", direction.normalized())#use autocomplete
		walk = true
	else:
		walk = false

and that’s it!

you can later add more animations and directions and more states very easily.

5

Well almost made it work. The walking state works fine but when the character stops it always goes to idle_up which is a bummer maybe I did a mistake somewhere

extends Node2D

@onready var tile_map: TileMapLayer = $"../TileMap"
@onready var sprite_2d: Sprite2D = $CharacterBody2D/Sprite2D
@onready var animation_player: AnimationPlayer = $CharacterBody2D/AnimationPlayer
@onready var animation_tree: AnimationTree = $CharacterBody2D/AnimationTree

var astar_grid: AStarGrid2D
var current_id_path: Array[Vector2i]
var current_point_path: PackedVector2Array
var target_position: Vector2
var is_moving: bool

var direction : Vector2	= Vector2.ZERO

func _ready():	
	animation_tree.active = true
	astar_grid = AStarGrid2D.new()
	astar_grid.region = tile_map.get_used_rect()
	astar_grid.cell_size = Vector2(32, 32)
	astar_grid.diagonal_mode = AStarGrid2D.DIAGONAL_MODE_NEVER
	astar_grid.update()

	for x in tile_map.get_used_rect().size.x:
		for y in tile_map.get_used_rect().size.y:
			var tile_position = Vector2i(
				x+tile_map.get_used_rect().position.x,
				y+tile_map.get_used_rect().position.y
			)
			var tile_data = tile_map.get_cell_tile_data(tile_position)
			if tile_position == null or tile_data.get_custom_data("Walkable") == false:
				astar_grid.set_point_solid(tile_position)
			
func _process(delta):
	update_animation_parameters()
			
func _input(event):	
	if event.is_action_pressed("move") == false:
		return
		
	var id_path
	
	if is_moving:
		id_path = astar_grid.get_id_path(
			tile_map.local_to_map(target_position),
			tile_map.local_to_map(get_global_mouse_position())
		)
	else:
		id_path = astar_grid.get_id_path(
			tile_map.local_to_map(global_position),
			 tile_map.local_to_map(get_global_mouse_position())
		)
	if id_path.is_empty() == false:
		current_id_path = id_path
		
		current_point_path = astar_grid.get_point_path(
			tile_map.local_to_map(target_position),
			tile_map.local_to_map(get_global_mouse_position())
		)
		for i in current_id_path.size():
			current_point_path[i] = current_point_path[i] + Vector2(16, 16)

func _physics_process(_delta: float) -> void:
		if current_id_path.is_empty():
			return
		if is_moving == false:
			target_position = tile_map.map_to_local(current_id_path.front())
			is_moving = true
		global_position = global_position.move_toward(target_position, 1)
		if global_position == target_position:
				current_id_path.pop_front() 
				if current_id_path.is_empty() == false:
					target_position = tile_map.map_to_local(current_id_path.front())
				else:
					is_moving = false
		var walking_direction = target_position - global_position
		if (abs(walking_direction.x) > abs(walking_direction.y)):
			if walking_direction.x > 0:
				direction = Vector2(1,0)
			else:
				direction = Vector2(-1,0)
		else: 
			if walking_direction.y > 0:
				direction = Vector2(0,-1)
			else:
				direction = Vector2(0,1)

func _on_pressed():
	pass
	
func update_animation_parameters():
	if target_position == global_position:
		animation_tree["parameters/conditions/idle"] = true
		animation_tree["parameters/conditions/is_moving"] = false
	else:
		animation_tree["parameters/conditions/idle"] = false
		animation_tree["parameters/conditions/is_moving"] = true
	
	animation_tree["parameters/idle/blend_position"] = direction
	animation_tree["parameters/walk/blend_position"] = direction

When looking into the remote in the animation tree it nicely shows when the walk and idle states activate and deactivate but somehow the idle and walk blend postion always defaults to 0, 1 when reaching target position which is why the character is always facing up.

6

there is no condition in case direction is ZERO (0, 0)

this should never pass ZERO.

and you used conditions in AnimationTree, it would’ve been much easier with Expressions, but if it works it works I guess.

my solution was very elegant because direction was only updated when directions was not ZERO. you could do that little change to your code:

func update_animation_parameters():
	if target_position == global_position:
		animation_tree["parameters/conditions/idle"] = true
		animation_tree["parameters/conditions/is_moving"] = false
	else:
		animation_tree["parameters/conditions/idle"] = false
		animation_tree["parameters/conditions/is_moving"] = true
		animation_tree["parameters/idle/blend_position"] = direction
		animation_tree["parameters/walk/blend_position"] = direction