src/protocol.cpp

   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 #include <assert.h>
  18 #include <iostream>
  19
  20 #include "protocol.h"
  21
  22 void Protocol::new_game()
  23 {
  24     game.tt.clear();
  25     game.clear_killers();
  26     game.search_moves.clear();
  27 }
  28
  29 bool Protocol::set_board(std::string fen)
  30 {
  31     // TODO Test if fen is valid?
  32
  33     // Load fen
  34     game.init(fen);
  35
  36     return true;
  37 }
  38
  39 /*
  40  * Set time control:
  41  * 'n' moves in 't' time with time in seconds.
  42  */
  43 bool Protocol::set_time(int moves, int time)
  44 {
  45     game.time = Time(moves, time * 100);
  46     return true;
  47 }
  48
  49 bool Protocol::set_remaining_time(int time)
  50 {
  51     game.time.set_remaining_time(time);
  52     return true;
  53 }
  54
  55 bool Protocol::set_output_thinking(bool ot)
  56 {
  57     game.output_thinking = ot;
  58     return true;
  59 }
  60
  61 Move Protocol::parse_move(std::string move)
  62 {
  63     Square from = Square(move[0] - 'a' + 16 * (move[1] - '1'));
  64     Square to = Square(move[2] - 'a' + 16 * (move[3] - '1'));
  65     if (game.board.is_out(from) || game.board.is_out(to)) return Move();
  66     Color c = game.current_position().get_turn_color();
  67     MoveType t = QUIET_MOVE;
  68
  69     if (move.size() == 5) { // Promotion
  70         switch (move[4]) {
  71             case 'n': t = KNIGHT_PROMOTION; break;
  72             case 'b': t = BISHOP_PROMOTION; break;
  73             case 'r': t = ROOK_PROMOTION; break;
  74             case 'q': t = QUEEN_PROMOTION; break;
  75             default: return Move();
  76         }
  77     }
  78     if (game.board[from].type() == PAWN) {
  79         if (game.board.is_pawn_begin(c, from) &&
  80             to == Square(from + 2 * PAWN_PUSH_DIRS[c])) {
  81                 return Move(from, to, DOUBLE_PAWN_PUSH);
  82         } else if (game.board.is_empty(to) &&
  83             to != Square(from + PAWN_PUSH_DIRS[c])) {
  84                 return Move(from, to, EN_PASSANT);
  85         }
  86     }
  87     if (game.board[from].type() == KING) {
  88         if (to == Square(from + RIGHT + RIGHT)) {
  89             return Move(from, to, KING_CASTLE);
  90         } else if (to == Square(from + LEFT + LEFT)) {
  91             return Move(from, to, QUEEN_CASTLE);
  92         }
  93     }
  94
  95     // Capture
  96     if (!game.board.is_empty(to)) {
  97         assert((t == QUIET_MOVE) ||
  98                (KNIGHT_PROMOTION <= t && t <= QUEEN_PROMOTION));
  99         return Move(from, to, static_cast<MoveType>(t + CAPTURE));
 100     } else {
 101         return Move(from, to, t);
 102     }
 103 }
 104
 105 bool Protocol::play_move(std::string move)
 106 {
 107     // Parse move
 108     Move m = parse_move(move);
 109
 110     // Test legality
 111     if (!game.is_legal(m)) return false;
 112
 113     // Play move
 114     game.make_move(m);
 115
 116     // Put move to history
 117     history.push(m);
 118
 119     return true;
 120 }
 121
 122 bool Protocol::undo_move()
 123 {
 124     if (history.empty()) return false;
 125     Move m = history.top();
 126     history.pop();
 127
 128     // Undo move
 129     game.undo_move(m);
 130     return true;
 131 }
 132
 133 std::string Protocol::search_move(bool use_san_notation)
 134 {
 135     Move m = game.root(depth + 1);
 136     if (m.is_null()) {
 137         if (game.is_check(game.current_position().get_turn_color())) {
 138             return "LOST";
 139         }
 140         return "DRAW";
 141     } else {
 142         if (use_san_notation) {
 143             std::string res = game.output_move(m);
 144             play_move(m.to_string());
 145             if (game.is_check(game.current_position().get_turn_color())) {
 146                 res += "+";
 147             }
 148             undo_move();
 149             return res;
 150         }
 151         return m.to_string();
 152     }
 153 }