src/position.h

   1 /* Copyright (C) 2007-2011 Vincent Ollivier
   2  *
   3  * Purple Haze is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * Purple Haze is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #ifndef NODE_H
  18 #define NODE_H
  19
  20 #include <bitset>
  21
  22 #include "common.h"
  23 #include "piece.h"
  24 #include "zobrist.h"
  25
  26 class Position
  27 {
  28     private:
  29         Hash zobrist_hash;
  30         Hash material_zobrist_hash;
  31         Piece captured_piece;
  32         std::bitset<4> castle_rights;
  33         std::bitset<2> castled;
  34         Square en_passant_square;
  35         unsigned char halfmove_counter;
  36         bool null_move_right;
  37         Color side_to_move;
  38
  39     public:
  40         Position() :
  41             en_passant_square(OUT),
  42             halfmove_counter(0),
  43             null_move_right(true),
  44             side_to_move(WHITE)
  45             {}
  46
  47         Hash& hash() {
  48             return zobrist_hash;
  49         };
  50         Hash& material_hash() {
  51             return material_zobrist_hash;
  52         };
  53         Color turn_color() const {
  54             return side_to_move;
  55         };
  56         void change_side() {
  57             side_to_move = !side_to_move;
  58         };
  59         unsigned char halfmove() const {
  60             return halfmove_counter;
  61         };
  62         void set_halfmove(unsigned char i) {
  63             halfmove_counter = i;
  64         };
  65         void inc_halfmove() {
  66             ++halfmove_counter;
  67         };
  68         void reset_halfmove() {
  69             halfmove_counter = 0;
  70         };
  71         Square en_passant() const {
  72             return en_passant_square;
  73         };
  74         void set_en_passant(Square ep) {
  75             en_passant_square = ep;
  76         };
  77         Piece capture() const {
  78             return captured_piece;
  79         };
  80         void set_capture(Piece p) {
  81             captured_piece = p;
  82         };
  83         bool can_null_move() const {
  84             return null_move_right;
  85         };
  86         void set_null_move_right(bool b) {
  87             null_move_right = b;
  88         };
  89         bool can_castle(Color c, PieceType t) const {
  90             return castle_rights[2 * c + t - QUEEN];
  91         };
  92         void set_castle_right(Color c, PieceType t, bool b = true) {
  93             castle_rights.set(2 * c + t - QUEEN, b);
  94         };
  95         bool has_castled(Color c) const {
  96             return castled[c];
  97         };
  98         void set_has_castled(Color c, bool b = true) {
  99             castled.set(c, b);
 100         };
 101 };
 102
 103 #endif /* !NODE_H */