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 "pieces.h"
  24 #include "move.h"
  25 #include "zobrist.h"
  26
  27 class Position
  28 {
  29     private:
  30         Hash zobrist_hash;
  31         Hash material_zobrist_hash;
  32         unsigned short ply;
  33         Piece capture;
  34         std::bitset<4> castle_rights;
  35         std::bitset<2> castle;
  36         Square en_passant;
  37         unsigned char halfmove_counter;
  38         bool null_move_right;
  39         Color side_to_move;
  40
  41     public:
  42         Position() :
  43             ply(0),
  44             en_passant(OUT),
  45             halfmove_counter(0),
  46             null_move_right(true),
  47             side_to_move(WHITE)
  48             {}
  49
  50         Hash& hash() {
  51             return zobrist_hash;
  52         };
  53         Hash& material_hash() {
  54             return material_zobrist_hash;
  55         };
  56         Color get_turn_color() const {
  57             return side_to_move;
  58         };
  59         void change_side() {
  60             side_to_move = !side_to_move;
  61         };
  62         unsigned short get_ply() const {
  63             return ply;
  64         };
  65         void set_ply(unsigned short i) {
  66             ply = i;
  67         };
  68         void inc_ply() {
  69             ++ply;
  70         };
  71         void dec_ply() {
  72             --ply;
  73         };
  74         unsigned char get_halfmove() const {
  75             return halfmove_counter;
  76         };
  77         void set_halfmove(unsigned char i) {
  78             halfmove_counter = i;
  79         };
  80         void inc_halfmove() {
  81             ++halfmove_counter;
  82         };
  83         void reset_halfmove() {
  84             halfmove_counter = 0;
  85         };
  86         Square get_en_passant() const {
  87             return en_passant;
  88         };
  89         void set_en_passant(Square ep) {
  90             en_passant = ep;
  91         };
  92         Piece get_capture() const {
  93             return capture;
  94         };
  95         void set_capture(Piece p) {
  96             capture = p;
  97         };
  98         bool can_castle(Color c, PieceType t) const {
  99             return castle_rights[2 * c + t - QUEEN];
 100         };
 101         void set_castle_right(Color c, PieceType t, bool b = true) {
 102             castle_rights.set(2 * c + t - QUEEN, b);
 103         };
 104         bool has_castle(Color c) const {
 105             return castle[c];
 106         };
 107         void set_has_castle(Color c, bool b = true) {
 108             castle.set(c, b);
 109         };
 110         bool get_null_move_right() const {
 111             return null_move_right;
 112         };
 113         void set_null_move_right(bool b) {
 114             null_move_right = b;
 115         };
 116 };
 117
 118 #endif /* !NODE_H */