AnimationNodeBlend2 in Godot – Complete Guide

Welcome to today’s tutorial, where we dive into the world of Godot 4 and explore the capabilities of the AnimationNodeBlend2 class. Animations can breathe life into your game, making it more immersive and enjoyable for players. Understanding how to blend animations is an essential skill for any game developer looking to create smooth and responsive character movements. Whether you’re just starting your coding journey or you’re an experienced coder looking to expand your skillset, this tutorial is for you. Together, we’ll unlock the potential of game animations in Godot 4, making your game characters move and act in a more lifelike manner.

What is AnimationNodeBlend2?

The AnimationNodeBlend2 is a class in the animation system of Godot 4 used within an AnimationNodeBlendTree. So what exactly does it do? Simply put, it enables you to blend two distinct animations together based on a blend amount, often resulting in a seamless transition between actions or states.

What is it for?

Animating characters or objects can be a challenging task, especially when aiming for natural transitions. Picture your game character running and then slowly coming to a walk. Using AnimationNodeBlend2, you can control how these two animations—running and walking—intermingle to create a natural movement from one state to another without abrupt changes or unrealistic motion.

Why Should I Learn It?

Mastering the use of AnimationNodeBlend2 allows you to:
– Create more dynamic and versatile animations leading to professional-quality game design.
– Control character movements with precision, leading to a more polished game experience.
– Enhance your skills in the Godot Engine, which is a powerful, open-source tool for game development.

Having a thorough understanding of this feature will not only expand your game development toolkit but will also give you the power to bring your characters to life in a smooth, aesthetically pleasing way.

CTA Small Image
FREE COURSES AT ZENVA
LEARN GAME DEVELOPMENT, PYTHON AND MORE
ACCESS FOR FREE
AVAILABLE FOR A LIMITED TIME ONLY

Creating a Basic AnimationNodeBlend2 Node

To begin with, let’s look at how to create a basic `AnimationNodeBlend2` instance within your Godot project. This will serve as the foundation for blending two animations.

var blend2_node = AnimationNodeBlend2.new()

Next, you must add this node to your `AnimationTree` as part of the blend tree. Here’s a snippet of code that accomplishes this:

var animation_tree = $AnimationTree
var blend_tree_root = animation_tree.get("parameters/blend_tree")

blend_tree_root.add_node("Blend2", blend2_node)

With the node added, you can now assign the animations that you want to blend between. Assuming you have two animations named “Walk” and “Run”, here’s how you could assign them to the blend positions:

blend2_node.add_input("Walk")
blend2_node.add_input("Run")

Setting and Animating the Blend Amount

Once your `AnimationNodeBlend2` is created and configured with your animations, you can start controlling the blend amount precisely. The blend amount is a value between 0 and 1, where 0 fully plays the first animation and 1 fully plays the second animation. To modify it in code, you’d use:

animation_tree.set("parameters/blend_tree/Blend2/blend_amount", 0.5)

This sets the blend amount to 0.5, meaning both animations will contribute equally to the final blend. To animate this property, creating a transition between the two animations, you’ll need an animation that modifies the blend amount over time. Here’s an example:

var blend_animation = Animation.new()
blend_animation.add_track(Animation.TYPE_VALUE)
blend_animation.track_set_path(0, "parameters/blend_tree/Blend2/blend_amount")
blend_animation.track_insert_key(0, 0.0, 0)
blend_animation.track_insert_key(0, 1.0, 1)
animation_tree.get("parameters/blend_tree").set("Blend2/blend_amount", 0)
animation_tree.animation_player.play("blend_animation")

Here we’ve created a new animation that changes the blend amount from 0 to 1 over one second. We set the initial blend amount to 0 and then play the newly created animation.

Connecting Animation Signals for Smooth Transitions

To make the blend transition even more seamless, you can connect the `AnimationPlayer`’s signals to control the blend amount dynamically based on the animations’ behaviors.

