server.h

//------------------------------------------------------------------------------
// server.h
//------------------------------------------------------------------------------
//
// 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) any later version.
//
// 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, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
//------------------------------------------------------------------------------
// Copyright (C) 2009 "Blzut3" <admin@maniacsvault.net>
//------------------------------------------------------------------------------

#ifndef __SERVER_H__
#define __SERVER_H__

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

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

class DMFlagsSection;
class EnginePlugin;
class ExeFile;
class GameCVar;
class GameHost;
class GameMode;
class GameClientRunner;
class PathFinder;
class Player;
class PlayersList;
class PWad;
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();

                // VIRTUALS
                virtual ExeFile* clientExe();
                virtual GameClientRunner* gameRunner();
                virtual bool hasRcon() const { return false; }
                virtual QList<GameCVar> modifiers() const;
                virtual RConProtocol *rcon() { return NULL; }
                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 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 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);

                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;

                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);
Q_DECLARE_METATYPE(ServerCPtr);

#endif /* __SERVER_H__ */