Tactics3DNPC.h

Go to the documentation of this file.

//    Copyright (C) 2008-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 TACTICS3DNPC_H
#define TACTICS3DNPC_H

#include "Tactics3DWarrior.h"

#include "../Libs/Core_LIB/IAIWrapperObject.h"
#include "../Libs/Core_LIB/ITransformChangeListener.h"
#include "../Libs/Math_LIB/MPath.h"

namespace Tactics3D {
    class NPC : public Warrior, public OpenSkyNet::Core::AIWrapperObject, public OpenSkyNet::Core::TransformChangeListener {
    public:
        static std::vector<Warrior*>* _warriors;

        NPC(OpenSkyNet::Utils::uint networkId_, OpenSkyNet::Core::PhysVisObject* pVO_, 
            int gp_, int lvl_, int dex_, int str_, int end_, TEAM team_);

        virtual ~NPC() {}

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

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

        virtual OpenSkyNet::Math::Point<> getVel() const { return Warrior::getVel(); }
        virtual void getVel(OpenSkyNet::Math::Point<>& vel_) const { Warrior::getVel(vel_); }
        virtual void setVel(const OpenSkyNet::Math::Point<>& vel_) { Warrior::setVel(vel_); }
        virtual bool getHasVelChanged() const { return Warrior::getHasVelChanged(); }
        virtual void setHasVelChanged(bool val_) { Warrior::setHasVelChanged(val_); }

        virtual OpenSkyNet::Math::Point<> getAngVel() const { return Warrior::getAngVel(); }
        virtual void getAngVel(OpenSkyNet::Math::Point<>& angVel_) const { Warrior::getAngVel(angVel_); }
        virtual void setAngVel(const OpenSkyNet::Math::Point<>& angVel_) { Warrior::setAngVel(angVel_); }
        virtual bool getHasAngVelChanged() const { return Warrior::getHasAngVelChanged(); }
        virtual void setHasAngVelChanged(bool val_) { Warrior::setHasAngVelChanged(val_); }

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

        virtual const std::string& getName() const { return Warrior::getName(); }
        virtual void setName(const std::string& name_) { Warrior::setName(name_); }

        virtual void doAction();

        virtual void handleTransformChange(OpenSkyNet::Core::Object* obj_, const OpenSkyNet::Math::Point<>& prevPos_, const OpenSkyNet::Math::Matrix3x3& prevRot_, float dt_);
        virtual void handleIdle(OpenSkyNet::Core::Object* obj_, float idleSecs_);

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

        virtual void onPrePerformAnyAction(const std::vector<Warrior*>& warriors_);
        virtual void onMove();

        virtual void setActions();

        inline const OpenSkyNet::Math::Point<>& getPosPrePerformAnyAction() const { return _posPrePerformAnyAction; }

        inline const OpenSkyNet::Math::Path& getPath() const { return _path; }
    private:
        bool _isPerforming;
        float _idleSecs;
        OpenSkyNet::Math::Point<> _posPrePerformAnyAction;
        OpenSkyNet::Math::Path _path;
    };
}

#endif //TACTICS3DNPC_H