func _on_animation_started(anim_name):
    if anim_name == "Walk":
        animation_tree.set("parameters/blend_tree/Blend2/blend_amount", 0.0)
    elif anim_name == "Run":
        animation_tree.set("parameters/blend_tree/Blend2/blend_amount", 1.0)

$AnimationPlayer.connect("animation_started", self, "_on_animation_started")

In this example, when either the “Walk” or “Run” animation starts, the `AnimationNodeBlend2` blend amount is set to the appropriate value, triggering a blend to the starting animation.

Adjusting Filters for Specific Conditions

Lastly, you may want to control when certain animations can blend with others. Godot’s animation system allows you to filter animations through code.

blend2_node.set_input_filter(0, false)  # Disable blending for the first animation
blend2_node.set_input_filter(1, true)   # Enable blending for the second animation

By utilizing `set_input_filter`, you can enable or disable blending for each animation input—the first argument representing the input index and the second a boolean for enabling or disabling.

Through these examples, you’re beginning to see the power and flexibility offered by the `AnimationNodeBlend2` in Godot 4. In the next section, we’ll delve even deeper, exploring how to refine and control these animations for various game scenarios.Controlling Animation Blends with User Input

In many games, animation blends need to respond to user input. For instance, a character might walk, run, or stop based on key presses. Let’s enhance our `AnimationNodeBlend2` to respond to such input.

func _process(delta):
    var blend_amount = animation_tree.get("parameters/blend_tree/Blend2/blend_amount")
    
    if Input.is_action_pressed("ui_right"): # Assumes right arrow for running
        blend_amount += delta # Increment blend amount over time for a smooth transition
    elif Input.is_action_pressed("ui_left"): # Assumes left arrow for walking
        blend_amount -= delta # Decrement blend amount over time for a smooth transition
    else:
        blend_amount = 0.5 # Neutral state (idle)
    
    blend_amount = clamp(blend_amount, 0.0, 1.0) # Ensure blend_amount stays within bounds
    animation_tree.set("parameters/blend_tree/Blend2/blend_amount", blend_amount)

In this example, pressing the right arrow key gradually increases the blend amount, transitioning into running, while the left arrow key decreases it, shifting back to walking. Releasing both keys brings the character to an idle state in the middle of the blend.

We use Godot’s `clamp` function to ensure `blend_amount` remains between 0 and 1.

Syncing Animation Speeds with Blend Amounts

Sometimes you may want the speed of your animations to correlate with the blend amount to achieve a more natural look.

func _process(delta):
    var blend_amount = animation_tree.get("parameters/blend_tree/Blend2/blend_amount")
    # Control animation speeds based on blend amount
    $AnimationPlayer.get_animation("Walk").playback_speed = 1.0 - blend_amount
    $AnimationPlayer.get_animation("Run").playback_speed = blend_amount
    
    # The rest of your input handling code goes here

Here we adjust the playback speed of each animation proportionally to the blend amount. As the character transitions to running, the walk animation slows down, and the run animation speeds up, and vice versa.

Interrupting Animations with Conditions

Animations often need to be interrupted when an action takes precedence, such as jumping or attacking.

func _process(delta):
    # Prior condition to interrupt the blend for a jump
    if Input.is_action_just_pressed("ui_up"):
        $AnimationPlayer.play("Jump")
        return # Skip the rest of the process function
    
    # Remaining animation blend logic

By playing the “Jump” animation and returning early from the `_process` function, we interrupt any current blending, prioritizing the jump animation.

Fine-Tuning Transitions

For even finer control over your animation blends, you might want to use easing functions or tween the `blend_amount` for different effects.

func _start_blend_to_run():
    # Use a Tween node to interpolate the blend amount
    var tween = $Tween
    tween.interpolate_property(
        animation_tree, "parameters/blend_tree/Blend2/blend_amount", 
        animation_tree.get("parameters/blend_tree/Blend2/blend_amount"), 
        1.0, 0.5, Tween.TRANS_LINEAR, Tween.EASE_IN_OUT
    )
    tween.start()

