Subversion Repositories Games.Chess Giants

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
99 pmbaty 1 
/*
2 
    Texel - A UCI chess engine.
3 
    Copyright (C) 2012-2013  Peter Österlund, peterosterlund2@gmail.com
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 3 of the License, or
8 
    (at your option) any later version.
9 
 
10 
    This program is distributed in the hope that it will be useful,
11 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
12 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 
    GNU General Public License for more details.
14 
 
15 
    You should have received a copy of the GNU General Public License
16 
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 
*/
18 
 
19 
/*
20 
 * game.hpp
21 
 *
22 
 *  Created on: Feb 25, 2012
23 
 *      Author: petero
24 
 */
25 
 
26 
#ifndef GAME_HPP_
27 
#define GAME_HPP_
28 
 
29 
#include "move.hpp"
30 
#include "undoInfo.hpp"
31 
#include "position.hpp"
32 
#include "player.hpp"
33 
 
34 
#include <vector>
35 
#include <string>
36 
#include <memory>
37 
 
38 
class GameTest;
39 
 
40 
/**
41 
 * Handles a game between two players.
42 
 */
43 
class Game {
44 
    friend class GameTest;
45 
public:
46 
    Game(const std::shared_ptr<Player>& whitePlayer,
47 
         const std::shared_ptr<Player>& blackPlayer);
48 
    virtual ~Game();
49 
    Game(const Game& other) = delete;
50 
    Game& operator=(const Game& other) = delete;
51 
 
52 
    /**
53 
     * Update the game state according to move/command string from a player.
54 
     * @param str The move or command to process.
55 
     * @return True if str was understood, false otherwise.
56 
     */
57 
    bool processString(const std::string& str);
58 
 
59 
    std::string getGameStateString();
60 
 
61 
    const Position& getPos() const;
62 
 
63 
    /**
64 
     * Get the last played move, or null if no moves played yet.
65 
     */
66 
    Move getLastMove();
67 
 
68 
    enum GameState {
69 
        ALIVE,
70 
        WHITE_MATE,         // White mates
71 
        BLACK_MATE,         // Black mates
72 
        WHITE_STALEMATE,    // White is stalemated
73 
        BLACK_STALEMATE,    // Black is stalemated
74 
        DRAW_REP,           // Draw by 3-fold repetition
75 
        DRAW_50,            // Draw by 50 move rule
76 
        DRAW_NO_MATE,       // Draw by impossibility of check mate
77 
        DRAW_AGREE,         // Draw by agreement
78 
        RESIGN_WHITE,       // White resigns
79 
        RESIGN_BLACK        // Black resigns
80 
    };
81 
 
82 
    /**
83 
     * Get the current state of the game.
84 
     */
85 
    GameState getGameState();
86 
 
87 
    /**
88 
     * Check if a draw offer is available.
89 
     * @return True if the current player has the option to accept a draw offer.
90 
     */
91 
    bool haveDrawOffer();
92 
 
93 
    void getPosHistory(std::vector<std::string> ret);
94 
 
95 
    std::string getMoveListString(bool compressed);
96 
 
97 
    std::string getPGNResultString();
98 
 
99 
    /** Return a list of previous positions in this game, back to the last "zeroing" move. */
100 
    void getHistory(std::vector<Position>& posList);
101 
 
102 
protected:
103 
    /**
104 
     * Handle a special command.
105 
     * @param moveStr  The command to handle
106 
     * @return  True if command handled, false otherwise.
107 
     */
108 
    virtual bool handleCommand(const std::string& moveStr);
109 
 
110 
    /** Swap players around if needed to make the human player in control of the next move. */
111 
    void activateHumanPlayer();
112 
 
113 
 
114 
    std::shared_ptr<Player> whitePlayer;
115 
    std::shared_ptr<Player> blackPlayer;
116 
    std::vector<Move> moveList;
117 
    std::vector<UndoInfo> uiInfoList;
118 
    std::vector<bool> drawOfferList;
119 
    int currentMove;
120 
 
121 
private:
122 
    /** Print a list of all moves. */
123 
    void listMoves();
124 
 
125 
    bool handleDrawCmd(std::string drawCmd);
126 
 
127 
    bool handleBookCmd(const std::string& bookCmd);
128 
 
129 
    bool insufficientMaterial();
130 
 
131 
    /** Compute PerfT value. */
132 
    static U64 perfT(Position& pos, int depth);
133 
 
134 
    Position pos;
135 
 
136 
    std::string drawStateMoveStr; // Move required to claim DRAW_REP or DRAW_50
137 
    GameState resignState;
138 
    bool pendingDrawOffer;
139 
    GameState drawState;
140 
 
141 
};
142 
 
143 
inline
144 
Game::~Game() {
145 
}
146 
 
147 
inline const Position& Game::getPos() const {
148 
    return pos;
149 
}
150 
 
151 
#endif /* GAME_HPP_ */