game.h

Go to the documentation of this file.

/*
    Copyright 2008 Sascha Peilicke <sasch.pe@gmx.de>

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef KIGO_GAME_H
#define KIGO_GAME_H

#include "move.h"
#include "player.h"
#include "stone.h"

#include <QList>
#include <QProcess>
#include <QString>
#include <QUndoStack>

namespace Kigo {

class Score;

class Game : public QObject
{
    Q_OBJECT

public:
    enum FinalState {
        FinalAlive = 1,         
        FinalDead,              
        FinalSeki,              
        FinalWhiteTerritory,    
        FinalBlackTerritory,    
        FinalDame,              
        FinalStateInvalid       
    };

    explicit Game(QObject *parent = 0);
    ~Game();

    bool start(const QString &command = "gnugo --mode gtp");

    void stop();

    bool isRunning() const { return m_process.state() == QProcess::Running; }
    QString engineName() const { return m_engineName; }
    QString engineVersion() const { return m_engineVersion; }
    QString engineCommand() const { return m_engineCommand; }
    QUndoStack *undoStack() { return &m_undoStack; }

    bool init();

    bool init(const QString &fileName, int moveNumber = 0);

    bool save(const QString &fileName);

    bool setBoardSize(int size);
    int boardSize() const { return m_boardSize; }

    bool setKomi(float komi);
    float komi() const { return m_komi; }

    bool setFixedHandicap(int handicap);
    int fixedHandicap() const { return m_fixedHandicap; }

    int fixedHandicapUpperBound();

    Player &currentPlayer() { return *m_currentPlayer; }
    const Player &currentPlayer() const { return *m_currentPlayer; }
    Player &whitePlayer() { return m_whitePlayer; }
    const Player &whitePlayer() const { return m_whitePlayer; }
    Player &blackPlayer() { return m_blackPlayer; }
    const Player &blackPlayer() const { return m_blackPlayer; }

    bool playMove(const Move &move, bool undoable = true);
    bool playMove(const Player &player, const Stone &stone = Stone(), bool undoable = true);
    bool generateMove(const Player &player, bool undoable = true);
    bool undoMove();
    bool redoMove();

    int currentMoveNumber() const { return m_currentMove; }

    Move lastMove() const;

    int moveCount();

    QList<Stone> stones(const Player &player);

    QList<Move> moves(const Player &player);
    QList<Move> moves() { return m_movesList; }

    QList<Stone> liberties(const Stone &field);

    QList<Stone> bestMoves(const Player &player);

    QList<Stone> legalMoves(const Player &player);

    int captures(const Player &player);

    FinalState finalState(const Stone &field);

    QList<Stone> finalStates(FinalState state);

    Score finalScore();

    Score estimatedScore();

    bool canRedo() const { return m_undoStack.canRedo(); }
    bool canUndo() const { return m_undoStack.canUndo(); }

    bool isFinished() const { return m_gameFinished; }

signals:
    void boardInitialized();

    void boardChanged();

    void boardSizeChanged(int);

    void resigned(const Player &);

    void passMovePlayed(const Player &);
    void consecutivePassMovesPlayed(int);

    void currentPlayerChanged(const Player &);

    void waiting(bool);

    void canRedoChanged(bool);

    void canUndoChanged(bool);

public slots:
    void gameSetup();
    
private slots:
    bool waitResponse(bool nonBlocking = false);

    void readyRead();

    void undoIndexChanged(int index);

private:
    void setCurrentPlayer(Player &player);

    QProcess m_process;

    QString m_engineName;
    QString m_engineVersion;
    QString m_engineCommand;
    QString m_response;

    QList<Move> m_movesList;
    int m_currentMove;
    QUndoStack m_undoStack;
    int m_lastUndoIndex;

    Player *m_currentPlayer;
    Player m_blackPlayer;
    Player m_whitePlayer;

    float m_komi;
    int m_boardSize;
    int m_fixedHandicap;
    int m_consecutivePassMoveNumber;
    bool m_waitAndProcessEvents;
    bool m_gameFinished;
};

} // End of namespace Kigo

#endif