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        
        };
 
        constexpr static auto c_defaultFormat 
            = "Rank,Name,Elo,Error,Games,Score,DScore";
 
        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 setReverseSides(bool enabled);
        void setOpeningBookOwnership(bool enabled);
        void setSeedCount(int seedCount);
        void setSwapSides(bool enabled);
        void setResultFormat(const QString &format);
        QString resultFormat() const;
        const QMap<QString, QString>& namedResultFormats() const;
        const QList<QString> resultFieldTokens() const;
        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, Chess::Side side, 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:
        enum OutputField
        {
            Rank,
            Name,
            Games,
            Wins,
            Losses,
            Draws,
            WhiteWins,
            WhiteLosses,
            WhiteDraws,
            BlackWins,
            BlackLosses,
            BlackDraws,
            Points,
            Score,
            DrawScore,
            EloDiff,
            ErrorMargin,
            LOS,
            WhiteScore,
            WhiteDrawScore,
            WhiteEloDiff,
            WhiteErrorMargin,
            WhiteLOS,
            BlackScore,
            BlackDrawScore,
            BlackEloDiff,
            BlackErrorMargin,
            BlackLOS
        };
 
        const QMap<QString, int> m_tokenMap = {
            {"Rank",    Rank},
            {"Name",    Name},
            {"Games",   Games},
            {"W",       Wins},
            {"L",       Losses},
            {"D",       Draws},
            {"wW",      WhiteWins},
            {"wL",      WhiteLosses},
            {"wD",      WhiteDraws},
            {"bW",      BlackWins},
            {"bL",      BlackLosses},
            {"bD",      BlackDraws},
            {"Points",  Points},
            {"Score",   Score},
            {"DScore",  DrawScore},
            {"Elo",     EloDiff},
            {"Error",   ErrorMargin},
            {"LOS",     LOS},
            {"wScore",  WhiteScore},
            {"wDScore", WhiteDrawScore},
            {"wElo",    WhiteEloDiff},
            {"wError",  WhiteErrorMargin},
            {"wLOS",    WhiteLOS},
            {"bScore",  BlackScore},
            {"bDScore", BlackDrawScore},
            {"bElo",    BlackEloDiff},
            {"bError",  BlackErrorMargin},
            {"bLOS",    BlackLOS}
        };
 
        const QMap<QString, QString> m_namedFormats =
        {
            {"minimal", "Rank,Name"},
            {"small",   "Rank,Name,Games,Points"},
            {"short",   "Rank,Name,Elo,Games"},
            {"concise", "Rank,Name,Elo,Error,Games"},
            {"default", QString(c_defaultFormat)},
            {"with-points", "Rank,Name,Elo,Error,Games,Points,Score,DScore"},
            {"wide",    "Rank,Name,Elo,Error,Games,W,L,D,Points,Score,DScore"},
            {"wide2",   "Rank,Name,Elo,Error,Games,W,L,D,Points,"
                    "Score,DScore,wScore,bScore"},
            {"per-color",   "Rank,Name,Elo,Error,Games,W,L,D,Points,"
                    "wW,wL,wD,wPoints,bW,bL,bD,bPoints"},
            {"ordo",    "Rank,Name,Elo,Points,Games,Score"}
        };
 
        struct GameData
        {
            int number;
            int whiteIndex;
            int blackIndex;
        };
        struct RankingData
        {
            QString name;
            int games;
            int wins;
            int losses;
            int draws;
            int whiteWins;
            int whiteLosses;
            int whiteDraws;
            int blackWins;
            int blackLosses;
            int blackDraws;
            qreal points;
            qreal score;
            qreal drawScore;
            qreal eloDiff;
            qreal errorMargin;
            qreal LOS;
            qreal whiteScore;
            qreal whiteDrawScore;
            qreal whiteEloDiff;
            qreal whiteErrorMargin;
            qreal whiteLOS;
            qreal blackScore;
            qreal blackDrawScore;
            qreal blackEloDiff;
            qreal blackErrorMargin;
            qreal blackLOS;
        };
 
        QString resultsForSides(int index) const;
 
        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;
        bool m_reverseSides;
 
        QString m_resultFormat;
        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;
};
 
class LIB_EXPORT ResultFormatter : public QObject
{
    Q_OBJECT
 
    public:
        ResultFormatter(const QMap<QString, int>& tokenMap,
                const QString& format = QString(),
                QObject* parent = nullptr);
        void setEntryFormat(const QString& format);
        QString entryFormat() const;
        QString entry(const QMap<int, QString>& data) const;
    private:
        QString m_entryFormat;
        QMap<QString, int> m_tokenMap;
        QStringList m_tokenList;
};
 
#endif // TOURNAMENT_H