Question

So my issue is, usually when I generate my maps I’d use the following:

for(int x = 0; x < width; x++) {
    for(int y = 0; y < height; y++) {
       tiles.add(new Tile(x, y));
    }
}

You can get the just of that.
Anyway I need to pretty much have pragmatic way of doing this in an isometric / 45 degree rotation.

Say the first loop you’d add new Tile(width / 2, 0).

Next loop you’d add new Tile((width / 2) – 1, 0), and new Tile((width / 2) + 1, 0).

I’ve experimented with a few differing ways to do this, but haven’t had much success.

Answer 1

If I understand correctly, it seems like you’re trying to represent the tiles for an isometric game, e.g.:

For this, your Tiles store the (x,y) information of their location with the following layout:

y \ x | 0 | 1 | 2 | 3 | 4 | 5 | 6
------+---+---+---+---+---+---+---
   0  |   |   |   | A |   |   |
------+---+---+---+---+---+---+---
   1  |   |   | B |   | C |   |
------+---+---+---+---+---+---+---
   2  |   | D |   | E |   | F |
------+---+---+---+---+---+---+---
      |   |   |   |   |   |   |

and so on.

However, I would suggest to decouple the internal representation of your tile grid from the way it is displayed. Just because you want isometric graphics doesn’t necessarily mean that you have to store your Tiles’ (x,y)-positions in a diamond shape as well.

Instead, try the following layout for each of your tiles:

y \ x | 0 | 1 | 2 | 3 
------+---+---+---+---
   0  | A | C | F | 
------+---+---+---+---
   1  | B | E |   | 
------+---+---+---+---
   2  | D |   |   | 
------+---+---+---+---
      |   |   |   | 

That is, tile A is created as new Tile(0,0), tile B as new Tile(0,1), etc.

With this representation you’ll get the advantage that adjacent tiles in your isometric display will only differ by 1 in either the x- or the y-direction. This should make the initialization step of your tiles list much easier.

To map these coordinates to the isometric display positions, remember that tile A at location (0,0) is at the top of the diamond. You can then compute the display positions of all other tiles relative to that one:

• The difference in the x-coordinate translates to moving right and down
• The difference in the y-coordinate translates to moving left and down

So let’s assume your display renders A at the pixel coordinates (px, py), and every tile is rendered with a width of pWidth and a height of pHeight.

The horizontal offset for tile can then be computed by walking right tile.x times and walking left tile.y times. Because of the isometric view, you only offset by half of the width in every step.

int pxTile = (tile.x - tile.y) * pWidth / 2 + px;

The vertical offset is computed similarly. While tile.x and tile.y cancel each other out in the horizontal directorion (since left and right are opposite of each other), they both contribute to moving down in the vertical direction.

int pyTile = (tile.x + tile.y) * pHeight / 2 + py;

Unless your game does scrolling/zooming, you can compute the pixel coordinates of every Tile right in the constructor, because they only depend on the values of (x,y) and the constants width, px, py, pWidth, and pHeight.