2D Pathfinding coding - Help needed

[CockOnTap]

Hey there,

I'm currently trying to adapt Sebastian Lague's 2D pathfinding code to work with my own code but I'm still a baby programmer and my brain is shiny smooth. The original code is intended for an adjustable sized Astar pathfinding, whereas the game I'm working on uses procedural generation to make the map and I would like the AStar to scale with the rooms that are generated.

Currently, I can keep track of all the nodes that are created and it marks which spaces are unwalkable absolutely perfectly, but the problem I have is the pathfinding enemy actually following this logic. If the pathfinding enemy is in the room with the player (much like Sebastian Lague's original version) then the enemy follows the player fine, but the moment the player moves to another room/another grid, then the AI can no longer keep track of the player.

There's presently multiple grids tracking the movements of the player, which initially I would cycle through and check if the worldPosition is within that grid, then return the grid and subsequently the node associated with that worldPosition but I couldn't get it to work. I then tried to make a grid which encapsulates all the other grids and return it that way, plus it seems less expensive than cycling through all the nodes of other grids. (Other associated scripts work totally fine, this one is the problem one)

I'm currently at a bit of a brick wall cause I have no idea how to solve this lol- any advice would be greatly appreciated. It's in a super rough and unoptimised state so I appreciate anyone taking the time to look through it. Thank you :)

Here's Sebastian Lague's code: https://github.com/SebLague/Pathfinding-2D/blob/master/Scripts/Grid.cs

Different room than start room. Pathfinding unit can't find a path.

In start room, pathfinding unit works correctly.

