Smarter Enemies: Implementing A* Pathfinding in Godot

Posted by Gemma Ellison

July 18, 2025

Forget the endless wandering and predictable enemy movements! It’s time to inject some real intelligence into your Godot games. We’re diving headfirst into the world of A* pathfinding, and I’m going to show you exactly how to implement it, even if you’re just starting out. This isn’t just about finding a path; it’s about creating truly dynamic and reactive AI. Let’s build smarter enemies together.

Setting Up the Navigation Mesh in Godot

The first step is preparing the environment for pathfinding. This involves creating a NavigationMesh node that outlines where our AI-controlled entities can move. Without this, the A* algorithm has nothing to work with.

Create a new Godot scene or open an existing one. Add a NavigationRegion2D or NavigationRegion3D node (depending on your project type). Make sure this node covers the traversable areas of your level. This is crucial; areas outside the navigation mesh are considered impassable.

Next, add a CollisionPolygon2D or CollisionShape3D node as a child of the NavigationRegion. This defines the shape of the walkable area. Draw the polygon/shape carefully to accurately represent the playable space.

Finally, bake the navigation mesh! Select the NavigationRegion2D or NavigationRegion3D node, and in the Inspector panel, click “Bake” under the “Navigation” section. This generates the navigation data used by the A* algorithm. A common mistake is forgetting to bake, leading to pathfinding failures. Double-check this step if things aren’t working.

Implementing the A* Algorithm in GDScript

Now for the juicy part: the code! We’ll create a GDScript to handle the A* logic. This script will be responsible for finding the shortest path between two points on the navigation mesh.

Create a new GDScript and name it something descriptive like Pathfinding.gd. Attach this script to a node in your scene – a dedicated “Game Manager” node is often a good choice.

Here’s the GDScript code:

extends Node

func find_path(start : Vector2, end : Vector2) -> Array[Vector2]:
    var navigation : Navigation = get_tree().root.get_node("Main").get_node("Navigation2D") # Replace "Main" and "Navigation2D" with your actual node names

    var astar = AStar.new()

    # Get the navigation map from the navigation node
    var nav_map = navigation.get_navigation_map()

    # Add all the connections to the AStar instance
    var points = navigation.get_all_cell_positions()
    for point in points:
        astar.add_point(points.size(), point, 1) # The id here doesn't actually matter as long as it's unique

    for i in range(points.size()):
        for j in range(i + 1, points.size()):
            if points[i].distance_to(points[j]) < 32:
                astar.connect_points(i, j) # The ids need to be the same as add_point


    var start_point = navigation.get_closest_point(start)
    var end_point = navigation.get_closest_point(end)

    var start_id = -1
    var end_id = -1

    var counter = 0
    for point in points:
        if point == start_point:
            start_id = counter
        if point == end_point:
            end_id = counter
        counter += 1

    if start_id == -1 or end_id == -1:
        print("Couldn't find start or end point in A* graph")
        return [] # Returning an empty array if no path is found

    var path = astar.get_path(start_id, end_id)
    var final_path : Array[Vector2]
    final_path.resize(path.size())
    for i in range(path.size()):
        final_path[i] = points[int(path[i])]
    return final_path

Explanation:

find_path(start, end): This function takes the starting and ending positions (Vector2) as input and returns an array of Vector2 points representing the path.
Navigation : This retrieves the navigation node from the tree. CRITICAL: Ensure your node names match!
AStar.new(): Creates a new AStar object.
get_all_cell_positions(): Gets all valid navigation cell positions.
The code then iterates through these points, adding them to the AStar object and connecting them based on proximity. You may need to adjust the proximity threshold (distance_to() < 32) depending on your tile size.
get_closest_point(): Finds the closest point on the navigation mesh to the provided start and end positions. This is vital, as A* needs to work within the navigation mesh.
Error Handling: The if start_id == -1 or end_id == -1: block prevents crashes if the start or end point is outside the navmesh.
astar.get_path(start_id, end_id): This is where the magic happens! It calculates the path using the A* algorithm and returns an array of point indices.
The code then translates these indices to real Vector2 positions and returns the final path.

Integrating Pathfinding with Enemy AI

Now, let’s make an enemy follow the path. Create a simple enemy scene (e.g., a KinematicBody2D with a sprite and collision shape). Attach a script to the enemy.

Here’s an example enemy script:

extends KinematicBody2D

export var speed = 50
var path = []
var path_index = 0

func _ready():
    #Get Pathfinding Node
    var pathfinding_node = get_tree().root.get_node("Main").get_node("Pathfinding") #Replace "Main" and "Pathfinding" with your actual node names

    #Set initial path
    path = pathfinding_node.find_path(position, Vector2(500, 300)) #Example destination

func _physics_process(delta):
    if path.size() > 0 and path_index < path.size():
        var direction = (path[path_index] - position).normalized()
        var collision = move_and_collide(direction * speed * delta)

        if position.distance_to(path[path_index]) < 5:
            path_index += 1
    else:
        #Reached the end, do something (e.g., find a new path)
        path = []
        path_index = 0

Explanation:

speed: An exported variable to control the enemy’s movement speed.
path: An array to store the calculated path.
path_index: Keeps track of the current point in the path the enemy is moving towards.
_ready(): In the _ready function, we call the find_path function (from our Pathfinding.gd script) to get a path from the enemy’s starting position to a target position. IMPORTANT: Adjust the node names!
_physics_process(): In the _physics_process function, we check if there’s a path and if the enemy hasn’t reached the end of it. If so, we calculate the direction to the next point in the path and move the enemy using move_and_collide.
The code checks if the enemy is close enough to the current path point and increments path_index if so.
If the enemy reaches the end of the path, you can implement new behavior, such as finding a new path.

Challenges and Pitfalls

Forgetting to Bake: The most common mistake. Always bake the navigation mesh after making changes.
Incorrect Node Names: The code relies on specific node names. Double-check that the names in your scripts match the names of your nodes in the Godot scene.
Start/End Points Outside NavMesh: Ensure that the start and end points of the pathfinding query are within the navigation mesh. Our code now includes a basic check, but you might need more robust handling.
Performance: For large or complex levels, A* pathfinding can become computationally expensive. Consider optimizing the navigation mesh or using techniques like path smoothing.
Zig-zagging: Enemies might zig-zag slightly. This can often be fixed by increasing the accepted distance to a path point (position.distance_to(path[path_index]) < 5). You can also try smoothing the path after calculation.

This detailed walkthrough provides a solid foundation for implementing A* pathfinding in your Godot projects. Experiment, optimize, and build smarter, more engaging AI!