Build character and UI animations in Godot 4.7. Choose tools for recorded animation clips, blend movements such as walking and running, animate sprite sheets, and create short fades or scaling effects in code.
Animate in Godot 4.7 three ways: AnimationPlayer for keyframed clips (incl. call and signal tracks), AnimationTree with state machines and blend spaces for character animation, and Tween for short procedural/UI tweens via create_tween(). Use when working with AnimationPlayer/AnimationTree nodes in a .tscn, blending character states, sprite-sheet animation, or code-driven Tweens.
Run score Not tested
See how to installReview the instructions the agent will receive before you install.
Choose and drive the right animation tool: AnimationPlayer (clips), AnimationTree
(blending/state machines), or Tween (short procedural moves). Targets Godot 4.7.
When not to use: the movement logic that decides which state to play →
godot-2d-movement; UI layout (vs. UI tweening) → godot-ui-control; shader-driven
effects → godot-shaders.
AnimationPlayer — author keyframed clips (transforms, properties, method calls,
audio, even other animations). The source of truth for clip data.AnimationTree — blend and transition between those clips at runtime with a state
machine and/or blend spaces. Needs an AnimationPlayer to pull clips from.Tween — fire-and-forget procedural interpolation in code (create_tween()); ideal
for UI pops, fades, and one-off moves.AnimatedSprite2D + SpriteFrames, or keyframe the
frame property in an AnimationPlayer.AnimationPlayer, then add an AnimationTree
(active = true), set its anim_player, and design an AnimationNodeStateMachine or
AnimationNodeBlendSpace2D as the tree root.travel) or by setting blend
parameters.animation_finished signal and call/method tracks.@onready var anim: AnimationPlayer = $AnimationPlayer
func attack() -> void:
anim.play("attack")
await anim.animation_finished # resume after the clip ends
anim.play("idle")
@onready var tree: AnimationTree = $AnimationTree
func _ready() -> void:
tree.active = true # the tree drives animation; AnimationPlayer is the source
func set_state(state: StringName) -> void:
# The playback object controls an AnimationNodeStateMachine root.
var sm: AnimationNodeStateMachinePlayback = tree.get("parameters/playback")
sm.travel(state) # transitions using the graph's connections
func _physics_process(_d: float) -> void:
set_state(&"run" if velocity.length() > 5.0 else &"idle")
# Root is an AnimationNodeBlendSpace2D named "Move" with idle/run points placed in it.
func update_locomotion(input_dir: Vector2) -> void:
# Parameter path = "parameters/<node name>/blend_position".
tree.set("parameters/Move/blend_position", input_dir)
func pop_in(node: Control) -> void:
node.scale = Vector2.ZERO
node.modulate.a = 0.0
var tw := create_tween() # bound to this node's tree
tw.set_parallel(true) # run the two tweens together
tw.tween_property(node, "scale", Vector2.ONE, 0.2) \
.set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
tw.tween_property(node, "modulate:a", 1.0, 0.2) # sub-property via ":"
AnimationTree.active left false → nothing animates and travel() appears to do
nothing. Set active = true and assign the anim_player path."parameters/<NodeName>/..." and
must match the node names in the tree exactly (e.g. "parameters/playback",
"parameters/Move/blend_position"). A typo silently no-ops.AnimationTree is active, don't
also call AnimationPlayer.play() for the same tracks — let the tree own playback.Tween node to add in 4.x; create tweens in
code with create_tween() (which returns a Tween). They auto-start and free themselves.create_tween() again for a new
animation. Use set_loops() for repetition.yield/yield(anim, "...") is gone. Use await anim.animation_finished."modulate:a", "position:x". Tweening the whole
property instead overwrites siblings.SpriteFrames/AnimatedSprite2D, and Tween easing/chaining/callbacks,
read references/animation-tree-and-tween.md.godot-2d-movement — supplies the velocity/state that selects animations.godot-ui-control — UI that Tweens animate.godot-3d-essentials — 3D character scenes driven by AnimationTree.game-ai — state machines that mirror animation states.No reviews yet. Tell others what you thought.
No login needed. Share how it worked for you, ask a question, or note where it did not run.
No comments yet. Be the first to write one.
Implement reusable decision systems for game characters using behavior trees, which organize conditional actions, and Utility AI, which scores available choices. Build either approach or combine them to control patrols, combat, targeting, and needs-based behavior.
Design game audio with grouped volume controls, music that responds to gameplay, and varied sound effects. Plan how music lowers during dialogue and how events follow the beat, using principles that can be adapted to different game engines.
Build and debug Rust games in Bevy using ECS, a way to separate game data from behavior. Organize apps and plugins, query entities, control execution order, and fix conflicting data access or frame-dependent movement.
Build and tune game cameras for smooth 2D following and 3D viewing. Covers motion smoothing, look-ahead, level boundaries, wall avoidance, and framing multiple targets, with techniques that apply across engines.
Design the core rules of a card game, including decks, hands, discards, drawing, shuffling, turns, and resource costs. Represent card effects as data and define their resolution order so card movement and gameplay outcomes follow explicit rules.
Plan and prepare consistent game artwork, from sprites and backgrounds to UI icons and 3D briefs. Organize asset requirements, generate or source related visuals, standardize files, and check their appearance and technical fit inside the game.