Add Board.Direction and Board.Position.

src/pegp/board.d

@@ -5,6 +5,35 @@ class Board
     private int m_size;
     private bool[] m_pegs;
 
+    enum Direction
+    {
+        NW,
+        NE,
+        W,
+        E,
+        SW,
+        SE,
+    }
+
+    struct Position
+    {
+        int row;
+        int col;
+
+        this(int row, int col)
+        {
+            this.row = row;
+            this.col = col;
+        }
+
+        Position move(Direction d, int dist = 1)
+        {
+            int new_row = row + dist * ((d / 2) - 1);
+            int new_col = col + dist * (((d % 3) + 1) & 1) * (d / 3 * 2 - 1);
+            return Position(new_row, new_col);
+        }
+    }
+
     this(int size)
     {
         assert(size >= 3);
@@ -31,15 +60,25 @@ class Board
         return (row >= 0) && (row < m_size) && (col >= 0) && (col <= row);
     }
 
+    bool valid_position(Position p)
+    {
+        return valid_position(p.row, p.col);
+    }
+
     bool peg_present(int row, int col)
     {
         return m_pegs[peg_index(row, col)];
     }
 
+    bool peg_present(Position p)
+    {
+        return peg_present(p.row, p.col);
+    }
+
     unittest
     {
         Board b = new Board(5);
-        assert(b.valid_position(0, 0));
+        assert(b.valid_position(Position(0, 0)));
         assert(b.valid_position(4, 0));
         assert(b.valid_position(4, 4));
         assert(b.valid_position(2, 2));
@@ -53,8 +92,34 @@ class Board
         assert(!b.valid_position(0, 4));
 
         assert(b.peg_present(1, 0));
-        assert(b.peg_present(1, 1));
+        assert(b.peg_present(Position(1, 1)));
         assert(b.peg_present(4, 4));
         assert(!b.peg_present(0, 0));
+
+        Position s = Position(2, 1);
+        assert(s.move(Direction.NW) == Position(1, 0));
+        assert(s.move(Direction.NE) == Position(1, 1));
+        assert(s.move(Direction.W) == Position(2, 0));
+        assert(s.move(Direction.E) == Position(2, 2));
+        assert(s.move(Direction.SW) == Position(3, 1));
+        assert(s.move(Direction.SE) == Position(3, 2));
+        assert(s.move(Direction.NW, 2) == Position(0, -1));
+        assert(s.move(Direction.NE, 2) == Position(0, 1));
+        assert(s.move(Direction.W, 2) == Position(2, -1));
+        assert(s.move(Direction.E, 2) == Position(2, 3));
+        assert(s.move(Direction.SW, 2) == Position(4, 1));
+        assert(s.move(Direction.SE, 2) == Position(4, 3));
+        assert(b.valid_position(s.move(Direction.NW)));
+        assert(b.valid_position(s.move(Direction.NE)));
+        assert(b.valid_position(s.move(Direction.W)));
+        assert(b.valid_position(s.move(Direction.E)));
+        assert(b.valid_position(s.move(Direction.SW)));
+        assert(b.valid_position(s.move(Direction.SE)));
+        assert(!b.valid_position(s.move(Direction.NW, 2)));
+        assert(!b.valid_position(s.move(Direction.NE, 2)));
+        assert(!b.valid_position(s.move(Direction.W, 2)));
+        assert(!b.valid_position(s.move(Direction.E, 2)));
+        assert(b.valid_position(s.move(Direction.SW, 2)));
+        assert(b.valid_position(s.move(Direction.SE, 2)));
     }
 }