Tactics3DWarrior.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 TACTICS3DWARRIOR_H
#define TACTICS3DWARRIOR_H

#include "../Libs/OgreCore_LIB/OgrePhysVisObject.h"
#include "../Libs/Core_LIB/ICollisionListener.h"
#include "../Libs/Core_LIB/CLog.h"
#include "../Libs/Utils_LIB/UThread.h"

#ifdef USE_EASTL
#include <EASTL/fixed_map.h>
#endif //USE_EASTL

#include "Tactics3DAction.h"
#include "Tactics3DAttackRange.h"
#include "Tactics3DInventory.h"
#include "Tactics3DEvocationObject.h"

namespace Tactics3D {
    class Warrior : public OpenSkyNet::Core::ABCObject, 
        public OpenSkyNet::Core::CollisionListener {
    public:
        struct FightingStyleContext {
            int _rank, _oO, _oD;
            FightingStyleContext() : _rank(0), _oO(0), _oD(0) {}
            FightingStyleContext(int rank_, int oO_, int oD_) : _rank(rank_), _oO(oO_), _oD(oD_) {}
        };

        struct SuperPowerContext {
            int _uses;
            int _roundsRemaining;
            SuperPower::Warriors _targets;
            SuperPowerContext() : _uses(0), _roundsRemaining(0) {}
            SuperPowerContext(int maxUses_) : _uses(maxUses_), _roundsRemaining(0) {}
        };

        static const OpenSkyNet::Utils::uint MAX_FIGHTING_STYLES = 4;
        static const OpenSkyNet::Utils::uint MAX_SUPER_POWERS = 2;
        static const OpenSkyNet::Utils::uint MAX_ACTIONS = 3;

#ifdef USE_EASTL
        typedef eastl::fixed_map<FIGHTING_STYLE, FightingStyleContext, MAX_FIGHTING_STYLES> FightingStyleContextMap;
        typedef eastl::fixed_map<SUPER_POWER, SuperPowerContext, MAX_SUPER_POWERS> SuperPowerContextMap;
#else
        typedef std::map<FIGHTING_STYLE, FightingStyleContext> FightingStyleContextMap;
        typedef std::map<SUPER_POWER, SuperPowerContext> SuperPowerContextMap;
#endif

        enum TEAM { NO_TEAM, PHILOSOPHER, MUSICIAN, MAX_TEAM };

        #define WARRIOR_MOVEMENT_DISABLED (1 << 0)
    protected:
        OpenSkyNet::Utils::uint _networkId;
        OpenSkyNet::Core::PhysVisObject* _pVO;
        OpenSkyNet::Math::Point<> _prevPos;
        int _gp, _lvl;
        int _dex, _str, _end, _initDex, _initStr, _initEnd;
        TEAM _team;
        int _oO, _oD, _prevOD, _initOD;
        int _dmgAdj;
        int _speed;
        int _flags;
        int _numRoundEndEventsSinceTempOD;
        FightingStyleContextMap _fightingStyleContexts;
        SuperPowerContextMap _superPowerContexts;
        bool _isTurn, _isGrounded, _isGrappling, _isDead;
        SPECIAL_MOVE _specialMoveJustPerformed;
        std::set<CounterableMove> _counterableMoves;
        float _movementLeftInAction, _distMovedLastPosSet;
        std::vector<AttackRange*> _attackRanges;
        std::vector<EvocationObject*> _evocationObjects;
        std::list<Action*> _actions;
        Warrior* _otherGrappler;
        OpenSkyNet::Math::Point<float, 2> _cachedPointInSpread;
        std::list<ICollectible*> _inventory;

        static OpenSkyNet::Utils::SyncEvent _performEvent;
    public:
        Warrior(OpenSkyNet::Utils::uint networkId_, OpenSkyNet::Core::PhysVisObject* pVO_, 
            int gp_, int lvl_, int dex_, int str_, int end_, TEAM team_);

        virtual ~Warrior();

        virtual OpenSkyNet::Math::Point<> getPos() const { return _pVO->getPos(); }
        virtual void getPos(OpenSkyNet::Math::Point<>& pos_) const { _pVO->getPos(pos_); }
        virtual void setPos(const OpenSkyNet::Math::Point<>& pos_);
        virtual bool getHasPosChanged() const { return _pVO->getHasPosChanged(); }
        virtual void setHasPosChanged(bool val_) { _pVO->setHasPosChanged(val_); }

        virtual OpenSkyNet::Math::Matrix3x3 getRot() const { return _pVO->getRot(); }
        virtual void getRot(OpenSkyNet::Math::Matrix3x3& rot_) const { _pVO->getRot(rot_); }
        virtual void setRot(const OpenSkyNet::Math::Matrix3x3& rot_) { _pVO->setRot(rot_); }
        virtual bool getHasRotChanged() const { return _pVO->getHasRotChanged(); }
        virtual void setHasRotChanged(bool val_) { _pVO->setHasRotChanged(val_); }

        virtual OpenSkyNet::Math::Point<> getVel() const;
        virtual void getVel(OpenSkyNet::Math::Point<>& vel_) const;
        virtual void setVel(const OpenSkyNet::Math::Point<> &vel_) { _pVO->setVel(vel_); }

        virtual OpenSkyNet::Math::Point<> getAngVel() const;
        virtual void getAngVel(OpenSkyNet::Math::Point<>& angVel_) const;

        virtual const OpenSkyNet::Core::PhysicalObject* getPhysicalObject() const { return _pVO->getPhysicalObject(); }
        virtual OpenSkyNet::Core::PhysicalObject* getPhysicalObject() { return _pVO->getPhysicalObject(); }
        virtual const OpenSkyNet::Core::VisibleObject* getVisibleObject() const { return _pVO->getVisibleObject(); }
        virtual OpenSkyNet::Core::VisibleObject* getVisibleObject() { return _pVO->getVisibleObject(); }

        virtual void setNonCollidingData(OpenSkyNet::Core::Object* obj_) { _pVO->setNonCollidingData(obj_); }
        virtual void handleNonCollidingTransformApplied(OpenSkyNet::Core::Object* obj_);
        virtual bool handleCollisions(OpenSkyNet::Core::Object* collidee_, std::vector<OpenSkyNet::CD::HitInfo>& colliders_, float& dt_);
        virtual bool handleOutOfGrid(OpenSkyNet::Core::Object* obj_);

        virtual void handleNewAttackRangeCollisions(AttackRange* collidee_, std::vector<OpenSkyNet::Core::Object*>& colliders_) {}
        virtual void handleDeletedAttackRangeCollisions(AttackRange* collidee_, std::vector<OpenSkyNet::Core::Object*>& colliders_) {}

        virtual void setVisible(bool val_) { getVisibleObject()->setVisible(val_); }

        inline const OpenSkyNet::OgreCore::OgreVisibleObject* getOgreVisibleObject() const {
            return static_cast<const OpenSkyNet::OgreCore::OgreVisibleObject*>(getVisibleObject());
        }
        inline OpenSkyNet::OgreCore::OgreVisibleObject* getOgreVisibleObject() {
            return static_cast<OpenSkyNet::OgreCore::OgreVisibleObject*>(getVisibleObject());
        }

        inline Ogre::SceneNode* getRenderNode() {
            OpenSkyNet::OgreCore::OgreVisibleObject* ogreVisObj = getOgreVisibleObject();

            if (ogreVisObj)
                return ogreVisObj->getRenderNode();

            return 0;
        }

        inline Ogre::Entity* getEntity() {
            Ogre::SceneNode* node = getRenderNode();

            if (node)
                return static_cast<Ogre::Entity*>(node->getAttachedObject(getName()));

            return 0;
        }

        void clearFightingStyles();
        void addFightingStyle(FIGHTING_STYLE style_, int rank_);
        inline const FightingStyleContextMap& getFightingStyleContexts() const { return _fightingStyleContexts; }

        inline void clearSuperPowers() { _superPowerContexts.clear(); }
        void addSuperPower(SUPER_POWER power_);
        inline const SuperPowerContextMap& getSuperPowerContexts() const { return _superPowerContexts; }

        virtual bool setSuperPowerActive(SUPER_POWER power_, const SuperPower::Warriors& targets_);
        bool isSuperPowerActive(SUPER_POWER power_);

        virtual const std::list<ICollectible*>& getInventory() const { return _inventory; }
        virtual std::list<ICollectible*>& getInventory() { return _inventory; }

        virtual const IWeapon* getPrimaryWeapon() const;
        virtual IWeapon* getPrimaryWeapon();

        virtual void setPrimaryWeapon(IWeapon* weapon_);

        inline int getGP() const { return _gp; }

        inline int getLvl() const { return _lvl; }

        virtual int getDex() const { return _dex; }
        virtual int getInitDex() const { return _initDex; }
        virtual void setDex(int dex_);
        virtual void setInitDex(int dex_) { _initDex = dex_; }

        virtual int getStr() const { return _str; }
        virtual int getInitStr() const { return _initStr; }
        virtual void setStr(int str_);
        virtual void setInitStr(int str_) { _initStr = str_; }

        virtual int getEnd() const { return _end; }
        virtual int getInitEnd() const { return _initEnd; }
        virtual void setEnd(int end_);
        virtual void setInitEnd(int end_) { _initEnd = end_; }

        inline TEAM getTeam() const { return _team; }

        inline int getOO(FIGHTING_STYLE style_=HIGHEST_OO) const {
            if (style_ == HIGHEST_OO) return _oO;
            FightingStyleContextMap::const_iterator i = _fightingStyleContexts.find(style_);
            assert(i != _fightingStyleContexts.end());
            return i->second._oO;
        }
        inline int getOD() const { return _oD; }
        inline int getInitOD() const { return _initOD; }

        inline int getDmgAdj() const { return _dmgAdj; }

        inline int getSpeed() const { return _speed; }
        inline void setSpeed(int speed_) { _speed = speed_; }

        inline float getMovementLeftInAction() const { return _movementLeftInAction; }
        inline void disableMovement() { _flags |= WARRIOR_MOVEMENT_DISABLED; }
        inline void enableMovement() { _flags &= ~WARRIOR_MOVEMENT_DISABLED; }
        inline bool isMovementEnabled() const { return !(_flags & WARRIOR_MOVEMENT_DISABLED); }

        void setTempOD(int oD_);

        virtual void setActions() {}

        inline void clearActions() { _actions.clear(); }

        inline std::list<Tactics3D::Action*>* getActions() { return &_actions; }
        inline const std::list<Tactics3D::Action*>* getActions() const { return &_actions; }

        virtual bool canAddAction(const Tactics3D::Action* action_) const;

        virtual bool updateContinuousAction(Tactics3D::Action*& action_);

        void takeDamage(int dmg_);

        virtual void setIsTurn(bool isTurn_);

        inline bool isGrounded() const { return _isGrounded; }
        void setGrounded(bool isGrounded_);

        inline bool isGrappling() const { return _isGrappling; }
        inline Warrior* getOtherGrappler() const { return _otherGrappler; }
        virtual bool grapple(Warrior* otherGrappler_);
        virtual bool stopGrappling();

        inline SPECIAL_MOVE getSpecialMoveJustPerformed() const { return _specialMoveJustPerformed; }

        virtual void addCounterableMove(Warrior* attacker_, SPECIAL_MOVE move_) {
            _counterableMoves.insert(CounterableMove(attacker_, move_));
        }

        virtual bool canCounter(Warrior* attacker_, SPECIAL_MOVE move_) const {
            CounterableMove counterableMove(attacker_, move_);
            std::set<CounterableMove>::const_iterator i = _counterableMoves.find(counterableMove);
            if (i != _counterableMoves.end() && attacker_->getSpecialMoveJustPerformed() == move_)
                return true;
            return false;
        }

        inline bool isAlive() const { return !_isDead; }
        void setDead();

        inline const std::vector<AttackRange*>& getAttackRanges() const { return _attackRanges; }
        virtual const AttackRange* getAttackRange(SPECIAL_MOVE specialMove_) const;

        inline void addEvocationObject(EvocationObject* evoObj_) { _evocationObjects.push_back(evoObj_); }
        inline std::vector<EvocationObject*>& getEvocationObjects() { return _evocationObjects; }

        virtual void getPointInSpread(float spread_, OpenSkyNet::Math::Point<float, 2>& p_);
        inline const OpenSkyNet::Math::Point<float, 2>& getCachedPointInSpread() { return _cachedPointInSpread; }
        virtual void getAim(float spread_, OpenSkyNet::Math::Point<>& origin_, OpenSkyNet::Math::Point<>& dir_);

        float getDist(const Warrior* warrior_) const;

        virtual bool doPerformAction(const Action* action_, bool& doDelay_, bool& doSubstitute_, Action*& substitute_);

        virtual void onPrePerformAnyAction(const std::vector<Warrior*>& warriors_);
        virtual void onPostPerformAction(const Action* action_);
        virtual void onMove() {}
        virtual void onHipFire(OpenSkyNet::Core::Object* intendedTarget_, Action* action_) {}
        virtual void onIronSightsFire(OpenSkyNet::Core::Object* intendedTarget_, Action* action_) {}
        virtual void onEvocation() {}
        virtual bool onAttack(std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_) { return false; }
        virtual void onDefend() {}
        virtual void onAttacked(const std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_) {}
        virtual void onDefended();
        virtual void onRoundEnd();

        void snapToGrid();

        static const volatile bool* _quit;

        static bool _isSmokeTest;

        static inline void setEvent(OpenSkyNet::Utils::SyncEvent& event_, bool ignoreIfQuitting_) {
            if (ignoreIfQuitting_ && _quit && *_quit) return;
            event_.set();
        }
        static inline void waitForEvent(OpenSkyNet::Utils::SyncEvent& event_, bool ignoreIfQuitting_) {
            if (ignoreIfQuitting_ && _quit && *_quit) return;
            event_.wait();
        }

        static inline void setPerformEvent(bool ignoreIfQuitting_) {
            setEvent(_performEvent,ignoreIfQuitting_);
        }
        static inline void waitForPerformEvent(bool ignoreIfQuitting_) {
            waitForEvent(_performEvent,ignoreIfQuitting_);
        }

        #define OVERRIDE_GROUNDED   (1 << 0) // rendering thread -> game thread
        #define OVERRIDE_DEAD       (1 << 1) // rendering thread -> game thread
        #define OVERRIDE_EVOCATION  (1 << 2) // game thread -> rendering thread

        struct Override {
        public:
            int _flags;
            bool _isGrounded, _isDead;
            std::string _name;
            Override() : _flags(0), _isGrounded(false), _isDead(false) {}
        } _override;

        OpenSkyNet::Utils::uint getNetworkId() const { return _networkId; }

        static OpenSkyNet::Utils::uint getAttributesBufferLen();
        static OpenSkyNet::Utils::uint serializeAttributes(const Warrior* warrior_, char (&buffer_)[MAX_STRING_SIZE]);
        static void assembleAttributes(char (&buffer_)[MAX_STRING_SIZE], std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_);

        static OpenSkyNet::Utils::uint getActionsBufferLen();
        static OpenSkyNet::Utils::uint serializeActions(const Warrior* warrior_, char (&buffer_)[MAX_STRING_SIZE]);
        static void assembleActions(char (&buffer_)[MAX_STRING_SIZE], const std::vector<Warrior*>& warriors_, OpenSkyNet::Utils::uint warriorIndex_, std::list<Action*>& actions_);

        #define MOVE_UPDATE_FINAL (1 << 0)

        static OpenSkyNet::Utils::uint getMoveUpdateBufferLen();
        static OpenSkyNet::Utils::uint serializeMoveUpdate(const Warrior* warrior_, int flags_, char (&buffer_)[MAX_STRING_SIZE]);
        static void assembleMoveUpdate(char (&buffer_)[MAX_STRING_SIZE], OpenSkyNet::Utils::uint warriorIndex_, int& flags_, OpenSkyNet::Math::Point<>& pos_, OpenSkyNet::Math::Point<>& axis_, float& radians_);

        static OpenSkyNet::Utils::uint getAttackBufferLen();
        static OpenSkyNet::Utils::uint serializeAttack(const std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_, char (&buffer_)[MAX_STRING_SIZE]);
        static void assembleAttack(char (&buffer_)[MAX_STRING_SIZE], std::vector<OpenSkyNet::Utils::TaggedUnion>& eventParams_);
    };
}

#endif //TACTICS3DWARRIOR_H