serverstructs.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
// serverstructs.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) 2010 "Blzut3" <admin@maniacsvault.net>
//------------------------------------------------------------------------------
#ifndef __SERVER_STRUCTS_H_
#define __SERVER_STRUCTS_H_

#include <QString>
#include <QList>
#include <QObject>
#include <QVariant>

#include "dptr.h"
#include "global.h"

class MAIN_EXPORT DMFlag
{
        public:
                DMFlag();
                DMFlag(const QString &internalName, unsigned value);
                DMFlag(const QString &internalName, unsigned value, const QString &name);
                virtual ~DMFlag();

                const QString &internalName() const;

                bool isValid() const;

                const QString &name() const;

                unsigned value() const;

        private:
                DPtr<DMFlag> d;
};

class MAIN_EXPORT DMFlagsSection
{
        public:
                static QList<DMFlagsSection> removedBySection(
                        const QList<DMFlagsSection> &original,
                        const QList<DMFlagsSection> &removals);

                DMFlagsSection();

                DMFlagsSection(const QString &internalName);

                DMFlagsSection(const QString &internalName, const QString &name);

                virtual ~DMFlagsSection();

                void add(const DMFlag& flag);
                unsigned combineValues() const;

                DMFlagsSection copyEmpty() const;

                int count() const;

                const QString &internalName() const;

                bool isEmpty() const;

                const QString &name() const;
                const DMFlag &operator[](int index) const;
                DMFlag &operator[](int index);

                DMFlagsSection& operator<<(const DMFlag& flag)
                {
                        add(flag);
                        return *this;
                }

                DMFlagsSection removed(const DMFlagsSection &removals) const;

        private:
                DPtr<DMFlagsSection> d;
};

class MAIN_EXPORT GameCVar
{
        public:
                GameCVar();
                GameCVar(const QString &name, const QString &command);
                GameCVar(const QString &name, const QString &command, const QVariant &value);
                virtual ~GameCVar();

                const QString &command() const;

                bool hasValue() const;
                bool isValid() const;

                const QString &name() const;

                void setValue(const QVariant& value);

                const QVariant &value() const;
                QString valueString() const { return value().toString(); }
                bool valueBool() const { return value().toBool(); }
                int valueInt() const { return value().toInt(); }

        private:
                DPtr<GameCVar> d;
};

class MAIN_EXPORT GameCVarProvider : public QObject
{
        Q_OBJECT;

public:
        GameCVarProvider();
        virtual ~GameCVarProvider();

        virtual QList<GameCVar> get(const QVariant &context);

private:
        Q_DISABLE_COPY(GameCVarProvider);

        DPtr<GameCVarProvider> d;
};

class MAIN_EXPORT GameMode
{
        public:
                enum StandardGameMode
                {
                        SGM_Cooperative = 900,
                        SGM_Deathmatch = 901,
                        SGM_TeamDeathmatch = 902,
                        SGM_CTF = 903,
                        SGM_Unknown = 904
                };

                // Standard game mode set
                // These should be used in order to keep the names uniform.
                // These can't be static members as translations may not work.
                static GameMode mkCooperative();
                static GameMode mkDeathmatch();
                static GameMode mkTeamDeathmatch();
                static GameMode mkCaptureTheFlag();
                static GameMode mkUnknown();

                static GameMode ffaGame(int index, const QString &name);
                static GameMode teamGame(int index, const QString &name);

                GameMode();
                virtual ~GameMode();

                int index() const;

                const QString &name() const;

                bool isTeamGame() const;
                bool isValid() const;

        private:
                DPtr<GameMode> d;

                GameMode(int index, const QString &name);

                void setTeamGame(bool b);
};

class MAIN_EXPORT PWad
{
        public:
                PWad(const QString &name, bool optional=false);
                virtual ~PWad();

                bool isOptional() const;
                const QString& name() const;

        private:
                DPtr<PWad> d;
};

#endif