src/game.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 GAME_H
  18 #define GAME_H
  19
  20 #include <string>
  21
  22 #include "pieces.h"
  23 #include "board.h"
  24 #include "moves.h"
  25 #include "tt.h"
  26 #include "hashtable.h"
  27 #include "time.h"
  28 #include "tree.h"
  29 #include "zobrist.h"
  30 #include "search.h"
  31
  32 class Position;
  33
  34 class Game
  35 {
  36     private:
  37         Zobrist zobrist;
  38         Move killer_moves[MAX_PLY][MAX_KILLERS];
  39         HashTable<int> material_table;
  40
  41     public:
  42         bool output_thinking;
  43         unsigned int nodes_count; // Used in search
  44         Pieces pieces;
  45         Board board;
  46         Tree tree;
  47         Time time;
  48         Transpositions tt;
  49         MoveList search_moves;
  50         Game();
  51         void add_piece(Color c, PieceType t, Square s);
  52         void del_piece(Color c, PieceType t, int i);
  53         void del_piece(Piece p) {
  54             del_piece(p.color(), p.type(), p.index());
  55         };
  56
  57         void new_position();
  58         void del_position();
  59         Position& current_position() {
  60             return tree.top();
  61         };
  62
  63         void init(std::string fen);
  64
  65         bool is_check(Color c) const {
  66             Square s = pieces.position(c, KING, 0);
  67             return board.is_attacked_by(!c, s, pieces);
  68         }
  69
  70         void make_move(Move m);
  71         void undo_move(Move m);
  72         bool is_legal(Move m);
  73         bool is_dangerous(Move m);
  74
  75         // Search
  76         unsigned long long int perft(unsigned int depth);
  77
  78         int quiescence(int alpha, int beta, int depth, const int ply);
  79
  80         template<NodeType node_type>
  81         int search(int alpha, int beta, int depth, const int ply);
  82
  83         Move root(int max_depth);
  84
  85         // Killer Moves
  86         void clear_killers();
  87         Move get_killer_move(int depth, int index) {
  88             return killer_moves[depth][index];
  89         }
  90         void set_killer_move(int depth, Move move);
  91         bool is_killer_move(int depth, Move move) {
  92             return (move == killer_moves[depth][0] ||
  93                     move == killer_moves[depth][1]);
  94         };
  95
  96         // Position's evaluation
  97         void init_eval();
  98         int eval(int alpha, int beta);
  99         int material_eval();
 100         int position_eval();
 101
 102         // Output
 103         void print_thinking_header();
 104         void print_thinking(int depth, int score, Move m);
 105         std::string output_pv(int depth, int score, Move m);
 106         std::string output_move(Move m);
 107         std::string output_square(Square s) {
 108             return output_square(board.file(s), board.rank(s));
 109         };
 110         std::string output_square(File f, Rank r);
 111         void print_tt_stats();
 112         std::string debug_move(Move m);
 113 };
 114
 115 #endif /* !GAME_H */