diff -r 000000000000 -r 3eb7be1dd7b6 Source/HexGrid.m
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Source/HexGrid.m	Mon Mar 10 17:30:57 2008 -0700
@@ -0,0 +1,200 @@
+/*  This code is based on Apple's "GeekGameBoard" sample code, version 1.0.
+    http://developer.apple.com/samplecode/GeekGameBoard/
+    Copyright © 2007 Apple Inc. Copyright © 2008 Jens Alfke. All Rights Reserved.
+
+    Redistribution and use in source and binary forms, with or without modification, are permitted
+    provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions
+      and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of
+      conditions and the following disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
+    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+    FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRI-
+    BUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
+    THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#import "HexGrid.h"
+#import "Game.h"
+
+
+@implementation HexGrid
+
+
+- (id) initWithRows: (unsigned)nRows columns: (unsigned)nColumns
+            spacing: (CGSize)spacing
+           position: (CGPoint)pos
+{
+    // Ignore given spacing.height; set it to make the hexagons regular.
+    CGFloat capHeight = spacing.height / 2 * tan(M_PI/6);
+    CGFloat side = spacing.height / 2 / cos(M_PI/6);
+    spacing.height = side + capHeight;
+    
+    self = [super initWithRows: nRows columns: nColumns
+                       spacing: spacing
+                      position: pos];
+    if( self ) {
+        _capHeight = capHeight;
+        _side = side;
+        self.bounds = CGRectMake(-1, -1, 
+                                 (nColumns+0.5)*spacing.width + 2,
+                                 nRows*spacing.height+capHeight + 2);
+        _cellClass = [Hex class];
+    }
+    return self;
+}
+
+
+- (id) initWithRows: (unsigned)nRows columns: (unsigned)nColumns
+              frame: (CGRect)frame;
+{
+    // Compute the horizontal spacing:
+    CGFloat s = floor(MIN( (frame.size.width -2.0)/nColumns,
+                         (frame.size.height-2.0)/(nRows+0.5*tan(M_PI/6)) / (0.5*(tan(M_PI/6)+1/cos(M_PI/6))) ));
+    return [self initWithRows: nRows columns: nColumns
+                      spacing: CGSizeMake(s,s)
+                     position: frame.origin];
+}
+    
+    
+- (void) dealloc
+{
+    CGPathRelease(_cellPath);
+    [super dealloc];
+}
+
+
+- (void) addCellsInHexagon
+{
+    int size = _nRows - !(_nRows & 1);      // make it odd
+    for( int row=0; row<_nRows; row++ ) {
+        int n;                              // # of hexes remaining in this row
+        if( row < size )
+            n = size - abs(row-size/2);
+        else
+            n = 0;
+        int c0 = floor(((int)_nRows+1-n -(row&1))/2.0);       // col of 1st remaining hex
+
+        for( int col=0; col<_nColumns; col++ )
+            if( col>=c0 && col<c0+n )
+                [self addCellAtRow: row column: col];
+    }
+}
+
+
+- (GridCell*) createCellAtRow: (unsigned)row column: (unsigned)col 
+               suggestedFrame: (CGRect)frame
+{
+    // Overridden to stagger the odd-numbered rows
+    if( row & 1 )
+        frame.origin.x += _spacing.width/2;
+    frame.size.height += _capHeight;
+    return [super createCellAtRow: row column: col suggestedFrame: frame];
+}
+
+
+// Returns a hexagonal CG path defining a cell's outline. Used by cells when drawing & hit-testing.
+- (CGPathRef) cellPath
+{
+    if( ! _cellPath ) {
+        CGFloat x1 = _spacing.width/2;
+        CGFloat x2 = _spacing.width;
+        CGFloat y1 = _capHeight;
+        CGFloat y2 = y1 + _side;
+        CGFloat y3 = y2 + _capHeight;
+        CGPoint p[6] = { {0,y1}, {x1,0}, {x2,y1}, {x2,y2}, {x1,y3}, {0,y2} };
+        
+        CGMutablePathRef path = CGPathCreateMutable();
+        CGPathAddLines(path, NULL, p, 6);
+        CGPathCloseSubpath(path);
+        _cellPath = path;
+    }
+    return _cellPath;
+}
+
+
+@end
+
+
+
+
+
+#pragma mark -
+
+@implementation Hex
+
+
+- (void) drawInParentContext: (CGContextRef)ctx fill: (BOOL)fill
+{
+    CGContextSaveGState(ctx);
+    CGPoint pos = self.position;
+    CGContextTranslateCTM(ctx, pos.x, pos.y);
+    CGContextBeginPath(ctx);
+    CGContextAddPath(ctx, ((HexGrid*)_grid).cellPath);
+    CGContextDrawPath(ctx, (fill ?kCGPathFill :kCGPathStroke));
+    
+    if( !fill && self.highlighted ) {
+        // Highlight by drawing my outline in the highlight color:
+        CGContextSetStrokeColorWithColor(ctx, self.borderColor);
+        CGContextSetLineWidth(ctx,6);
+        CGContextBeginPath(ctx);
+        CGContextAddPath(ctx, ((HexGrid*)_grid).cellPath);
+        CGContextDrawPath(ctx, kCGPathStroke);
+    }
+    CGContextRestoreGState(ctx);
+}
+
+
+- (BOOL)containsPoint:(CGPoint)p
+{
+    return [super containsPoint: p]
+        && CGPathContainsPoint( ((HexGrid*)_grid).cellPath, NULL, p, NO );
+}
+
+
+- (void) setHighlighted: (BOOL)highlighted
+{
+    if( highlighted != self.highlighted ) {
+        [super setHighlighted: highlighted];
+        [_grid setNeedsDisplay];        // So I'll be asked to redraw myself
+    }
+}
+
+
+#pragma mark -
+#pragma mark NEIGHBORS:
+
+
+- (NSArray*) neighbors
+{
+    NSMutableArray *neighbors = [NSMutableArray arrayWithCapacity: 6];
+    Hex* n[6] = {self.nw, self.ne, self.w, self.e, self.sw, self.se};
+    for( int i=0; i<6; i++ )
+        if( n[i] )
+            [neighbors addObject: n[i]];
+    return neighbors;
+}
+
+- (Hex*) nw     {return (Hex*)[_grid cellAtRow: _row+1 column: _column - ((_row+1)&1)];}
+- (Hex*) ne     {return (Hex*)[_grid cellAtRow: _row+1 column: _column + (_row&1)];}
+- (Hex*) e      {return (Hex*)[_grid cellAtRow: _row   column: _column + 1];}
+- (Hex*) se     {return (Hex*)[_grid cellAtRow: _row-1 column: _column + (_row&1)];}
+- (Hex*) sw     {return (Hex*)[_grid cellAtRow: _row-1 column: _column - ((_row-1)&1)];}
+- (Hex*) w      {return (Hex*)[_grid cellAtRow: _row   column: _column - 1];}
+
+// Directions relative to the current player:
+- (Hex*) fl     {return self.fwdIsN ?self.nw :self.se;}
+- (Hex*) fr     {return self.fwdIsN ?self.ne :self.sw;}
+- (Hex*) r      {return self.fwdIsN ?self.e  :self.w;}
+- (Hex*) br     {return self.fwdIsN ?self.se :self.nw;}
+- (Hex*) bl     {return self.fwdIsN ?self.sw :self.ne;}
+- (Hex*) l      {return self.fwdIsN ?self.w  :self.e;}
+
+
+@end