server.h

//------------------------------------------------------------------------------
// server.h
//------------------------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301  USA
//
//------------------------------------------------------------------------------
// Copyright (C) 2009 Braden "Blzut3" Obrzut <admin@maniacsvault.net>
//------------------------------------------------------------------------------

#ifndef __SERVER_H__
#define __SERVER_H__

#include "dptr.h"
#include "global.h"
#include "serverapi/polymorphism.h"
#include "serverapi/serverptr.h"
#include "serverapi/serverstructs.h"

#include <QColor>
#include <QHostAddress>
#include <QHostInfo>
#include <QList>
#include <QMetaType>
#include <QObject>
#include <QPixmap>
#include <QString>
#include <QTime>
#include <QUdpSocket>

class DMFlagsSection;
class EnginePlugin;
class ExeFile;
class GameCVar;
class GameHost;
class GameClientRunner;
class PathFinder;
class Player;
class PlayersList;
class RConProtocol;
class TooltipGenerator;

class MAIN_EXPORT Server : public QObject
{
        Q_OBJECT

        friend class ServerPointer;

public:
        enum Response
        {
                RESPONSE_GOOD,
                RESPONSE_TIMEOUT,
                RESPONSE_WAIT,
                RESPONSE_BAD,
                RESPONSE_BANNED,
                RESPONSE_NO_RESPONSE_YET,
                RESPONSE_PENDING,
                RESPONSE_REPLY,
        };

        Server(const QHostAddress &address, unsigned short port);
        virtual ~Server() override;

        // VIRTUALS
        virtual ExeFile *clientExe();
        virtual GameClientRunner *gameRunner();
        virtual bool hasRcon() const { return false; }
        virtual QList<GameCVar> modifiers() const;
        virtual RConProtocol *rcon() { return nullptr; }
        virtual QRgb teamColor(int team) const;
        virtual QString teamName(int team) const;
        virtual EnginePlugin *plugin() const = 0;

        virtual TooltipGenerator *tooltipGenerator() const;

        virtual PathFinder wadPathFinder();
        // END OF VIRTUALS

        void addPlayer(const Player &player);
        const QHostAddress &address() const;
        QString addressWithPort() const;

        QStringList allWadNames() const;

        bool anyWadnameContains(const QString &text,
                Qt::CaseSensitivity cs = Qt::CaseInsensitive) const;

        void clearPlayersList();

        QString customDetails();

        const QString &country() const;

        const QList<DMFlagsSection> &dmFlags() const;
        const QString &email() const;

        QString engineName() const;

        const GameMode &gameMode() const;
        const QString &gameVersion() const;

        QString hostName(bool forceAddress = false) const;
        const QPixmap &icon() const;

        bool isCustom() const;
        bool isEmpty() const;
        bool isFull() const;
        bool isKnown() const;

        bool isLockedAnywhere() const;
        bool isLocked() const;
        bool isLockedInGame() const;

        bool isRandomMapRotation() const;
        bool isRefreshing() const;

        bool isSecure() const;

        bool isSpecial() const;

        bool isTestingServer() const;

        const QString &iwad() const;

        Response lastResponse() const;
        void lookupHost();

        const QString &map() const;
        const QStringList &mapList() const;
        unsigned short maxClients() const;
        unsigned short maxPlayers() const;
        const QString &motd() const;
        const QString &name() const;
        int numFreeClientSlots() const;
        int numFreeJoinSlots() const;
        int numFreeSpectatorSlots() const;
        int numTotalSlots() const
        {
                return maxPlayers() > maxClients() ? maxPlayers() : maxClients();
        }
        int numWads() const { return wads().size(); }
        unsigned int ping() const;
        const Player &player(int index) const;
        const PlayersList &players() const;
        unsigned short port() const;

        Response readRefreshQueryResponse(const QByteArray &data);

        void refreshStarts();

        void refreshStops(Response response);

        unsigned int score(int team = 0) const;
        const QList<int> &scores() const;
        unsigned int scoreLimit() const;

        QWeakPointer<Server> self() const;

        bool sendRefreshQuery(QUdpSocket *socket);

        void setCountry(const QString &country);
        void setCustom(bool custom);
        void setEmail(const QString &mail);
        void setGameMode(const GameMode &gameMode);
        void setMap(const QString &name);
        void setMapList(const QStringList &mapList);
        void setMaxClients(unsigned short i);
        void setMaxPlayers(unsigned short i);
        void setMotd(const QString &message);
        void setName(const QString &name);
        void setPort(unsigned short i);
        void setRandomMapRotation(bool b);
        void setSelf(const QWeakPointer<Server> &self);
        void setSkill(unsigned char newSkill);
        void setWebSite(const QString &site);

        void setAdditionalWebSites(const QStringList &list);

        unsigned short timeLeft() const;
        unsigned short timeLimit() const;

        qint64 timeMsSinceLastRefresh() const;

        unsigned char skill() const;
        const PWad &wad(int index) const;
        const QList<PWad> &wads() const;
        const QString &webSite() const;

        const QStringList &additionalWebSites() const;

        QStringList allWebSites() const;

        bool isLan() const;
        void setLan(bool b);

signals:
        void begunRefreshing(ServerPtr server);
        void updated(ServerPtr server, int response);

protected:
        POLYMORPHIC_SETTER_DECLARE(QString, Server, customDetails, ())
        QString customDetails_default();

        Response readRequest(const QByteArray &data);
        POLYMORPHIC_SETTER_DECLARE(Response, Server, readRequest, (const QByteArray &data))

        QByteArray createSendRequest();
        POLYMORPHIC_SETTER_DECLARE(QByteArray, Server, createSendRequest, ())

        void addWad(const PWad &wad);
        void clearWads();
        QList<int> &scoresMutable();
        void setDmFlags(const QList<DMFlagsSection> &dmFlags);
        void setGameVersion(const QString &version);
        void setIwad(const QString &iwad);
        void setLocked(bool locked);
        void setLockedInGame(bool locked);
        void setPing(unsigned int currentPing);

        void setPingIsSet(bool b);

        void setTestingServer(bool b);
        void setTimeLeft(unsigned short timeLeft);
        void setTimeLimit(unsigned short timeLimit);
        void setScoreLimit(unsigned int scoreLimit);
        void setSecure(bool bSecureServer);

private:
        Q_DISABLE_COPY(Server)

        static QString teamNames[];

        DPtr<Server> d;

        void clearDMFlags();

        QByteArray createSendRequest_default();
        Response readRequest_default(const QByteArray &data);

        void setResponse(Response response);
        void setScores(const QList<int> &scores);
        void setWads(const QList<PWad> &wads);

private slots:
        void setHostName(QHostInfo host);
};

Q_DECLARE_METATYPE(ServerPtr)
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
// Qt6 normalizes smart pointer meta types so we only need the non-const version
Q_DECLARE_METATYPE(ServerCPtr)
#endif

#endif /* __SERVER_H__ */