This code uses a `Tween` node to transition the `blend_amount` from its current value to 1.0, representing full running, over half a second. `Tween.TRANS_LINEAR` and `Tween.EASE_IN_OUT` determine the nature of the transition.

Experimenting with Different Blends

Finally, the best way to master the `AnimationNodeBlend2` is through experimentation. Try different blend amounts and observe the results, and use these insights to fine-tune your animations.

# Experimenting with arbitrary blend amounts
func _fixed_process(delta):
    var random_blend = rand_range(0.0, 1.0) # generates a random number between 0 and 1
    animation_tree.set("parameters/blend_tree/Blend2/blend_amount", random_blend)

By setting the `blend_amount` to random values, you can see how your animations interact and identify the best combinations for your game’s specific requirements.

By integrating these techniques, you are taking a significant step towards creating more realistic and responsive animations in your Godot 4 projects. Remember, the key is to practice, experiment, and find the perfect blend for your game. Happy developing!

Understanding the Power of Blend Trees

To truly harness the potential of `AnimationNodeBlend2`, one must understand how it fits into the bigger picture of blend trees in Godot 4. A blend tree allows you to manage complex animations and state transitions systematically.

Combine several `AnimationNodeBlend2` nodes to create sophisticated blend behaviors between multiple animations. Here’s an example creating a basic two-tier blend scenario:

// First tier blends walking and running
var walk_run_blend = AnimationNodeBlend2.new()
// Assume "Walk" and "Run" are already created as AnimationNodeAnimation
walk_run_blend.add_input("Walk")
walk_run_blend.add_input("Run")

// Second tier blends the result with an idle animation
var blend_with_idle = AnimationNodeBlend2.new()
blend_with_idle.add_input("Idle")
blend_with_idle.add_input(walk_run_blend)

// Adding to the blend tree root
blend_tree_root.add_node("WalkRunBlend", walk_run_blend)
blend_tree_root.add_node("FinalBlend", blend_with_idle)

This creates a two-tier blend tree: one `AnimationNodeBlend2` blending walk and run, and another blending the result with idle. This setup allows for smooth transitions across three different states.

Controlling Blends Based on Gameplay Variables

Beyond user input, in-game variables or states should often influence how animations blend. For example, a health variable might determine the character’s movement.

func _process(delta):
    var health_percentage = player.health / player.max_health
    if health_percentage < 0.5:
        blend_tree_root.set("parameters/FinalBlend/blend_amount", health_percentage * 2.0)
    else:
        blend_tree_root.set("parameters/FinalBlend/blend_amount", 1.0)

Here, if the player’s health is below 50%, the blend amount correlates with health, producing a more cautious or injured movement style; above 50%, the character moves normally.

Leveraging State Machines

`AnimationNodeBlendTree` thrives when used with `AnimationNodeStateMachine`. You can create states corresponding to your animations and use `AnimationNodeBlend2` to blend between them.

Let’s look at how you might switch states in an `AnimationNodeStateMachine`. Assume we have a state machine with a “Walk” state and a “Run” state:

func _unhandled_input(event):
    if event.is_action_pressed("ui_run"):
        $AnimationTree.set("parameters/state_machine/active", "Run")
    elif event.is_action_pressed("ui_walk"):
        $AnimationTree.set("parameters/state_machine/active", "Walk")

This script listens for ‘ui_walk’ and ‘ui_run’ inputs and switches states accordingly. The state machine handles transitions internally, potentially using `AnimationNodeBlend2` nodes.

Animating Blend Amounts with Code

Sometimes, you may want a blend to occur over a specified time or based on a particular curve. In such cases, you can animate the `blend_amount` in code.

The example below smoothly transitions from walking to running over a 3-second period:

// Assuming a blend2_node is already properly set up and added

func _ready():
    var duration = 3.0
    var start_value = 0.0
    var end_value = 1.0
    var elapsed = 0.0
    
    while elapsed < duration:
        var t = elapsed / duration
        var blend_value = lerp(start_value, end_value, t)
        blend2_node.set("blend_amount", blend_value)
        yield(get_tree().create_timer(0.01), "timeout")
        elapsed += 0.01

