engineplugin.h

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

#ifndef __ENGINEPLUGIN_H__
#define __ENGINEPLUGIN_H__

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

// 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 TextProvider;

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,
                EP_AboutProvider,
                EP_CanonicalName,
                EP_AllowsLogging
        };

        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;
                QScopedPointer<TextProvider> aboutProvider;
                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;
                bool allowsLogging;
                QString canonicalName;

                Data();

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

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

        EnginePlugin();
        virtual ~EnginePlugin();

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

        virtual ConfigPage *configuration(QWidget *parent);

        virtual QList<CreateServerDialogPage *> createServerDialogPages(CreateServerDialog *pDialog)
        {
                Q_UNUSED(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
        {
                Q_UNUSED(mode);
                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