engineplugin.h

//------------------------------------------------------------------------------
// engineplugin.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) 2011 "Blzut3" <admin@maniacsvault.net>
//------------------------------------------------------------------------------

#ifndef __ENGINEPLUGIN_H__
#define __ENGINEPLUGIN_H__

#include <QtContainerFwd>
#include <QString>
#include <QStringList>
#include <QVector>
#include "global.h"
#include "serverapi/serverstructs.h"
#include "serverapi/serverptr.h"

// Bump whenever the ABI changes in order to reject old plugins
#define DOOMSEEKER_ABI_VERSION 2

#define DECLARE_PLUGIN(XEnginePlugin) \
        friend PLUGIN_EXPORT EnginePlugin *doomSeekerInit(); \
        public: \
                static EnginePlugin *staticInstance() { return __Static_Instance; } \
        private: \
                static XEnginePlugin *__Static_Instance;

#define INSTALL_PLUGIN(XEnginePlugin) \
        XEnginePlugin *XEnginePlugin::__Static_Instance; \
        extern "C" PLUGIN_EXPORT unsigned int doomSeekerABI() { return DOOMSEEKER_ABI_VERSION; } \
        extern "C" PLUGIN_EXPORT EnginePlugin *doomSeekerInit() \
        { \
                XEnginePlugin::__Static_Instance = new XEnginePlugin(); \
                return XEnginePlugin::staticInstance(); \
        }

class Broadcast;
class ConfigPage;
class CreateServerDialog;
class CreateServerDialogPage;
class GameCVarProvider;
class GameCVar;
class GameExeFactory;
class GameHost;
class GameMode;
class IniSection;
class IRCNetworkEntity;
class MasterClient;
class Server;
class QHostAddress;
class QPixmap;
class QWidget;

class MAIN_EXPORT EnginePlugin
{
        protected:
                enum InitFeatures
                {
                        EP_Done, 

                        EP_Author, 
                        EP_Version, 

                        EP_AllowsConnectPassword, 
                        EP_AllowsEmail, 
                        EP_AllowsURL, 
                        EP_AllowsJoinPassword, 
                        EP_AllowsRConPassword, 
                        EP_AllowsMOTD, 
                        EP_DefaultMaster, 
                        EP_DefaultServerPort, 
                        EP_InGameFileDownloads, 
                        EP_IRCChannel, 
                        EP_SupportsRandomMapRotation, 
                        EP_RefreshThreshold, 
                        EP_URLScheme, 
                        EP_DemoExtension, 

                        EP_DontCreateDMFlagsPagesAutomatic,
                        EP_ClientOnly, 

                        EP_Broadcast,
                        EP_MasterClient,
                        EP_ClientExeName,
                        EP_ServerExeName,
                        EP_GameFileSearchSuffixes,
                        EP_DifficultyProvider,
                        EP_NoMapList,
                        EP_NoIwad,
                        EP_NoClientSlots,
                        EP_NoPlayerSlots,
                        EP_AllowsUpnp,
                        EP_AllowsUpnpPort
                };

                virtual void setupConfig(IniSection &config);

        public:
                class Data
                {
                        public:
                                unsigned int abiVersion;
                                bool allowsConnectPassword;
                                bool allowsEmail;
                                bool allowsJoinPassword;
                                bool allowsMOTD;
                                bool allowsRConPassword;
                                bool allowsURL;
                                QString author;
                                QString defaultMaster;
                                quint16 defaultServerPort;
                                QPixmap *icon;
                                bool inGameFileDownloads;
                                QVector<IRCNetworkEntity> ircChannels;
                                MasterClient *masterClient;
                                QString name;
                                IniSection *pConfig;
                                quint8 refreshThreshold;
                                QString scheme;
                                bool supportsRandomMapRotation;
                                bool valid;
                                unsigned int version;
                                bool demoExtensionAutomatic;
                                QString demoExtension;
                                bool createDMFlagsPagesAutomatic;
                                bool clientOnly;
                                QSharedPointer<GameExeFactory> gameExeFactory;
                                Broadcast *broadcast;

                                QString clientExeName;
                                QString serverExeName;
                                QStringList gameFileSearchSuffixes;

                                QSharedPointer<GameCVarProvider> difficulty;
                                bool hasMapList;
                                bool hasIwad;
                                bool allowsClientSlots;
                                bool allowsPlayerSlots;
                                bool allowsUpnp;
                                bool allowsUpnpPort;

                                Data();

                                bool hasBroadcast() const
                                {
                                        return broadcast != NULL;
                                }

                                bool hasMasterClient() const
                                {
                                        return masterClient != NULL;
                                }
                };

                EnginePlugin();
                virtual ~EnginePlugin();

                void init(const char* name, const char* const icon[], ...);

                virtual ConfigPage* configuration(QWidget *parent);

                virtual QList<CreateServerDialogPage*> createServerDialogPages(
                        CreateServerDialog* pDialog)
                {
                        return QList<CreateServerDialogPage*>();
                }

                const Data *data() const { return d; }
                const QPixmap &icon() const { return *d->icon; }
                void setConfig(IniSection &cfg);

                virtual QList<DMFlagsSection> dmFlags() const;

                GameExeFactory *gameExe();

                virtual GameHost* gameHost();

                virtual QList<GameMode> gameModes() const;
                virtual QList<GameCVar> gameModifiers() const;

                virtual QList<GameCVar> limits(const GameMode& mode) const { return QList<GameCVar>(); }

                void masterHost(QString &host, unsigned short &port) const;

                QString nameCanonical() const;

                virtual ServerPtr server(const QHostAddress &address, unsigned short port) const;

                virtual void start();

        protected:
                virtual ServerPtr mkServer(const QHostAddress &address, unsigned short port) const = 0;
                void initDefaultGameFiles();
                void setGameExeFactory(QSharedPointer<GameExeFactory> factory);

        private:
                Data *d;

                QStringList collectKnownPaths(const IniSection &ini) const;
                void findGameFiles(IniSection &ini);
};

extern "C" PLUGIN_EXPORT EnginePlugin *doomSeekerInit();

#endif