chessplayer.h

/*
    This file is part of Cute Chess.
    Copyright (C) 2008-2018 Cute Chess authors

    Cute Chess 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 3 of the License, or
    (at your option) any later version.

    Cute Chess 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 Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef CHESSPLAYER_H
#define CHESSPLAYER_H

#include <QObject>
#include <QString>
#include <QVector>
#include "board/result.h"
#include "board/move.h"
#include "timecontrol.h"
#include "moveevaluation.h"
class QTimer;
namespace Chess { class Board; }


class LIB_EXPORT ChessPlayer : public QObject
{
    Q_OBJECT

    public:
        enum State
        {
            NotStarted, 
            Starting,   
            Idle,       
            Observing,  
            Thinking,   
            FinishingGame,  
            Disconnected    
        };

        ChessPlayer(QObject* parent = nullptr);
        virtual ~ChessPlayer();
        
        virtual bool isReady() const;

        State state() const;

        bool hasError() const;
        QString errorString() const;

        void newGame(Chess::Side side,
                 ChessPlayer* opponent,
                 Chess::Board* board);
        
        virtual void endGame(const Chess::Result& result);
        
        const MoveEvaluation& evaluation() const;

        const TimeControl* timeControl() const;

        void setTimeControl(const TimeControl& timeControl);

        void addTime(int bonus);

        Chess::Side side() const;

        virtual void makeMove(const Chess::Move& move) = 0;
        
        virtual void makeBookMove(const Chess::Move& move);
        
        QString name() const;
        
        void setName(const QString& name);

        virtual bool supportsVariant(const QString& variant) const = 0;

        virtual void startPondering();

        virtual void clearPonderState();

        virtual bool isHuman() const = 0;

        bool areClaimsValidated() const;
        void setClaimsValidated(bool validate);

        void setCanPlayAfterTimeout(bool enable);


    public slots:
        virtual void go();

        virtual void quit();

        virtual void kill();

    signals:
        void disconnected();

        void ready();
        
        void startedThinking(int timeLeft);

        void stoppedThinking();

        void thinking(const MoveEvaluation& eval);

        void moveMade(const Chess::Move& move);
        
        void resultClaim(const Chess::Result& result);

        void debugMessage(const QString& data);

        void nameChanged(const QString& name);

    protected slots:
        virtual void onCrashed();

        virtual void onTimeout();

    protected:
        Chess::Board* board();

        virtual void startGame() = 0;

        virtual void startThinking() = 0;

        virtual bool canPlayAfterTimeout() const;

        void claimResult(const Chess::Result& result);
        void forfeit(Chess::Result::Type type,
                 const QString& description = QString());

        void emitMove(const Chess::Move& move);
        
        const ChessPlayer* opponent() const;

        void setState(State state);

        void setError(const QString& error);
        
        MoveEvaluation m_eval;

    private:
        void startClock();

        QString m_name;
        QString m_error;
        State m_state;
        TimeControl m_timeControl;
        QTimer* m_timer;
        bool m_claimedResult;
        bool m_validateClaims;
        bool m_canPlayAfterTimeout;
        Chess::Side m_side;
        Chess::Board* m_board;
        ChessPlayer* m_opponent;
};

#endif // CHESSPLAYER_H