Tactics3DAction.h

Go to the documentation of this file.

//    Copyright (C) 2006-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 TACTICS3DACTION_H
#define TACTICS3DACTION_H

#include <vector>

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

#include "Tactics3DFightingStyle.h"
#include "Tactics3DSuperPower.h"

namespace Tactics3D {
    class Warrior;
    class AttackRange;

    enum ACTION_TYPE { NO_ACTION, NOP_ACTION, DELAY_ACTION, MOVE_ACTION, ATTACK_ACTION, SPECIAL_MOVE_ACTION, SUPER_POWER_ACTION, REPAIR_THRUSTERS, BREAK_GRAPPLE };

    struct Action {
        static const OpenSkyNet::Utils::uint MAX_PARAMS = 10;

        std::string _name;
        const ACTION_TYPE _type;
        bool _isAuto;
        bool _isContinuous;
        Tactics3D::Warrior* _performer;
        std::vector<OpenSkyNet::Utils::TaggedUnion> _params;

        Action(const std::string& name_="NO_ACTION", ACTION_TYPE type_=NO_ACTION, bool isAuto_=true) : 
            _name(name_), _type(type_), _isAuto(isAuto_), _isContinuous(false), _performer(0) {}

        virtual ~Action() {}

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

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

        virtual void perform() {}
    };

    struct NoPAction : public Action {
        NoPAction() : Action("No Performance",NOP_ACTION,true) {}
    };

    struct DelayAction : public Action {
        DelayAction() : Action("Delay",DELAY_ACTION,true) {}

        static void getPlayerInfo(char* buffer_, int bufferLen_);
    };

    struct MoveAction : public Action {
        MoveAction() : Action("Move",MOVE_ACTION,true) {}

        static void getPlayerInfo(char* buffer_, int bufferLen_);

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

        virtual void perform();
    };

    struct RepairThrustersAction : public Action {
        RepairThrustersAction() : Action("Repair Thrusters",REPAIR_THRUSTERS,true) {}

        static void getPlayerInfo(char* buffer_, int bufferLen_);

        virtual void perform();
    };

    struct BreakGrappleAction : public Action {
        BreakGrappleAction() : Action("Break Grapple",BREAK_GRAPPLE,true) {}

        static void getPlayerInfo(char* buffer_, int bufferLen_);

        virtual void perform();
    };

    struct AttackAction : public Action {
        AttackAction() : Action("Attack",ATTACK_ACTION,false) {}

        AttackAction(Warrior* performer_, const AttackRange* attackRange_, Warrior* defender_) 
            : Action("Attack",ATTACK_ACTION,false) {
            _performer = performer_;
            _params.push_back(attackRange_);
            _params.push_back(defender_);
        }

        inline const AttackRange* getAttackRange() const {
            assert(_params.size() > 0);
            return static_cast<const AttackRange*>(_params[0].getConstPointer());
        }

        inline Warrior* getDefender() const {
            assert(_params.size() > 1);
            return static_cast<Warrior*>(_params[1].getPointer());
        }

        virtual void getAnimationName(char* buffer_, int bufferLen_) const { strncpy(buffer_, "attack", bufferLen_); }
        static void getPlayerInfo(char* buffer_, int bufferLen_);

        virtual void perform();
    };

    struct SpecialMoveAction : public Action {
        static const OpenSkyNet::Utils::uint MAX_DEFENDERS = 2;

        SpecialMoveAction(Warrior* performer_, SPECIAL_MOVE specialMove_, const AttackRange* attackRange_, 
            std::vector<Warrior*> defenders_, 
            std::vector<OpenSkyNet::Utils::TaggedUnion>& specialMoveParams_);

        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const { getSpecialMove()->getPrePerformInfo(buffer_, bufferLen_); }
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { getSpecialMove()->getAnimationName(buffer_, bufferLen_); }
        static void getPlayerInfo(char* buffer_, int bufferLen_);

        virtual bool canMoveInSameRound() const { return getSpecialMove()->canMoveInSameRound(); }
        virtual bool canTranslate() const { return getSpecialMove()->canTranslate(); }
        virtual bool canRotate() const { return getSpecialMove()->canRotate(); }

        virtual void perform();

        inline const SpecialMove* getSpecialMove() const {
            assert(_params.size() > 0);
            return g_specialMoves[static_cast<SPECIAL_MOVE>(_params[0].getInt())];
        }