This script uses linear interpolation (`lerp`) to move `blend_amount` from 0 to 1 over 3 seconds, updating every 0.01 seconds, resulting in a smooth transition.

Adding Directional Blending

Games with more complex movement often blend animations in more than one direction. For example, you might blend between idle, walking, running, and strafing animations. In such cases, `AnimationNodeBlend3` or even `AnimationNodeBlendSpace2D` could be used, providing multiple directions of blending.

A skeletal example of creating a blend space for four-way directional movement:

var blend_space = AnimationNodeBlendSpace2D.new()

// Configure blend_space and add animations for up, down, left, and right

// Connect actions to blend space inputs
func _process(delta):
    var x = int(Input.is_action_pressed("ui_right")) - int(Input.is_action_pressed("ui_left"))
    var y = int(Input.is_action_pressed("ui_down")) - int(Input.is_action_pressed("ui_up"))
    
    blend_space.set_blend_position(Vector2(x, y))

This sets up a blend space and alters the blend position based on user input, allowing for blending between different directions of movement seamlessly.

Animating Properties with AnimationNodeBlend2

Lastly, remember that `AnimationNodeBlend2` isn’t limited to animating skeletons or sprites; it can also blend between animations of properties, like colors or transforms.

// Create two animations for color property
var animation_red = Animation.new()
animation_red.add_track(Animation.TYPE_VALUE)
animation_red.track_set_path(0, "SelfModulate")
animation_red.track_insert_key(0, 0.0, Color.red)

var animation_blue = Animation.new()
animation_blue.add_track(Animation.TYPE_VALUE)
animation_blue.track_set_path(0, "SelfModulate")
animation_blue.track_insert_key(0, 0.0, Color.blue)

// Assign to blend2_node inputs and blend on user input

From transitions between colors, transforms, or any animatable property, the ability to blend these animations can lead to some highly dynamic and creative effects.

By capitalizing on these advanced blending techniques, you solidify your foundational knowledge of Godot’s animation system, positioning yourself at the forefront of game animation and design. Keep experimenting, and every step will lead you to a more engaging and interactive gaming experience for your players.

Continue Your Game Development Journey

The world of game development is vast and ever-evolving, and your learning journey doesn’t stop here. Diving into Godot 4 and mastering animation blending is just the beginning. To further advance your skills and knowledge, we invite you to explore our comprehensive Godot Game Development Mini-Degree. This program is designed to take you from beginner to professional, covering everything from the basics of using assets and GDScript programming to developing full-fledged RPG, RTS, and platformer games using Godot 4.

Whether you’re new to game development or looking to refine your existing skills, our mini-degree is tailored to accommodate all levels. With flexible access to a variety of project-based learning materials, you’ll be able to create games at your own pace and earn certificates along the way. Moreover, with the strong community backing of Godot’s free and open-source engine, you’ll be joining a passionate group of developers making waves in the industry.

If you’re eager to expand your horizons even further, check out our broad collection of Godot courses, where you’ll find even more tools and techniques to explore. Embrace the endless possibilities of game creation with Zenva, and let us help you turn your game development dreams into reality.

Conclusion

Your curiosity and dedication have brought you to the end of this tutorial, but this is just the start of what you can accomplish with Godot 4 and its powerful animation blending capabilities. Remember that the most captivating games are those that provide seamless and dynamic experiences—something that mastering animation blends can surely deliver. Keep pursuing knowledge, refining your technique, and embracing the creative process. Turn your game concepts into mesmerizing realities that players worldwide can enjoy.

Are you ready to take your game development journey to the next level? Join us at Zenva Academy where we offer top-tier education in all things code and game development. With our Godot Game Development Mini-Degree, step-by-step tutorials, and supportive community, your path from enthusiastic learner to game industry innovator is clearer than ever. Start blending, start building, start creating—your adventure in game development is just getting started!

FREE COURSES
Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.