Technical Breakdown

                    
// Finds a path from the start position to the target position
public static List<Vector2Int> FindPath(Vector2Int startPosition, Vector2Int targetPosition)
{
    // Validates the target position before proceeding to find the path
    if (!IsTargetValid(targetPosition)) return null;

    // Initializes start and target nodes
    PathNode startNode = new PathNode(startPosition);
    PathNode targetNode = new PathNode(targetPosition);

    // Performs path search and returns the result
    PathNode finalNode = SearchPath(startNode, targetNode);
    return finalNode != null ? BuildPath(finalNode) : null;
}

// Searches for a path using the A* algorithm
private static PathNode SearchPath(PathNode startNode, PathNode targetNode)
{
    // Initializes lists for open and closed nodes and a dictionary for node references
    var openList = new List<PathNode> { startNode }; // Nodes to be evaluated
    var closedList = new HashSet<PathNode>(); // Nodes already evaluated
    var vecNodeDict = new Dictionary<Vector2Int, PathNode>
    {
        [startNode.Position] = startNode // Store start node
    };

    int searchCount = 0; // Limit search iterations

    while (searchCount < 1000 && openList.Count > 0)
    {
        // Gets node with the lowest F cost
        PathNode current = GetLowestFCostNode(openList);

        // Checks if the target has been reached
        if (IsTargetNode(current, targetNode))
            return current;

        openList.Remove(current); // Moves current node to closed list
        closedList.Add(current);

        // Evaluates neighbors of the current node
        foreach (var neighbor in GetNeighbourNodes(current))
        {
            if (closedList.Contains(neighbor)) continue; // Skips evaluated neighbors

            // Updates costs of the neighbor
            UpdateNodeCosts(current, neighbor, targetNode);

            // Adds to open list if not already present
            if (!openList.Contains(neighbor))
            {
                openList.Add(neighbor);
                vecNodeDict[neighbor.Position] = neighbor; // Stores neighbor in dictionary
            }
        }

        searchCount++; // Increments search count
    }
    return null; // Returns null if no path found
}

// Updates the G and H costs for a neighbor node
private static void UpdateNodeCosts(PathNode current, PathNode neighbor, PathNode targetNode)
{
    float gCost = current.G + 1; // Cost from start to current node
    float hCost = GetDistance(neighbor, targetNode); // Heuristic cost to target

    // Updates costs if this path to neighbor is better than any previous one
    if (gCost < neighbor.G)
    {
        neighbor.SetConnection(current); // Sets current as connection
        neighbor.SetCosts(gCost, hCost); // Updates costs
    }
}

// Builds the path from the final node to the start node
private static List<Vector2Int> BuildPath(PathNode finalNode)
{
    var pathCoords = new List<Vector2Int>();

    // Traverses back through the connections to build the path
    while (finalNode != null)
    {
        pathCoords.Add(finalNode.Position);
        finalNode = finalNode.Connection; // Moves to the next node in the path
    }

    pathCoords.Reverse(); // Reverses to get the path from start to end
    return pathCoords;
}

// Gets the node with the lowest F cost from the open list
private static PathNode GetLowestFCostNode(List<PathNode> openList) =>
    openList.OrderBy(node => node.F).First();

// Checks if the current node is the target node
private static bool IsTargetNode(PathNode current, PathNode targetNode) =>
    current.Position == targetNode.Position;

// Retrieves the neighboring nodes of the current node
private static List<PathNode> GetNeighbourNodes(PathNode node)
{
    var neighbors = new List<PathNode>();
    var directions = new Vector2Int[] {
        new Vector2Int(-1, 0), new Vector2Int(1, 0), new Vector2Int(0, 1), new Vector2Int(0, -1)
    };

    // Checks each direction for valid neighbor nodes
    foreach (var dir in directions)
    {
        Vector2Int newPos = node.Position + dir;

        if (TileOccupied(newPos)) continue; // Skips occupied tiles

        // Creates a new neighbor node
        var neighborNode = new PathNode(newPos);
        neighborNode.SetConnection(node); // Sets current node as connection
        neighbors.Add(neighborNode); // Adds to neighbors list
    }
    return neighbors;
}

// Checks if the specified tile is occupied
private static bool TileOccupied(Vector2Int position) =>
    Physics2D.OverlapBox(position, Vector2.one * 0.2f, 0f) != null;

// Calculates the Manhattan distance between two nodes
private static float GetDistance(PathNode a, PathNode b) =>
    Mathf.Abs(a.Position.x - b.Position.x) + Mathf.Abs(a.Position.y - b.Position.y);

// Validates if the target position is unoccupied
private static bool IsTargetValid(Vector2Int targetPos) =>
    Physics2D.OverlapBox(targetPos, Vector2.one * 0.4f, 0f) == null;