serverstructs.h

Go to the documentation of this file.

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

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

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

class Checksum;
class ModFile;
class MAIN_EXPORT DMFlag
{
public:
        DMFlag();
        DMFlag(const QString &internalName, unsigned value);
        DMFlag(const QString &internalName, unsigned value, const QString &name);
        DMFlag(const DMFlag &other);
        virtual ~DMFlag();
        DMFlag &operator=(const DMFlag &other);

        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);

        DMFlagsSection(const DMFlagsSection &other);
        virtual ~DMFlagsSection();
        DMFlagsSection &operator=(const DMFlagsSection &other);

        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);
        GameCVar(const GameCVar &other);
        virtual ~GameCVar();
        GameCVar &operator=(const GameCVar &other);

        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() override;

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

private:
        Q_DISABLE_COPY(GameCVarProvider)

        DPtr<GameCVarProvider> d;
};

using gamemode_id = int;

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();
        GameMode(const GameMode &other);
        virtual ~GameMode();
        GameMode &operator=(const GameMode &other);

        gamemode_id index() const;

        const QString &name() const;

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

private:
        DPtr<GameMode> d;

        GameMode(gamemode_id index, const QString &name);

        void setTeamGame(bool b);
};

class MAIN_EXPORT PWad
{
public:
        PWad(const QString &name, bool optional = false);
        PWad(const QString &name, bool optional, const QList<Checksum> &checksums);
        PWad(const ModFile &modFile);
        PWad(const PWad &other);
        virtual ~PWad();
        PWad &operator=(const PWad &other);

        operator ModFile();
        bool isOptional() const;
        const QString &name() const;
        const QList<Checksum> checksums() const;
        void addChecksum(const QByteArray &hash, const QCryptographicHash::Algorithm &algorithm);
        bool validFile(const QString &path) const;
private:
        DPtr<PWad> d;
};

class Skill
{
public:
        static const unsigned char UNDEFINED = CHAR_MAX;
};

#endif