A-star algorithm after 2D tilemap 90-degree rotation

Question

I am learing Unity and for now trying to implement a simply pathfinding alogorithm in a simply 2D isometric diamond-shaped tilemap.

Recently I learned a way how to rotate tilemap and I already have a question.

My rotation algorithm works as follows:

1. I create a Dictionary Dictionary<Vector3Int, TileBase> for storing tiles.
2. Then I iterate through my tilemap and implement a 90-degrees rotation operator as (x, y) --> (-y, x). And save new tiles position in a Dictionary.
3. Then I clear all tiles by calling tilemap.ClearAllTiles()
4. And then set tiles again from Dictionary.

f

foreach (var item in tilesPositions)
{
tilemap.SetTile(item.Key, item.Value);
}
tilemap.CompressBounds();

Honestly I am worry a little about implementation of the pathfinding. As I understand, this algorithm receive start position and end position and made some calculation for mob's to move from start to end

Let imagine I rotate my tilemap making (x, y) --> (-y, x) for all tiles Will this procdeure broke a pathfinding algorithm?

And most of all, is the rotation of tilemap which maded with recalculation position for all tiles the best way to do 90 degree rotation for an isometric game?

Answer 1

You need to decouple/disconnect different parts of your application.

Ideally, you want to have some object representing the board in memory which only deals with gameplay-specific concerns (placing pieces, movement, etc).

Whilst it's possible to use a Dictionary<Vector3Int, TileBase> for this, it's not actually a very useful format for finding (or reasoning about) adjacent tiles.

You might be better off creating a 2-dimensional array of TileBase...

var board = new TileBase[10,10];

Then you can refer to the tiles by coordinate (0-indexed) board[0,0], board[8,9], etc.

This will make it a lot easier to find the next tile when path finding.

---

Entirely separate to that, you have a requirement to display that board in the UI.

If possible, you can just pull the data directly from the board to recreate the UI elements as needed.

If you absolutely must have it in the form of a Dictionary<Vector3Int, TileBase>, you can convert from the board to your dictionary format.

If you do that step using a couple of nested loops as shown below

var dictionary = new Dictionary<Vector3Int, TileBase>();

for (int x = 0; x < board.GetLength(0); x++)
{
    for (int y = 0; y < board.GetLength(1); y++)
    {
        if (board[x, y] != null)
        {
            dictionary[new Vector3Int(x, y, 0)] = board[x, y];
        }
    }
}

Then it becomes trivially simple to rotate/flip the board by tweaking the values written to the dictionary (or even by playing with the loop order/variables)

All your path finding is now working on board alone, so doesn't have to worry about rotation or any other UI-level concerns.

p.s. There's a Vector2Int if you only need 2D coordinates.