Système d'Animation Godot
Lors de l'implémentation d'animations, utilisez ces modèles pour des mouvements de personnages fluides et réactifs.
Bases d'AnimationPlayer
Lire des Animations
extends CharacterBody2D
@onready var anim_player: AnimationPlayer = $AnimationPlayer
func _ready() -> void:
# Connecter au signal de fin d'animation
anim_player.animation_finished.connect(_on_animation_finished)
func play_animation(anim_name: String, speed: float = 1.0) -> void:
if anim_player.current_animation != anim_name:
anim_player.play(anim_name)
anim_player.speed_scale = speed
func play_backwards(anim_name: String) -> void:
anim_player.play_backwards(anim_name)
func stop_animation() -> void:
anim_player.stop()
func pause_animation() -> void:
anim_player.pause()
func resume_animation() -> void:
anim_player.play()
func _on_animation_finished(anim_name: String) -> void:
match anim_name:
"attack":
play_animation("idle")
"death":
queue_free()
Mélange d'Animations
extends AnimationPlayer
func crossfade_to(anim_name: String, duration: float = 0.2) -> void:
if current_animation == anim_name:
return
# Mettre en file la nouvelle animation avec crossfade
queue(anim_name)
advance(0) # Démarrer immédiatement
# Utiliser le mélange intégré d'AnimationPlayer
set_blend_time(current_animation, anim_name, duration)
# Un crossfade manuel via AnimationTree est préféré pour les mélanges complexes
Callbacks d'Animation
extends CharacterBody2D
@onready var anim_player: AnimationPlayer = $AnimationPlayer
func _ready() -> void:
# Ajouter des appels de méthode dans les pistes d'animation
# Ou utiliser le signal animation_finished
pass
# Appelé depuis une piste d'animation
func spawn_projectile() -> void:
var projectile := preload("res://projectile.tscn").instantiate()
projectile.global_position = $ProjectileSpawn.global_position
get_parent().add_child(projectile)
func play_sound(sound_name: String) -> void:
var sound := $Sounds.get_node(sound_name) as AudioStreamPlayer2D
if sound:
sound.play()
func enable_hitbox() -> void:
$Hitbox/CollisionShape2D.disabled = false
func disable_hitbox() -> void:
$Hitbox/CollisionShape2D.disabled = true
AnimationTree
Configuration de Machine d'État
extends CharacterBody2D
@onready var anim_tree: AnimationTree = $AnimationTree
@onready var state_machine: AnimationNodeStateMachinePlayback = \
anim_tree.get("parameters/playback")
func _ready() -> void:
anim_tree.active = true
func travel_to_state(state_name: String) -> void:
state_machine.travel(state_name)
func force_state(state_name: String) -> void:
state_machine.start(state_name)
func get_current_state() -> String:
return state_machine.get_current_node()
func is_playing(state_name: String) -> bool:
return state_machine.get_current_node() == state_name
func _physics_process(_delta: float) -> void:
update_animation_state()
func update_animation_state() -> void:
if not is_on_floor():
if velocity.y < 0:
travel_to_state("Jump")
else:
travel_to_state("Fall")
elif velocity.length() > 10:
travel_to_state("Run")
else:
travel_to_state("Idle")
Configuration d'Arbre de Mélange
extends CharacterBody2D
@onready var anim_tree: AnimationTree = $AnimationTree
func _physics_process(_delta: float) -> void:
update_blend_parameters()
func update_blend_parameters() -> void:
# Pour BlendSpace2D (mouvement 8 directions)
var input := Input.get_vector("left", "right", "up", "down")
anim_tree.set("parameters/Move/blend_position", input)
# Pour BlendSpace1D (basé sur la vitesse)
var speed_ratio := velocity.length() / max_speed
anim_tree.set("parameters/Speed/blend_position", speed_ratio)
# Pour les transitions d'animations
anim_tree.set("parameters/conditions/is_jumping", not is_on_floor() and velocity.y < 0)
anim_tree.set("parameters/conditions/is_falling", not is_on_floor() and velocity.y > 0)
anim_tree.set("parameters/conditions/is_grounded", is_on_floor())
Animations One-Shot
extends CharacterBody2D
@onready var anim_tree: AnimationTree = $AnimationTree
func play_attack() -> void:
# Déclencher une animation one-shot
anim_tree.set("parameters/Attack/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_FIRE)
func abort_attack() -> void:
anim_tree.set("parameters/Attack/request", AnimationNodeOneShot.ONE_SHOT_REQUEST_ABORT)
func is_attacking() -> bool:
return anim_tree.get("parameters/Attack/active")
func _on_attack_finished() -> void:
# Appelé lorsque l'animation one-shot se termine
pass
Animations en Couches
# Structure d'AnimationTree :
# - AnimationNodeBlendTree
# - Add2 (mélange bas du corps et haut du corps)
# - Entrée 0 : Machine d'État (bas du corps : idle, walk, run)
# - Entrée 1 : Machine d'État (haut du corps : idle, aim, shoot)
# - Filtre : Os du haut du corps uniquement
extends CharacterBody2D
@onready var anim_tree: AnimationTree = $AnimationTree
func _ready() -> void:
# Configurer le filtre d'os pour la couche du haut du corps
# Cela se fait généralement dans l'éditeur, mais peut être fait en code
pass
func update_animations() -> void:
# Le bas du corps suit le mouvement
var move_state := "idle" if velocity.length() < 10 else "run"
anim_tree.set("parameters/LowerBody/playback").travel(move_state)
# Le haut du corps est indépendant
if is_aiming:
anim_tree.set("parameters/UpperBody/playback").travel("aim")
elif is_shooting:
anim_tree.set("parameters/UpperBody/playback").travel("shoot")
else:
anim_tree.set("parameters/UpperBody/playback").travel("idle")
# Quantité de mélange
anim_tree.set("parameters/Add2/add_amount", 1.0 if is_aiming else 0.0)
Animation Procédurale
Suivi de Regard / Tête
extends Node3D
@export var head_bone: String = "Head"
@export var max_angle := 70.0
@export var look_speed := 5.0
var skeleton: Skeleton3D
var head_bone_idx: int
var target: Node3D
func _ready() -> void:
skeleton = $Skeleton3D
head_bone_idx = skeleton.find_bone(head_bone)
func _process(delta: float) -> void:
if not target or head_bone_idx < 0:
return
var head_transform := skeleton.get_bone_global_pose(head_bone_idx)
var head_position := skeleton.to_global(head_transform.origin)
var target_direction := (target.global_position - head_position).normalized()
var local_direction := skeleton.global_transform.basis.inverse() * target_direction
# Calculer la rotation pour regarder la cible
var target_rotation := Quaternion(Vector3.FORWARD, local_direction)
# Limiter la rotation
var angle := target_rotation.get_euler()
angle.x = clamp(angle.x, deg_to_rad(-max_angle), deg_to_rad(max_angle))
angle.y = clamp(angle.y, deg_to_rad(-max_angle), deg_to_rad(max_angle))
var clamped_rotation := Quaternion.from_euler(angle)
# Appliquer une rotation lissée
var current := skeleton.get_bone_pose_rotation(head_bone_idx)
var new_rotation := current.slerp(clamped_rotation, look_speed * delta)
skeleton.set_bone_pose_rotation(head_bone_idx, new_rotation)
Cycle de Marche Procédural
extends CharacterBody2D
@export var leg_length := 20.0
@export var step_height := 10.0
@export var step_duration := 0.3
@onready var left_foot: Node2D = $LeftFoot
@onready var right_foot: Node2D = $RightFoot
var left_foot_target: Vector2
var right_foot_target: Vector2
var step_progress := 0.0
var is_left_stepping := true
func _physics_process(delta: float) -> void:
if velocity.length() > 10:
update_procedural_walk(delta)
else:
reset_feet()
func update_procedural_walk(delta: float) -> void:
step_progress += delta / step_duration
if step_progress >= 1.0:
step_progress = 0.0
is_left_stepping = not is_left_stepping
calculate_next_step()
# Interpoler les positions des pieds
var stepping_foot := left_foot if is_left_stepping else right_foot
var grounded_foot := right_foot if is_left_stepping else left_foot
var target := left_foot_target if is_left_stepping else right_foot_target
# Mouvement en arc pour le pied qui marche
var t := step_progress
var horizontal := stepping_foot.position.lerp(target, t)
var vertical_offset := sin(t * PI) * step_height
stepping_foot.position = horizontal + Vector2(0, -vertical_offset)
func calculate_next_step() -> void:
var forward := velocity.normalized()
var step_distance := velocity.length() * step_duration
if is_left_stepping:
left_foot_target = left_foot.position + forward * step_distance
else:
right_foot_target = right_foot.position + forward * step_distance
Squash and Stretch
extends Sprite2D
@export var squash_amount := 0.3
@export var stretch_amount := 0.2
@export var return_speed := 10.0
var target_scale := Vector2.ONE
func squash() -> void:
target_scale = Vector2(1 + squash_amount, 1 - squash_amount)
func stretch() -> void:
target_scale = Vector2(1 - stretch_amount, 1 + stretch_amount)
func _process(delta: float) -> void:
scale = scale.lerp(target_scale, return_speed * delta)
target_scale = target_scale.lerp(Vector2.ONE, return_speed * delta)
# Utilisation avec la physique
extends CharacterBody2D
func _physics_process(delta: float) -> void:
var was_on_floor := is_on_floor()
move_and_slide()
# Squash à l'atterrissage
if is_on_floor() and not was_on_floor:
$Sprite2D.squash()
# Stretch au saut
if Input.is_action_just_pressed("jump") and is_on_floor():
$Sprite2D.stretch()
Tremblement d'Écran
extends Camera2D
var shake_amount := 0.0
var shake_decay := 5.0
func shake(amount: float, duration: float = 0.2) -> void:
shake_amount = amount
var tween := create_tween()
tween.tween_property(self, "shake_amount", 0.0, duration)
func _process(delta: float) -> void:
if shake_amount > 0:
offset = Vector2(
randf_range(-shake_amount, shake_amount),
randf_range(-shake_amount, shake_amount)
)
else:
offset = Vector2.ZERO
Animation Sprite
Contrôleur AnimatedSprite2D
extends CharacterBody2D
@onready var sprite: AnimatedSprite2D = $AnimatedSprite2D
func _physics_process(_delta: float) -> void:
update_animation()
update_facing()
func update_animation() -> void:
if not is_on_floor():
if velocity.y < 0:
sprite.play("jump")
else:
sprite.play("fall")
elif abs(velocity.x) > 10:
sprite.play("run")
else:
sprite.play("idle")
func update_facing() -> void:
if velocity.x > 0:
sprite.flip_h = false
elif velocity.x < 0:
sprite.flip_h = true
func play_attack() -> void:
sprite.play("attack")
await sprite.animation_finished
# Revenir à l'animation idle ou de mouvement
Événements par Frame
extends AnimatedSprite2D
signal attack_frame
signal step_frame
func _ready() -> void:
frame_changed.connect(_on_frame_changed)
func _on_frame_changed() -> void:
var current_anim := animation
match current_anim:
"attack":
if frame == 3: # L'attaque touche à la frame 3
attack_frame.emit()
"run":
if frame == 2 or frame == 6: # Frames des pas
step_frame.emit()
Astuces d'Animation
Vitesse d'Animation Basée sur le Mouvement
extends CharacterBody2D
@onready var anim_player: AnimationPlayer = $AnimationPlayer
@export var walk_speed := 100.0
@export var run_speed := 200.0
func _physics_process(_delta: float) -> void:
var speed := velocity.length()
if speed > 10:
# Adapter la vitesse d'animation à la vitesse de déplacement
var anim_speed := speed / walk_speed
anim_player.speed_scale = clamp(anim_speed, 0.5, 2.0)
anim_player.play("walk")
else:
anim_player.speed_scale = 1.0
anim_player.play("idle")
Root Motion
extends CharacterBody2D
@onready var anim_tree: AnimationTree = $AnimationTree
var root_motion_position := Vector2.ZERO
func _physics_process(delta: float) -> void:
# Obtenir le root motion depuis l'animation
var root_motion := anim_tree.get_root_motion_position()
# Appliquer le root motion comme vélocité
if root_motion.length() > 0:
velocity = Vector2(root_motion.x, root_motion.z) / delta
else:
# Mouvement normal sans root motion
apply_movement_input()
move_and_slide()
Retargeting d'Animation
# Lors du partage d'animations entre différents squelettes
extends Skeleton3D
@export var source_skeleton: Skeleton3D
@export var bone_mapping: Dictionary # {source_bone: target_bone}
func _process(_delta: float) -> void:
if not source_skeleton:
return
for source_bone in bone_mapping:
var target_bone: String = bone_mapping[source_bone]
var source_idx := source_skeleton.find_bone(source_bone)
var target_idx := find_bone(target_bone)
if source_idx >= 0 and target_idx >= 0:
var pose := source_skeleton.get_bone_pose(source_idx)
set_bone_pose_rotation(target_idx, pose.basis.get_rotation_quaternion())