AStar3D in Godot – Complete Guide

Navigating through the wondrous world of game development, we often encounter the need for characters to traverse complex terrains, find treasures or simply reach targeted destinations. Pathfinding stands out as one of the most critical components in creating an intelligent and responsive game environment, and understanding its power is crucial for any budding game developer. Enter AStar3D, a powerful class within the Godot 4 game engine designed to solve these navigational puzzles in 3D space, proving that getting from point A to B is anything but a straight line.

What is AStar3D?


is a class provided by the Godot 4 engine, implementing the A* search algorithm for 3D spaces. A* is well-known for its efficiency and accuracy when it comes to finding the shortest path between two points on a graph. In game development, it enables characters and agents to find their way through dynamic and intricate environments with varying obstacles and terrains.

What is it for?

The AStar3D class offers developers a way to apply pathfinding algorithms easily within a 3D environment. This opens the door to a plethora of uses, such as:

– Creating NPCs that can navigate through complex worlds.
– Plotting course for player movements based on terrain difficulty or enemy positions.
– Formulating strategic elements in games, such as flanking maneuvers or evasive paths.

Why Should I Learn It?

Delving into the mechanics of AStar3D not only arms you with the know-how to implement efficient pathfinding in your games but also offers a deeper understanding of graph theory and algorithm optimization, crucial skills in game development. Our tutorial will guide you through the intricacies of the AStar3D class in Godot 4, providing practical knowledge and the coding skills required to bring sophisticated behaviors to your game elements. So, sharpen your coding swords, and let’s chart the paths to new realms of game creation.

CTA Small Image

Setting Up AStar3D in Godot 4

The first step to utilizing AStar3D in Godot is setting up the environment. Here’s how you can initiate an AStar3D node within your Godot project.

var astar =

This code creates a new instance of AStar3D. Remember to add it as a member variable so you can access it throughout your script.

Next, we define the points (also known as nodes) in our 3D space, which will act as the waypoints for our pathfinding.

astar.add_point(1, Vector3(0, 0, 0))
astar.add_point(2, Vector3(0, 0, 10), 1.0) // The second argument is the location as a Vector3, and the optional third argument is the weight.

Here, you’ve created two points: one at the origin and another 10 units away on the Z-axis.

Connecting the Points

After adding points to the AStar3D, you need to connect them to form a graph.

astar.connect_points(1, 2)
astar.connect_points(2, 1) // Points should be connected bidirectionally unless you want one-way movement

In this example, points 1 and 2 are connected, allowing movement between them.

Creating the Path

With our points connected, we can now compute a path between them. The get_point_path() method will return the computed path as an array of Vector3D points.

var path = astar.get_point_path(1, 2)

This will store in ‘path’ the way to travel from point 1 to point 2.

Pathfinding in Action

Let’s bring the AStar3D to life by using it in our game. Imagine a character that needs to move from point A to B on the trigger of an event:

func _on_Trigger_Enter():
    var path = astar.get_point_path(1, 2)
    for point in path:
        print("Moving to point: ", point)
        # Imagine your character moving from point to point here.

This function would be triggered by an event and commence the character’s movement along the points detailed in the path array.

Handling Dynamic Obstacles

Games are dynamic, and often paths need to be recalculated on the fly to account for sudden changes, such as an obstacle appearing. With Godot’s AStar3D, you can update the graph and find a new path seamlessly.

func _on_Obstacle_Spawned(position, radius):
    astar.remove_points_in_circle(position, radius)
    # Recalculate your path as needed.

Call this function when an obstacle appears within the game world, and it will remove points within the specified radius around a position, then you can recalculate the path to ensure the character or agent can find a new route.

Enhancing Pathfinding with Heuristics

Heuristics are a crucial aspect of the A* algorithm, influencing how the pathfinding prioritizes different paths. In Godot 4, we can customize our AStar3D’s heuristic method to fine-tune our pathfinding behavior.

func my_heuristic(p_id_start, p_id_end):
    var start = astar.get_point_position(p_id_start)
    var end = astar.get_point_position(p_id_end)
    return start.distance_to(end) * 0.5 # The heuristic value is weighed down.


Here, we’ve defined a simple heuristic function and applied it using the set_heuristic_scale method, which alters the default heuristic scale in the AStar3D class to one that fits our game’s specific needs.

Adding Complexity to the Graph

In complex game worlds, points in space aren’t aligned in a simple grid. We can add complexity by creating points that are distributed across various elevations and locations, resembling a more realistic game environment.

astar.add_point(3, Vector3(0, 5, 15))
astar.add_point(4, Vector3(5, 3, 20))
astar.connect_points(2, 3)
astar.connect_points(3, 4)

By adding and connecting additional points, we now have a 3D space with points at varying heights, adding a vertical dimension to the pathfinding challenges.

Optimizing Path with Disabled Points

Sometimes, you might want to consider temporary obstacles without modifying the graph drastically. In Godot, we can disable and enable points.

astar.set_point_disabled(3, true) # Temporarily disables the point 3 

astar.set_point_disabled(3, false) # Re-enables the point 3 when the obstacle is gone

This functionality allows us to quickly respond to dynamic environments such as doors opening or closing and bridges being destroyed or rebuilt.

Following the Path with an Agent

In a game, NPCs or characters need to follow the path provided by the AStar3D node. Here’s a simple way to navigate the calculated path using Godot’s built-in methods.

var current_point_index = 0
var path_to_follow = astar.get_point_path(1, 4)

