map[x][y] or map[y][x]

[Z]

As Jo said, [ x][y] is the standard in math, physics, and most importantly programming.

I agree that (x,y) is a standard when writing coordinates. But you do not usually index arrays in maths and physics. Well, you do, when you are using matrices. But note that matrix indices are usually written as a_ij where i is the row number (y) and j is the column number (x).

Also, most graphical formats I know (BMP, SDL, OpenGL textures, internal VGA memory...) list the pixels row by row (row 1, row 2, row 3, ...) which corresponds to [y][ x] indexing.

I have looked at some available roguelike sources, and some of them use [y][ x], some use [ x][y] (without any clear majority).

[XLambda]

Well, curses used y,x coordinates. And in linear algebra matrix elements are usually defined as a_ij denoting the element in the ith row and jth column. I think it's just a maths thing.

[guest509]

  I just asked my niece what comes first, 'x' or 'y'. After successfully completing the ABC song (many times) it was clear that 'x' does in fact come before 'y'.

  I'd consider that to be pretty much the final word on the subject.

[requerent]

  I just asked my niece what comes first, 'x' or 'y'. After successfully completing the ABC song (many times) it was clear that 'x' does in fact come before 'y'.

  I'd consider that to be pretty much the final word on the subject.

+1

[Omnomnom]

I found arrays were too impersonal. I give all my tiles their own names.

Code: [Select]

Tile tilex1y1;
Tile tilex2y1;
Tile tilex7y3;
Tile amy;
Tile tilex14y30;
Tile true;
Tile false;
Tile tilex18y25;
Tile dontStandHere;
etc

Don't seem to be making much progress though for some reason

[Quendus]

I found arrays were too impersonal. I give all my tiles their own names.

Code: [Select]

Tile tilex1y1;
Tile tilex2y1;
Tile tilex7y3;
Tile amy;
Tile tilex14y30;
Tile true;
Tile false;
Tile tilex18y25;
Tile dontStandHere;
etc

Don't seem to be making much progress though for some reason

This is the future of programming. All it needs for this paradigm to work is an good actor for each tile.

[naughty]

In terms of [ x][y] versus [y][ x], it won't affect performance on modern machines either way, but tty based displays drew the screen from left to right top to bottom making [ x][y] make more sense. I think virtually everyone uses [ x][y], and every open source program I've seen uses [ x][y]. I use [ x][y] too. As Jo said, [ x][y] is the standard in math, physics, and most importantly programming.

There is an enormous performance difference (can be upto 100X on tight loops) between [x ][y ] and [y ][x ] but most roguelikes aren't performance sensitive enough to notice the difference. The difference is even bigger on more modern hardware because CPU clock rates are so high that memory latency is a big issue. This is something you really need to be aware of when writing very high performance software like high end games, scientific applications and so on.

This is vital knowledge for working on the engines of AAA games for example.

In C multidimensional arrays are laid out with the rightmost array index increasing first so:

Code: [Select]

char map[X][Y] = ...

// The above is the same as a 1D array laid out as:
{ [X0,Y0], [X0,Y1], ..., [X0,YN], [X1,Y0], [X1,Y1], ..., [X1,YN] ... }


Memory is broken up into little contiguous arrays called cache-lines (normally 64 bytes these days). Only so many cache lines can be in the L1 cache, which is the fastest to access memory apart from registers. Getting a new cache-line into the cache is a lot slower than using something already in the cache. So the fastest way to access memory (all things being equal) is to access memory very close to previously accessed memory. For example:

Code: [Select]

const int DIM = 256;
char map[DIM][DIM] = {0};

// FAST LOOP
// This is 'column' major, it iterates through the Y dimension first.
for (int x=0; x < DIM; ++x) {
    for (int y=0; y < DIM; ++y) {
        map[x][y] = // something...
   }
}

// SLOW LOOP
// This is 'row' major, it iterates through the X dimension first.
for (int y=0; y < DIM; ++y) {
    for (int x=0; x < DIM; ++x) {
        map[x][y] = // something...
   }
}

Now the fast loop is 'column' major (top-to-bottom, left-to-right) but we have a natural assumption that we iterate in the same way we read, e.g. left-to-right, top-to-bottom. But to make that the fast way to loop you need to order you map as [y ][x ].

This is where the controversy comes from you can't have both [x ][y ] and 'left-to-right, top-to-bottom' iteration order you have to pick one if you want the best performance.

However most roguelikes don't need to care because they don't tax the hardware much at all but if you wanted to do FOV calculations on every tile for some reason you better do it the optimal way or it'll be a hell of a lot slower.