Tactics3DSuperPower.h

Go to the documentation of this file.

//    Copyright (C) 2015 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This file is part of Tactics3D.
//
//    Tactics3D 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.
//
//    Tactics3D 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 St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef TACTICS3DSUPER_POWER_H
#define TACTICS3DSUPER_POWER_H

#include "../Libs/Utils_LIB/UTypes.h"

#include <vector>
#include <string>
#include <map>

namespace Tactics3D {
    class Warrior;

    enum SUPER_POWER { NO_POWER, EVOCATION, WHAT_DOES_NOT_KILL_ME, ARGUMENT_AGAINST_MOTION, JAM_SESSION };

    struct SuperPower {
        SUPER_POWER _id;
        std::string _name;
        int _maxUses;
        int _maxRounds;

        typedef std::vector<Warrior*> Warriors;
        typedef std::vector<OpenSkyNet::Utils::TaggedUnion> Params;

        static const Warriors s_emptyWarriors;
        static const Params s_emptyParams;

        SuperPower(SUPER_POWER id_, const std::string& name_, int maxUses_, int maxRounds_) : 
            _id(id_), _name(name_), _maxUses(maxUses_), _maxRounds(maxRounds_) {}
        virtual ~SuperPower() {}

        virtual void use(Warrior* user_, const Warriors& targets_, const Params& params_) const {}

        virtual void setInactive(Warrior* user_, const Warriors& targets_) const {}

        virtual void takeDamage(Warrior* user_, int dmg_) const {}
        virtual void onFirstActiveRoundEnd(Warrior* user_, const Warriors& targets_) const {}

        virtual void getPlayerInfo(const Warrior* user_, char* buffer_, int bufferLen_) const { memset(buffer_, 0, bufferLen_); }
        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const { memset(buffer_, 0, bufferLen_); }
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { strncpy(buffer_, "attack", bufferLen_); }

        virtual bool canMoveInSameRound() const { return true; }
        virtual bool canTranslate() const { return false; }
        virtual bool canRotate() const { return false; }

        virtual bool doesMoveCurrCamToWarriorPOV(const Warrior* user_) const { return false; }

        virtual Warriors filterTargets(const Warrior* user_, const Warriors& targets_) const { return Warriors(); }
        virtual void formatParams(Params& params_) const { params_.clear(); }

        static void initAll();
    };

    struct Evocation : public SuperPower {
        Evocation() : SuperPower(EVOCATION, "Evocation", -1, 0) {}

        virtual void use(Warrior* user_, const Warriors& targets_, const Params& params_) const;

        virtual void getPlayerInfo(const Warrior* user_, char* buffer_, int bufferLen_) const;
        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const;
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { memset(buffer_, 0, bufferLen_); }

        virtual bool canRotate() const { return true; }

        virtual bool doesMoveCurrCamToWarriorPOV(const Warrior* user_) const;
    };
    extern const Evocation g_evocation;

    struct WhatDoesNotKillMe : public SuperPower {
        WhatDoesNotKillMe() : SuperPower(WHAT_DOES_NOT_KILL_ME, "What Does Not Kill Me Makes Me Stronger", 1, 5) {}

        virtual void use(Warrior* user_, const Warriors& targets_, const Params& params_) const;

        virtual void setInactive(Warrior* user_, const Warriors& targets_) const;

        virtual void takeDamage(Warrior* user_, int dmg_) const;

        virtual void getPlayerInfo(const Warrior* user_, char* buffer_, int bufferLen_) const;
    };
    extern const WhatDoesNotKillMe g_whatDoesNotKillMe;

    struct ArgumentAgainstMotion : public SuperPower {
        ArgumentAgainstMotion() : SuperPower(ARGUMENT_AGAINST_MOTION, "Argument Against Motion", 1, 2) {}

        virtual void use(Warrior* user_, const Warriors& targets_, const Params& params_) const;

        virtual void setInactive(Warrior* user_, const Warriors& targets_) const;

        virtual void getPlayerInfo(const Warrior* user_, char* buffer_, int bufferLen_) const;

        virtual Warriors filterTargets(const Warrior* user_, const Warriors& targets_) const;
    };
    extern const ArgumentAgainstMotion g_argumentAgainstMotion;

    struct JamSession : public SuperPower {
        JamSession() : SuperPower(JAM_SESSION, "Jam Session", 1, 2) {}

        virtual void use(Warrior* user_, const Warriors& targets_, const Params& params_) const;

        virtual void setInactive(Warrior* user_, const Warriors& targets_) const;

        virtual void onFirstActiveRoundEnd(Warrior* user_, const Warriors& targets_) const;

        virtual void getPlayerInfo(const Warrior* user_, char* buffer_, int bufferLen_) const;

        virtual Warriors filterTargets(const Warrior* user_, const Warriors& targets_) const;
    };
    extern const JamSession g_jamSession;

    extern std::map<SUPER_POWER, const SuperPower*> g_superPowers;
}

#endif //TACTICS3DSUPER_POWER_H