• Doomseeker
• Wadseeker
• Download
• Tracker
• Git
• Docs

src/core/masterserver/masterclient.h

//------------------------------------------------------------------------------
// masterclient.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 __MASTERSERVER_H__
#define __MASTERSERVER_H__

#include <QObject>
#include <QHostAddress>
#include <QList>

#include "global.h"

class Message;
class EnginePlugin;
class Server;
class QFile;
class QUdpSocket;

class MAIN_EXPORT MasterClient : public QObject
{
        Q_OBJECT

        public:
                static QUdpSocket*              pGlobalUdpSocket;

                MasterClient();
                virtual ~MasterClient();

                bool                                    hasServer(const Server*);

                bool                                    isAddressDataCorrect(const QHostAddress& address, unsigned short port)
                {
                        return (this->address == address && this->port == port);
                }

                bool                                    isEnabled() const { return enabled; }
                bool                                    isTimeouted() const { return bTimeouted; }
                int                                             numPlayers() const;
                int                                             numServers() const { return servers.size(); }
                Server                                  *operator[] (int index) const { return servers[index]; }

                virtual const EnginePlugin*             plugin() const = 0;

                void                                    pushPacketToCache(QByteArray &data);
                void                                    resetPacketCaching();

                virtual bool                    readMasterResponse(QByteArray &data)=0;

                virtual bool                    readMasterResponse(QHostAddress& address, unsigned short port, QByteArray &data);

                QList<Server*>                  &serverList() { return servers; }
                const QList<Server*>    &serverList() const { return servers; }

                void                                    updateAddress();

        public slots:
                virtual void                    refresh();

                void                                    setEnabled(bool b) { enabled = b; }

                void                                    timeoutRefresh();

        signals:
                void                                    listUpdated();

                void                                    message(const QString& title, const QString& content, bool isError);

                void                    messageImportant(const Message& message);

                void                                    newServerBatchReceived(const QList<Server* >& servers);

        protected:
                QHostAddress                    address;

                bool                                    bTimeouted;
                bool                                    enabled;
                unsigned short                  port;
                QList<Server *>                 servers;

                QFile                                   *cache;

                void                                    emptyServerList();

                QString                 engineName() const;

                virtual bool                    getServerListRequest(QByteArray &data)=0;

                void                                    notifyBanned();
                void                                    notifyDelay();
                
                void notifyError();

                void                                    notifyUpdate();

                bool                                    preparePacketCache(bool write);
                void                                    readPacketCache();

                virtual void                    timeoutRefreshEx() {}
};

#endif /* __MASTERSERVER_H__ */

   

Doomseeker © 2009-2019 The Doomseeker Team