D:/simple_rts/include/Unit.h

Go to the documentation of this file.

#ifndef __UNIT_H__
#define __UNIT_H__

#pragma once

#include "Level.h"
#include "AStarSearchManager.h"


#include "OgreSceneManager.h"
#include "OgreSceneNode.h"
#include "OgreVector3.h"
#include "OgreString.h"
#include "OgreEntity.h"
#include "OgreMath.h"
#include "OgreUserDefinedObject.h"
#include "OgreIteratorWrappers.h"
#include "OgreAnimationState.h"

#include <list>
#include <vector>

using Ogre::AnimationState;
using Ogre::VectorIterator;
using Ogre::UserDefinedObject;
using Ogre::SceneManager;
using Ogre::SceneNode;
using Ogre::Node;
using Ogre::Vector3;
using Ogre::String;
using Ogre::Entity;
using Ogre::Real;

using std::list;
using std::vector;


// TODO
//              Implement a global LevelManager (singleton) that has the
//              scene manager as a part of that. Lots of classes use this
//              and it will save passing it all over the place
//              Also, getTerrainHeight (x,z) can also be implemented there
//              so a single scene query is used.
//
//              Implement getTypeID from UserDefinedObject so we can make
//              sure we are casting the right type of object.
// ----------------------------------------------------------------------------
namespace ASR
{
        class Projectile;

        // ----------------------------------------------------------------------------
        class Unit : public UserDefinedObject
        {
        // ----------------------------------------------------------------------------
        public:
                static String   TYPE_NAME;

                typedef VectorIterator<list<Vector3>>   WaypointIterator;

                enum UnitStatus
                {
                        US_IDLE,
                        US_MOVING,
                        US_DYING,
                        US_DEAD,
                        US_ATTACKING,
                        US_CHASING
                };

        // Unit Statistics
        // ----------------------------------------------------------------------------
        private:
                int                     mCurHitPoints;
                int                     mMaxHitPoints;

                float           mRange;
                float           mSightRadius;


        // Battle Information
        // ----------------------------------------------------------------------------
        private:
                // The current target to attack
                Unit*           mTarget;

                // The time that's elapsed since the previous attack
                float           mAttackTime;

                float           mFireRate;

                typedef vector<Projectile*>                     BulletList;
                BulletList                                                      mProjectiles;


        // Animation
        // ----------------------------------------------------------------------------
        private:
                AnimationState*         mAnimationState;


        // Data Storage
        // ----------------------------------------------------------------------------
        private:

                bool            mNavDirty;

                Entity*         mEntity;

        // HACKS
        public:
                Entity*         mShoulder;
                Entity*         mShield;
                Entity*         mWeapon;

        private:

                String          mMeshName;
                String          mUnitName;

                SceneNode*      mUnitNode;

                static int      mNumUnits;

                AStarSearch<Level::LevelNode>*  mSearch;
                list<Vector3>                                   mWaypoints;
                
                const static float                              mSearchUpdateTime;

                float                                                   mSearchElapsedTime;

                UnitStatus      mStatus;

        // Construction
        // ----------------------------------------------------------------------------
        public:
                Unit( SceneNode* parentNode, String meshName );
                ~Unit(void);



        // Query Methods
        // ----------------------------------------------------------------------------
        public:
                // TODO
                //      Return a reference to a const String instead
                String getUnitName () const;
                Entity* getEntity ();
                const String& getTypeName () const;

                float getSightRadius () const;
                float getRange () const;


        // Misc Functions
        // ----------------------------------------------------------------------------
        public:
                void hide ();
                void show ();


                void scale ( Real x, Real y, Real z );

                void setStatus ( UnitStatus status );

                void updateAnimation ( float deltaTime );

        // Movement
        // ----------------------------------------------------------------------------
        public:
                void translate ( const Vector3& vec, Node::TransformSpace space = Node::TS_PARENT );
                Vector3 getPosition () const;
                void setPosition ( const Vector3& pos );

                void setDirection ( const Vector3& dir );
                void setDirection ( float x, float y, float z );

                void clearWaypoints ();
                void addWaypoint ( const Vector3& position );
                

                Vector3 getDestination ();

                void removeDestination ();

                bool hasDestination ();

                WaypointIterator getWaypointIterator ();

                void stopMovement ();

                bool setDestination ( const Vector3& destination );

        private:
                void _assignWaypoints ();

                void _destroySearch ();


        // Battle Functions
        // ----------------------------------------------------------------------------
        public:
                void assignTarget ( Unit* target );


                bool isEngaged () const;


                Unit* getTarget () const;

                void doAttack ();

                void assignDamage ( int damage );

                bool isDead () const;

        private:
                float _getTimeBetweenAttacks ();

                void _spawnAttack ();

                void _updateProjectiles ();

                float _getDistanceToTarget ();

                void _destroyAttacks ();

                float _calcDamage ( const Unit* unit ) const;

                void _chaseTarget ();


        // Helpers
        // ----------------------------------------------------------------------------
        private:
                void _alignToWaypoint ();
                void _alignToTarget ();
        };
}

#endif

---