func _process(delta):
    if current_point_index < path_to_follow.size():
        var target = path_to_follow[current_point_index]
        var direction = target - $Character.translation
        if direction.length() < 1: 
            current_point_index += 1 # Move to the next point
            $Character.translation += direction.normalized() * move_speed * delta

This snippet controls an in-game character, smoothly following a path from the first to the fourth point. Once the character is close enough to the target point, it advances to the next.

Implementing AStar3D for efficient pathfinding in Godot 4 can significantly elevate your game’s AI and environmental interactions. With the ability to customize and dynamically adjust paths, your game worlds and characters become more responsive, realistic, and engaging. Our tutorials aim to get you started and empower you to explore the advanced capabilities that Godot 4 has to offer in this space. Happy coding!As we progress further into the intricacies of `AStar3D`, we explore more advanced features that Godot 4 offers to truly tailor the pathfinding experience to our game’s specific requirements. Detailed below are more code examples that demonstrate additional capabilities of the `AStar3D` class.

Let’s consider a scenario where the cost of traversal could vary depending on the type of terrain. To simulate a more complex movement cost scenario, you can assign higher weights to certain points to dissuade the pathfinder from taking that route unless necessary.

astar.add_point(5, Vector3(10, 2, 30), 2.0) # A higher weight makes this point 'harder' to traverse.
astar.connect_points(4, 5)

Here, reaching point 5 requires twice the effort, making it less desirable unless it’s the only route.

When your game requires an understanding of 3D space, as in cases where agents can jump from different elevations or use ladders, you can reflect that in your AStar3D setup:

func connect_vertical_points(p_id_start, p_id_end):
    astar.connect_points(p_id_start, p_id_end, true) # A bidirectional connection between different elevations.

connect_vertical_points(2, 5) # Connects a lower point to a higher point, simulating a jump or ladder.

Suppose you have a dynamic environment where certain paths can only be used during specific in-game events or times:

func enable_path_during_nighttime():
    if is_nighttime():
        astar.set_point_disabled(2, false)
        astar.set_point_disabled(2, true)

func is_nighttime():
    # Assuming game logic to determine time of day is present
    return game_time >= 20 || game_time < 6

Points can be enabled or disabled depending on circumstances defined within your game logic.

In some cases, you may want to identify your waypoints in more detail, associating additional data with each point in your pathfinding graph:

astar.set_point_metadata(5, {"terrain": "mud", "danger_level": "high"}) # Adding metadata to point 5

var metadata = astar.get_point_metadata(5)
if metadata.danger_level == "high":
    print("Avoid point 5 if possible, it's dangerous!")

Here we’re tagging a point with metadata, which can be used for more sophisticated logic in AI behavior.

In multiplayer or cooperative games, you might need to manage multiple pathfinding processes at once. With Godot 4’s `AStar3D`, you can seamlessly work with multiple instances tailored to each character or team:

var astar_for_team_red =
var astar_for_team_blue =

# Setup respective points and connections for each team which can have different traversable graphs

Each `AStar3D` instance operates independently, allowing for customizable pathfinding strategies per team or character.

Moreover, we can also improve the path post-calculation using Godot’s built-in methods. For example, smoothing out the path or creating more organic movement can be essential for realism:

var smooth_path = astar.get_point_path(1, 4).smooth()

This will give you a smoothed version of the original path by interpolating between the points.

All these pieces come together to form a perfectly tailored pathfinding logic specific to your game’s challenges and scenarios. By mastering the `AStar3D` class and its many features, you ensure your game characters can make intelligent decisions about their movement, leading to more engaging and dynamic gameplay experiences. As they say, in game development, the journey truly matters as much as the destination. Keep experimenting and exploring the potentials of `AStar3D` in Godot 4 to make your game world come alive!

Continuing Your Game Development Journey

Having taken your first steps with AStar3D and pathfinding in Godot 4, you’re well on your way to creating engaging and dynamic game environments. Remember, the world of game development is vast and ever-evolving, and there’s always room to enhance your skills and knowledge. If you’re eager to dive deeper and broaden your expertise, our Godot Game Development Mini-Degree is the perfect next step for your learning journey.

At Zenva, we equip you with practical skills through a structured learning path. Whether you’re a beginner or someone with a foundation looking to advance further, our courses adapt to your pace. Explore a wide array of topics within Godot, ranging from working with both 2D and 3D assets to mastering GDScript, and build real games that showcase your abilities. With our flexible and accessible online courses, you have the power to transform your game development passion into a tangible career.

For a broader look at all we have to offer in this engine, check out our comprehensive selection of Godot courses. Each course is developed to help you achieve your goals, whether that’s creating the next indie game hit or honing a specific set of skills. Unlock your potential with Zenva, and take your game development dreams to the next level.


By venturing into the realm of AStar3D pathfinding with Godot 4, you unlock a crucial aspect of game development that breathes intelligence and life into your virtual worlds. The skills you’ve begun to develop here are just scratching the surface of the profound capabilities of Godot, and at Zenva, we’re committed to guiding you every step of the way. Seize the opportunity to mold the future of interactive entertainment with your own hands by leveraging the full suite of our tutorials and courses.

Whether you dream of crafting complex levels or implementing advanced AI behaviors in your games, our Godot Game Development Mini-Degree awaits to transform those dreams into reality. Join us today and take your place in the vibrant community of game developers crafting tomorrow’s gaming experiences!

Python Blog Image

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