HEX GRIDS
Copyright (c) Clark Verbrugge, 1996. [clump@cs.mcgill.ca]
This article may be freely distributed as long as this attribution is 
included.

Here's a hexagonal grid with a coordinate system mapped to square grids.
Note that this is just one possible orientation of the hexagons---if
you change it so hexes are adjacent horizontally instead of vertically,
you get a symmetric situation (the details of which i'm sure you can
work out; essentially, in (1) and (2) below, the "==" changes to a "!=").

                      __   5
                   __/D \__   4
                __/  \__/  \__   3      "Y" coord
             __/  \__/  \__/  \__   2
          __/A \__/  \__/  \__/  \__   1
       __/  \__/  \__/E \__/B \__/  \__   0
      /  \__/G \__/  \__/  \__/F \__/C \
      \__/  \__/  \__/  \__/  \__/  \__/
         \__/  \__/  \__/  \__/  \__/   5
            \__/  \__/  \__/  \__/   4
               \__/  \__/  \__/    3
                  \__/  \__/    2     "X" coord
                     \__/    1
                         0    

Unlike the obvious route, these coordinates are not orthogonal---that
is, the y-coord increases to the upper-left, and the x-coord increases
to the upper-right. This means "A" has coords (2,5), B is (4,2), 
C = (5,0),  D = (5,5), E = (3,3), F = (4,1) and G = (1,4).  
This also means that a "square" in this coordinate system is more of 
a diamond shape (as you can tell from the 6x6 "square" shown above).
Circles, however, are reasonably circular.

Distance between points A and B is given by:
    dx = B.x - A.x;
    dy = B.y - A.y;
    if (sign(dx) == sign(dy)) {    // this is (1); see first paragraph
        dist = max(abs(dx),abs(dy));
    } else {
        dist = abs(dx) + abs(dy);
    }
This is a distance metric in the technical sense.

So, for instance, the distance between A and B is given by:
    dx = 4 - 2 = 2;
    dy = 2 - 5 = -3;
    since sign(dx) != sign(dy), 
        dist = abs(2) + abs(-3) = 5;

How do you compute line-of-sight?  You use a simple modification of
Bresenham's line algorithm.  Here's a schematic version which calls
the function "process()" for each coord in the line from A to B.
Note that there's a choice in the horizontal move of whether to
increment x, process, then y, or to increment y, process, then x.

    // assume abs(dx) >= abs(dy), it's symmetric otherwise
    int sig,dx,dy,factor,x,y,xone,yone;
    // this is (2); the next line changes from "==" to "!=" if 
    // hexagons are not stacked vertically (see first paragraph)
    sig = (sign(dx) == sign(dy));   
    if(dx<0) xone = -1; else xone = 1; // unit increments
    if(dy<0) yone = -1; else yone = 1; // unit increments
    if (dx % 2)  {  // so dx is divisible by two
        dx *= 2;
        dy *= 2;
    }  
    dx = abs(dx); dy = abs(dy); // don't need the signs anymore
    factor = dx/2; // should start at 0.5, which is just (dx/2)/dx
    x = A.x; y = A.y;
    process(x,y);
    while (x != B.x || y != B.y) { 
        factor += dy;
        if (factor >= dx) {
            // Make a "diagonal move" in grid (ie vertical or horizontal)
            factor -= dx;
            if(sig) {  // vertical move: 2 moves in 1
                x += xone; // add 1 in the appropriate sign
                y += yone;   
            } else {   // horizontal move: 2 moves in 2
                x += xone; // doesn't matter which increases first
                process(x,y);
                y += yone;
            }
        } else {
            x += xone;
        }
        process(x,y);
    }

For example to get from G to D in our grid described above, we get
the following sequence of steps:
    dx = 4, dy = 1, factor = 2, sig = true
    process(1,4);
    factor = 3, process(2,4);
    factor = 0, process(3,5);
    factor = 1, process(4,5);
    factor = 2, process(5,5);

Incidentally, the distance metric and matrix representation 
described above is (well?) known in the literature; if you want 
the reference email me (address is at top).

--- end ----