tests/hlvariants/prototype/board.h

   1 #ifndef HLVARIANT__BOARD_H
   2 #define HLVARIANT__BOARD_H
   3
   4 #include <vector>
   5
   6 #include "point.h"
   7 #include "pathinfo.h"
   8
   9 namespace HLVariant {
  10
  11 template <typename _Piece>
  12 class Board {
  13 public:
  14   typedef _Piece Piece;
  15 private:
  16   Point m_size;
  17   std::vector<Piece> m_data;
  18 public:
  19   /**
  20     * Create a new Board with the given size.
  21     */
  22   Board(const Point& size);
  23
  24   /**
  25     * Create a Board copying a given one.
  26     */
  27   Board(const Board<Piece>& other);
  28
  29   /**
  30     * Compare two boards for equality.
  31     */
  32   bool operator==(const Board& other) const;
  33   bool operator!=(const Board& other) const;
  34
  35   /**
  36     * \return Board size.
  37     */
  38   Point size() const;
  39
  40   /**
  41     * Retrieve a piece from the board.
  42     * \param p Coordinates of the piece.
  43     * \return The piece at that square, or an invalid piece, if the square is out of the board.
  44     */
  45   Piece get(const Point& p) const;
  46
  47   /**
  48     * Add a piece to the board.
  49     * \param p Coordinates of the piece.
  50     * \param piece The piece to add.
  51     * \note This function does nothing if @a p is out of the board.
  52     */
  53   void set(const Point& p, const Piece& piece);
  54
  55   /**
  56     * \return Whether @a p is a valid board square.
  57     */
  58   bool valid(const Point& p) const;
  59
  60   /**
  61     * \return Information on the path joining @a from and @a to.
  62     */
  63   PathInfo path(const Point& from, const Point& to) const;
  64 };
  65
  66 // IMPLEMENTATION
  67
  68 template <typename Piece>
  69 Board<Piece>::Board(const Point& size)
  70 : m_size(size) {
  71   m_data.resize(m_size.x * m_size.y);
  72 }
  73
  74 template <typename Piece>
  75 Board<Piece>::Board(const Board<Piece>& other)
  76 : m_size(other.m_size)
  77 , m_data(other.m_data) { }
  78
  79 template <typename Piece>
  80 bool Board<Piece>::operator==(const Board<Piece>& other) const {
  81   if (m_size != other.m_size)
  82     return false;
  83
  84   const unsigned int total = m_data.size();
  85   for (unsigned int i = 0; i < total; i++) {
  86     if (m_data[i] != other.m_data[i])
  87       return false;
  88   }
  89
  90   return true;
  91 }
  92
  93 template <typename Piece>
  94 bool Board<Piece>::operator!=(const Board<Piece>& other) const {
  95   return !((*this) == other);
  96 }
  97
  98 template <typename Piece>
  99 Point Board<Piece>::size() const { return m_size; }
 100
 101 template <typename Piece>
 102 Piece Board<Piece>::get(const Point& p) const {
 103   if (valid(p)) {
 104     return m_data[p.x + p.y * m_size.x];
 105   }
 106   else {
 107     return Piece();
 108   }
 109 }
 110
 111 template <typename Piece>
 112 void Board<Piece>::set(const Point& p, const Piece& piece) {
 113   if (valid(p)) {
 114     m_data[p.x + p.y * m_size.x] = piece;
 115   }
 116 }
 117
 118 template <typename Piece>
 119 bool Board<Piece>::valid(const Point& p) const {
 120   return p.x < m_size.x &&
 121          p.x >= 0       &&
 122          p.y < m_size.y &&
 123          p.y >= 0;
 124 }
 125
 126 template <typename Piece>
 127 PathInfo Board<Piece>::path(const Point& from, const Point& to) const {
 128   if (!valid(from) || !valid(to))
 129     return PathInfo(PathInfo::Undefined, 0);
 130
 131   Point delta = to - from;
 132   PathInfo::Direction direction;
 133
 134   if (delta.x == 0)
 135     direction = PathInfo::Vertical;
 136   else if (delta.y == 0)
 137     direction = PathInfo::Horizontal;
 138   else if (delta.x == delta.y)
 139     direction = PathInfo::Diagonal1;
 140   else if (delta.x == -delta.y)
 141     direction = PathInfo::Diagonal2;
 142   else
 143     direction = PathInfo::Undefined;
 144
 145   int num_obs = 0;
 146   if (direction != PathInfo::Undefined) {
 147     Point step = delta.normalizeInfinity();
 148     Point position = from;
 149     while ((position += step) != to) {
 150       if (get(position) == Piece())
 151         continue;
 152       num_obs++;
 153     }
 154   }
 155
 156   return PathInfo(direction, num_obs);
 157 }
 158
 159 }
 160
 161 #endif // HLVARIANT__BOARD_H