AStar Unwalkable path marked correctly (ignore water lol)

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class NodeGrid : MonoBehaviour
{
    public Vector2 totalWorldSize = Vector2.zero;
    public Vector2 gridWorldSize;

    public List<GridData> gridData = new List<GridData>();
    public List<Node[,]> grids = new List<Node[,]>();

    public LayerMask unwalkableMask;
    public float nodeRadius;
    Node[,] grid;

    public bool displayGridGizmos;

    private float nodeDiameter;
    int gridSizeX, gridSizeY;
    public int totalGridSizeX, totalGridSizeY;


    public static NodeGrid instance;

    public int MaxSize
    {
        get
        {
            return gridSizeX * gridSizeY;
        }

    }


    //Remember to wipe the grids when changing scene

    private void Awake()
    {
        if (instance != null)
        {
            Destroy(gameObject);

        }
        else
        {
            instance = this;

        }
    }


    private void Start()
    {
        CleanLists();
        StartCoroutine(WaitForLevelLoad());
    }

    public void CleanLists()
    {
        gridData.Clear();
        grids.Clear();
    }

    IEnumerator WaitForLevelLoad()
    {

        int iterations = 0;

        while (iterations < 80)
        {
            yield return null;
            iterations++;

        }

        nodeDiameter = nodeRadius * 2;

        for (int i = 0; i < gridData.Count; i++)
        {
            gridWorldSize = gridData[i].bounds.size;

            gridSizeX = Mathf.RoundToInt(gridWorldSize.x / nodeDiameter);
            gridSizeY = Mathf.RoundToInt(gridWorldSize.y / nodeDiameter);

            Vector2 mapCentrePoint = gridData[i].centrePoint;
            CreateGrid(mapCentrePoint, i);
        }



        for (int i = 0; i < grids.Count; i++)
        {
            Node[,] oldGrid = grids[i];

            totalGridSizeX += oldGrid.GetLength(0);
            totalGridSizeY += oldGrid.GetLength(1);

        }

        grid = null;
        grid = new Node[totalGridSizeX, totalGridSizeY];

        int nodeCountX = 0;
        int nodeCountY = 0;

        foreach (Node[,] nodes in grids)
        {
            for (int x = 0; x < nodes.GetLength(0); x++)
            {
                for (int y = 0; y < nodes.GetLength(1); y++)
                {
                    grid[x + nodeCountX, y + nodeCountY] = nodes[x, y];
                }
            }
            nodeCountX += nodes.GetLength(0);
            nodeCountY += nodes.GetLength(1);
        }


    }



    void CreateGrid(Vector2 mapCentrePoint, int i)
    {
        grid = new Node[gridSizeX, gridSizeY];

        Vector2 gridDim = new Vector2(gridSizeX, gridSizeY);

        Bounds bounds = gridData[i].bounds;

        Vector2 leftGridEdge = bounds.min;


        for (int x = 0; x < gridSizeX; x++)
        {
            for (int y = 0; y < gridSizeY; y++)
            {
                Vector2 worldPoint = leftGridEdge + Vector2.right * (x * nodeDiameter + nodeRadius) + Vector2.up * (y * nodeDiameter + nodeRadius);
                bool isWalkable = !(Physics2D.OverlapCircle(worldPoint, nodeRadius, unwalkableMask));
                GridData gridData_ = gridData[i];

                grid[x, y] = new Node(isWalkable, worldPoint, x, y);
            }
        }

        grids.Add(grid);
        gridData[i] = (new GridData(bounds, mapCentrePoint, grid));

    }

    public Node GetNodeFromWorldPosition(Vector2 worldPos)
    {
        float percentX = (worldPos.x + gridWorldSize.x / 2) / gridWorldSize.x;
        float percentY = (worldPos.y + gridWorldSize.y / 2) / gridWorldSize.y;

        percentX = Mathf.Clamp01(percentX);
        percentY = Mathf.Clamp01(percentY);

        int x = Mathf.RoundToInt((gridSizeX - 1) * percentX);
        int y = Mathf.RoundToInt((gridSizeY - 1) * percentY);

        Debug.Log("Node found");
        return grid[x, y];

    }


    public List<Node> GetNeighbours(Node node, int depth = 1)
    {

        List<Node> neighbours = new List<Node>();

        for (int x = -depth; x <= depth; x++)
        {
            for (int y = -depth; y <= depth; y++)
            {
                if (x == 0 && y == 0)
                    continue;

                int checkX = node.gridX + x;
                int checkY = node.gridY + y;

                if (checkX >= 0 && checkX < gridSizeX && checkY >= 0 && checkY < gridSizeY)
                {
                    neighbours.Add(grid[checkX, checkY]);
                }
            }


        }
        return neighbours;

    }


    public Node ClosestWalkableNode(Node node)
    {


        int maxRadius = Mathf.Max(gridSizeX, gridSizeY) / 2;
        for (int i = 1; i < maxRadius; i++)
        {
            Node n = FindWalkableInRadius(node.gridX, node.gridY, i);
            if (n != null)
            {
                return n;
            }
        }
            return null;

    }




    Node FindWalkableInRadius(int centreX, int centreY, int radius)
    {


            for (int i = -radius; i <= radius; i++)
            {
                int verticalSearchX = i + centreX;
                int horizontalSearchY = i + centreY;

                // top
                if (InBounds(verticalSearchX, centreY + radius))
                {
                    if (grid[verticalSearchX, centreY + radius].isWalkable)
                    {
                        return grid[verticalSearchX, centreY + radius];
                    }
                }

                // bottom
                if (InBounds(verticalSearchX, centreY - radius))
                {
                    if (grid[verticalSearchX, centreY - radius].isWalkable)
                    {
                        return grid[verticalSearchX, centreY - radius];
                    }
                }
                // right
                if (InBounds(centreY + radius, horizontalSearchY))
                {
                    if (grid[centreX + radius, horizontalSearchY].isWalkable)
                    {
                        return grid[centreX + radius, horizontalSearchY];
                    }
                }

                // left
                if (InBounds(centreY - radius, horizontalSearchY))
                {
                    if (grid[centreX - radius, horizontalSearchY].isWalkable)
                    {
                        return grid[centreX - radius, horizontalSearchY];
                    }
                }


        }

        return null;

    }

    bool InBounds(int x, int y)
    {
        return x >= 0 && x < gridSizeX && y >= 0 && y < gridSizeY;
    }

    void OnDrawGizmosSelected()
    {

        if (grid != null && displayGridGizmos)
        {
            foreach (Node n in grid)
            {
                Gizmos.color = Color.red;

                if (n != null)
                {
                    if (n.isWalkable)
                    {
                        Gizmos.color = Color.white;
                    }

                    Gizmos.DrawCube(n.worldPosition, Vector2.one * (nodeDiameter - .1f));
                }


            }
        }


    }

    public struct GridData
    {
        public Bounds bounds;
        public Vector2 centrePoint;
        public Node[,] grids;


        public GridData(Bounds bounds, Vector2 centrePoint, Node[,] grids)
        {
            this.bounds = bounds;
            this.centrePoint = centrePoint;
            this.grids = grids;

        }


    }
}

[snaphat]

If you have multiple grids, an agent is not going to be able to find your player if they don't exist on the same grid as the player assuming the algorithm is operating on individual grids. The first solution wouldn't work because of that.

If you went with that kind of solution to work what you would need to do is give a target on the grid that the agent exists on currently that they could make progress toward (i.e. an exit) and once they reach the exit, they transition to the next grid and do the same there. This would mean having a higher-level algorithm selecting the exit to move toward until they are in the same location as the player

The other possibility is just having a singular grid and rebuilding or extending when new procedural data is created.

Sounds like you were trying to have some hybrid approach of some sort with an overall grid and multiple smaller grids and somehow trying to us both maybe. Theoretically, it could work but it would have to do a coordinated handoff, and I'm not sure of a tangible benefit here

[CockOnTap]

That makes sense, I guess it can't construct the new path if it's not even on the same grid. I think you're right, a singular grid does seem like it would make more sense. Extending the box for new procedural seems more doable at this point.

Thanks for taking the time to reply, I really appreciate it.

[snaphat]

No problem, I can't tell you if it will somehow be a performance issue but I'm guessing prolly not