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:
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:
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.
Show Posts