tournament.h

/*
    This file is part of Cute Chess.

    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 TOURNAMENT_H
#define TOURNAMENT_H

#include <QObject>
#include <QList>
#include <QVector>
#include <QMap>
#include <QFile>
#include <QTextStream>
#include "board/move.h"
#include "timecontrol.h"
#include "pgngame.h"
#include "gameadjudicator.h"
#include "tournamentplayer.h"
#include "tournamentpair.h"
class GameManager;
class PlayerBuilder;
class ChessGame;
class OpeningBook;
class OpeningSuite;
class Sprt;

class LIB_EXPORT Tournament : public QObject
{
    Q_OBJECT

    public:
        enum OpeningPolicy
        {
            DefaultPolicy,     
            EncounterPolicy,   
            RoundPolicy        
        };

        Tournament(GameManager* gameManager, QObject *parent);
        virtual ~Tournament();

        virtual QString type() const = 0;
        GameManager* gameManager() const;
        bool isFinished() const;
        QString errorString() const;
        QString name() const;
        QString site() const;
        QString variant() const;
        int currentRound() const;
        int gamesPerEncounter() const;
        int roundMultiplier() const;
        int finishedGameCount() const;
        int finalGameCount() const;
        const TournamentPlayer& playerAt(int index) const;
        int playerCount() const;
        int seedCount() const;
        Sprt* sprt() const;

        void setName(const QString& name);
        void setSite(const QString& site);
        void setVariant(const QString& variant);
        void setGamesPerEncounter(int count);
        virtual bool canSetRoundMultiplier() const;
        void setRoundMultiplier(int factor);
        void setStartDelay(int delay);
        void setRecoveryMode(bool recover);
        void setAdjudicator(const GameAdjudicator& adjudicator);
        void setOpeningSuite(OpeningSuite* suite);
        void setOpeningDepth(int plies);
        void setPgnOutput(const QString& fileName,
                  PgnGame::PgnMode mode = PgnGame::Verbose);

        void setPgnWriteUnfinishedGames(bool enabled);

        void setPgnCleanupEnabled(bool enabled);

        void setEpdOutput(const QString& fileName);

        void setOpeningRepetitions(int count);
        void setOpeningPolicy(OpeningPolicy policy = DefaultPolicy);
        void setSwapSides(bool enabled);
        void setOpeningBookOwnership(bool enabled);
        void setSeedCount(int seedCount);
        void addPlayer(PlayerBuilder* builder,
                   const TimeControl& timeControl,
                   const OpeningBook* book = nullptr,
                   int bookDepth = 256);
        virtual QString results() const;

    public slots:
        void start();
        void stop();

    signals:
        void gameStarted(ChessGame* game,
                 int number,
                 int whiteIndex,
                 int blackIndex);
        void gameFinished(ChessGame* game,
                  int number,
                  int whiteIndex,
                  int blackIndex);
        void finished();

    protected:
        void setCurrentRound(int round);
        int gamesInProgress() const;
        TournamentPair* currentPair() const;
        TournamentPair* pair(int player1, int player2);
        void startGame(TournamentPair* pair);
        virtual void onGameAboutToStart(ChessGame* game,
                        const PlayerBuilder* white,
                        const PlayerBuilder* black);
        int playerIndex(ChessGame* game, Chess::Side side) const;
        virtual void initializePairing() = 0;
        virtual int gamesPerCycle() const = 0;
        virtual TournamentPair* nextPair(int gameNumber) = 0;
        virtual void onFinished();
        virtual void addScore(int player, int score);
        virtual bool areAllGamesFinished() const;
        virtual bool hasGauntletRatingsOrder() const;

    private slots:
        void startNextGame();
        bool writePgn(PgnGame* pgn, int gameNumber);
        bool writeEpd(ChessGame* game);
        void onGameStarted(ChessGame* game);
        void onGameFinished(ChessGame* game);
        void onGameDestroyed(ChessGame* game);
        void onGameStartFailed(ChessGame* game);

    private:
        struct GameData
        {
            int number;
            int whiteIndex;
            int blackIndex;
        };
        struct RankingData
        {
            QString name;
            int games;
            qreal score;
            qreal draws;
            qreal errorMargin;
            qreal eloDiff;
        };

        GameManager* m_gameManager;
        ChessGame* m_lastGame;
        QString m_error;
        QString m_name;
        QString m_site;
        QString m_variant;
        int m_round;
        int m_oldRound;
        int m_nextGameNumber;
        int m_finishedGameCount;
        int m_savedGameCount;
        int m_finalGameCount;
        int m_gamesPerEncounter;
        int m_roundMultiplier;
        int m_startDelay;
        int m_openingDepth;
        int m_seedCount;
        bool m_stopping;
        int m_openingRepetitions;
        OpeningPolicy m_openingPolicy;
        bool m_recover;
        bool m_pgnCleanup;
        bool m_pgnWriteUnfinishedGames;
        bool m_finished;
        bool m_bookOwnership;
        GameAdjudicator m_adjudicator;
        OpeningSuite* m_openingSuite;
        Sprt* m_sprt;
        QFile m_pgnFile;
        QTextStream m_pgnOut;
        QFile m_epdFile;
        QTextStream m_epdOut;
        QString m_startFen;
        int m_repetitionCounter;
        int m_swapSides;
        PgnGame::PgnMode m_pgnOutMode;
        TournamentPair* m_pair;
        QMap< QPair<int, int>, TournamentPair* > m_pairs;
        QList<TournamentPlayer> m_players;
        QMap<int, PgnGame> m_pgnGames;
        QMap<ChessGame*, GameData*> m_gameData;
        QVector<Chess::Move> m_openingMoves;
};

#endif // TOURNAMENT_H