        inline const AttackRange* getAttackRange() const {
            assert(_params.size() > 1);
            return static_cast<const AttackRange*>(_params[1].getConstPointer());
        }

        inline std::vector<Warrior*> getDefenders() const {
            assert(_params.size() > 2);
            std::vector<Warrior*> defenders;
            int numDefenders = _params[2].getInt();
            assert(numDefenders > -1);
            assert(static_cast<OpenSkyNet::Utils::uint>(numDefenders) <= MAX_DEFENDERS);
            defenders.reserve(numDefenders);

            std::size_t indexAfterLastDefender = numDefenders + 3;
            assert(_params.size() >= indexAfterLastDefender);
            for (std::size_t i = 3; i < indexAfterLastDefender; ++i)
                defenders.push_back(static_cast<Warrior*>(_params[i].getPointer()));

            return defenders;
        }

        inline std::vector<OpenSkyNet::Utils::TaggedUnion> getSpecialMoveParams() const {
            assert(_params.size() > 3);
            std::vector<OpenSkyNet::Utils::TaggedUnion> specialMoveParams;

            int numDefenders = _params[2].getInt();
            int numSpecialMoveParams = _params[numDefenders + 3].getInt();

            if (numSpecialMoveParams) {
                int firstSpecialMoveParam = numDefenders + 3 + 1;
                int indexAfterLastSpecialMoveParam = firstSpecialMoveParam + numSpecialMoveParams;
                specialMoveParams.reserve(numSpecialMoveParams);
                for (int i = firstSpecialMoveParam; i < indexAfterLastSpecialMoveParam; ++i)
                    specialMoveParams.push_back(_params[i]);
            }

            return specialMoveParams;
        }
    };

    struct SuperPowerAction : public Action {
        static const OpenSkyNet::Utils::uint MAX_TARGETS = 2;

        SuperPowerAction(Warrior* performer_, SUPER_POWER superPower_, SuperPower::Warriors& targets_, SuperPower::Params& superPowerParams_);

        virtual void getPrePerformInfo(char* buffer_, int bufferLen_) const { getSuperPower()->getPrePerformInfo(buffer_, bufferLen_); }
        virtual void getAnimationName(char* buffer_, int bufferLen_) const { getSuperPower()->getAnimationName(buffer_, bufferLen_); }
        static void getPlayerInfo(char* buffer_, int bufferLen_);

        virtual bool canMoveInSameRound() const { return getSuperPower()->canMoveInSameRound(); }
        virtual bool canTranslate() const { return getSuperPower()->canTranslate(); }
        virtual bool canRotate() const { return getSuperPower()->canRotate(); }

        virtual void perform();

        inline const SuperPower* getSuperPower() const {
            assert(_params.size() > 0);
            return g_superPowers[static_cast<SUPER_POWER>(_params[0].getInt())];
        }

        inline SuperPower::Warriors getTargets() const {
            assert(_params.size() > 1);
            SuperPower::Warriors targets;
            int numTargets = _params[1].getInt();
            assert(numTargets > -1);
            assert(static_cast<OpenSkyNet::Utils::uint>(numTargets) <= MAX_TARGETS);
            targets.reserve(numTargets);

            std::size_t indexAfterLastTarget = numTargets + 2;
            assert(_params.size() >= indexAfterLastTarget);
            for (std::size_t i = 2; i < indexAfterLastTarget; ++i)
                targets.push_back(static_cast<Warrior*>(_params[i].getPointer()));

            return targets;
        }

        inline SuperPower::Params getSuperPowerParams() const {
            assert(_params.size() > 2);
            SuperPower::Params superPowerParams;

            int numTargets = _params[1].getInt();
            int numSuperPowerParams = _params[numTargets + 2].getInt();

            if (numSuperPowerParams) {
                int firstSuperPowerParam = numTargets + 2 + 1;
                int indexAfterLastSuperPowerParam = firstSuperPowerParam + numSuperPowerParams;
                superPowerParams.reserve(numSuperPowerParams);
                for (int i = firstSuperPowerParam; i < indexAfterLastSuperPowerParam; ++i)
                    superPowerParams.push_back(_params[i]);
            }

            return superPowerParams;
        }
    };
}

#endif //TACTICS3DACTION_H