src/hlvariant/shogi/gamestate.h

   1 /*
   2   Copyright (c) 2007 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2007 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #ifndef HLVARIANT__SHOGI__GAMESTATE_H
  12 #define HLVARIANT__SHOGI__GAMESTATE_H
  13
  14 #include "../crazyhouse/gamestate.h"
  15 #include "../pool.h"
  16 #include "../poolcollection.h"
  17
  18 namespace HLVariant {
  19 namespace Shogi {
  20
  21 template <typename _Board, typename _Move>
  22 class GameState {
  23 public:
  24   typedef _Board Board;
  25   typedef _Move Move;
  26   typedef typename Board::Piece Piece;
  27   typedef Pool<Piece> Pool;
  28   typedef PoolCollection<Pool> Pools;
  29 private:
  30   Board m_board;
  31   Pools m_pools;
  32   typename Piece::Color m_turn;
  33 public:
  34   GameState();
  35   virtual ~GameState();
  36
  37   virtual Board& board();
  38   virtual const Board& board() const;
  39
  40   virtual Pools& pools();
  41   virtual const Pools& pools() const;
  42
  43   virtual void setup();
  44
  45   virtual bool operator==(const GameState<Board, Move>& other) const;
  46
  47   virtual void move(const Move& m);
  48   virtual void basicMove(const Move& m);
  49   virtual void captureOn(const Point& p);
  50   virtual bool promotionZone(typename Piece::Color player, const Point& p) const;
  51
  52   virtual void setTurn(typename Piece::Color color);
  53   virtual typename Piece::Color previousTurn() const;
  54   virtual void switchTurn();
  55   virtual typename Piece::Color turn() const;
  56
  57   virtual int startingRank(typename Piece::Color color) const;
  58   virtual int promotionRank(typename Piece::Color color) const;
  59   virtual Point kingStartingPosition(typename Piece::Color color) const;
  60   virtual Point direction(typename Piece::Color color) const;
  61 };
  62
  63 // IMPLEMENTATION
  64
  65 template <typename Board, typename Move>
  66 GameState<Board, Move>::GameState()
  67 : m_turn(Piece::BLACK) { }
  68
  69 template <typename Board, typename Move>
  70 GameState<Board, Move>::~GameState() { }
  71
  72 template <typename Board, typename Move>
  73 Board& GameState<Board, Move>::board() { return m_board; }
  74
  75 template <typename Board, typename Move>
  76 const Board& GameState<Board, Move>::board() const { return m_board; }
  77
  78 template <typename Board, typename Move>
  79 typename GameState<Board, Move>::Pools& GameState<Board, Move>::pools() { return m_pools; }
  80
  81 template <typename Board, typename Move>
  82 const typename GameState<Board, Move>::Pools& GameState<Board, Move>::pools() const { return m_pools; }
  83
  84 #define COL(i, c) c == Piece::BLACK ? (i) : (m_board.size().x - i - 1)
  85 template <typename Board, typename Move>
  86 void GameState<Board, Move>::setup() {
  87   for (int c = 0; c < 2; c++) {
  88     typename Piece::Color color = static_cast<typename Piece::Color>(c);
  89     int rank = startingRank(color);
  90     for (int i = 0; i < m_board.size().x; i++) {
  91       m_board.set(Point(i, rank + direction(color).y * 2),
  92                   Piece(color, Piece::PAWN));
  93     }
  94     m_board.set(Point(0, rank), Piece(color, Piece::LANCE));
  95     m_board.set(Point(1, rank), Piece(color, Piece::KNIGHT));
  96     m_board.set(Point(2, rank), Piece(color, Piece::SILVER));
  97     m_board.set(Point(3, rank), Piece(color, Piece::GOLD));
  98     m_board.set(Point(4, rank), Piece(color, Piece::KING));
  99     m_board.set(Point(5, rank), Piece(color, Piece::GOLD));
 100     m_board.set(Point(6, rank), Piece(color, Piece::SILVER));
 101     m_board.set(Point(7, rank), Piece(color, Piece::KNIGHT));
 102     m_board.set(Point(8, rank), Piece(color, Piece::LANCE));
 103
 104     m_board.set(Point(COL(1, c), rank + direction(color).y),
 105       Piece(color, Piece::ROOK));
 106     m_board.set(Point(COL(7, c), rank + direction(color).y),
 107       Piece(color, Piece::BISHOP));
 108   }
 109 }
 110 #undef COL
 111
 112 template <typename Board, typename Move>
 113 bool GameState<Board, Move>::promotionZone(typename Piece::Color player, const Point& p) const {
 114   return player == Piece::WHITE ? p.y >= 6 : p.y <= 2;
 115 }
 116
 117 template <typename Board, typename Move>
 118 bool GameState<Board, Move>::operator==(const GameState<Board, Move>& other) const {
 119   return m_turn == other.m_turn &&
 120     m_board == other.m_board;
 121 }
 122
 123 template <typename Board, typename Move>
 124 void GameState<Board, Move>::move(const Move& m) {
 125   if (m.drop() == Piece()) {
 126     captureOn(m.to());
 127     basicMove(m);
 128
 129     if (m.promoteTo() != -1) {
 130       Piece piece = m_board.get(m.to());
 131       piece.setPromoted();
 132       m_board.set(m.to(), piece);
 133     }
 134   }
 135   else {
 136     m_board.set(m.to(), m.drop());
 137     m_pools.pool(m.drop().color()).remove(m.drop().type());
 138   }
 139
 140   switchTurn();
 141 }
 142
 143 template <typename Board, typename Move>
 144 void GameState<Board, Move>::captureOn(const Point& p) {
 145   Piece captured = m_board.get(p);
 146   m_board.set(p, Piece());
 147   m_pools.pool(captured.color()).add(captured.type());
 148 }
 149
 150 template <typename Board, typename Move>
 151 void GameState<Board, Move>::basicMove(const Move& m) {
 152   if (m.from() != m.to()) {
 153     m_board.set(m.to(), m_board.get(m.from()));
 154     m_board.set(m.from(), Piece());
 155   }
 156 }
 157
 158 template <typename Board, typename Move>
 159 void GameState<Board, Move>::switchTurn() {
 160   m_turn = Piece::oppositeColor(m_turn);
 161 }
 162
 163 template <typename Board, typename Move>
 164 typename Board::Piece::Color GameState<Board, Move>::turn() const {
 165   return m_turn;
 166 }
 167
 168 template <typename Board, typename Move>
 169 typename Board::Piece::Color GameState<Board, Move>::previousTurn() const {
 170   return Piece::oppositeColor(m_turn);
 171 }
 172
 173 template <typename Board, typename Move>
 174 void GameState<Board, Move>::setTurn(typename Piece::Color color) {
 175   m_turn = color;
 176 }
 177
 178 template <typename Board, typename Move>
 179 int GameState<Board, Move>::startingRank(typename Piece::Color color) const {
 180   return color == Piece::BLACK ? m_board.size().y - 1 : 0;
 181 }
 182
 183 template <typename Board, typename Move>
 184 int GameState<Board, Move>::promotionRank(typename Piece::Color color) const {
 185   return startingRank(Piece::oppositeColor(color));
 186 }
 187
 188 template <typename Board, typename Move>
 189 Point GameState<Board, Move>::kingStartingPosition(typename Piece::Color color) const {
 190   return Point(4, startingRank(color));
 191 }
 192
 193 template <typename Board, typename Move>
 194 Point GameState<Board, Move>::direction(typename Piece::Color color) const {
 195   return Point(0, color == Piece::BLACK ? -1 : 1);
 196 }
 197
 198
 199 } // namespace Shogi
 200 } // namespace HLVariant
 201
 202 #endif // HLVARIANT__SHOGI__GAMESTATE_H