D:/simple_rts/include/Level.h

Go to the documentation of this file.

#pragma once

#include "Team.h"
#include "AStarSearchManager.h"

#include "OgreVector3.h"
#include "OgreMath.h"
#include "OgreSingleton.h"
#include "OgreColourValue.h"
#include "OgreIteratorWrappers.h"
#include "OgreAxisAlignedBox.h"

#include <vector>
using std::vector;

using Ogre::ColourValue;
using Ogre::AxisAlignedBox;
using Ogre::VectorIterator;
using Ogre::Singleton;
using Ogre::Vector3;
using Ogre::Math;



namespace ASR
{
        class Unit;
        class Building;
        class Level : public Singleton<Level>
        {
                friend  class LevelStatusVisualizer;


        // Internal Classes
        // ----------------------------------------------------------------------------
        public:
                class LevelNode
                {
                        friend class Level;

                // Data Storage
                // ----------------------------------------------------------------------------
                private:
                        Vector3                 mWorldPos;
                        float                   mTraversalCost;
                        unsigned int    mId;

                        // Useful for performing graph searches
                        // This will not be persistent. That is, it will only be valid in the
                        // current call in which you are modifying it. Other calls may use it
                        // so do not rely on it being the same value from call to call
                        bool                    mChecked;

                        int                             mNumNeighbours;
                        LevelNode*              mNeighbours[8];

                // Construction
                // ----------------------------------------------------------------------------
                public:
                        LevelNode ( Vector3 worldPos, float traversalCost = 1.0f )
                                : mWorldPos ( worldPos ), mTraversalCost ( traversalCost ),
                                  mNumNeighbours ( 0 )
                        {
                                for ( int i = 0; i < 8; i++ )
                                {
                                        mNeighbours[i] = NULL;
                                }
                        }

                        void setTraversalCost ( float cost )
                        {
                                mTraversalCost = cost;
                        }


                // Implementation for use in AStarSearch as a UserState
                // ----------------------------------------------------------------------------
                public:
                        int getNumNeighbours () const
                        {
                                return mNumNeighbours;
                        }

                        // ----------------------------------------------------------------------------
                        LevelNode* getNeighbour ( int index ) const
                        {
                                assert ( index < mNumNeighbours );
                                return mNeighbours[index];
                        }
                        
                        // ----------------------------------------------------------------------------
                        float getTraversalCost () const
                        {
                                return mTraversalCost;
                        }

                        // ----------------------------------------------------------------------------
                        float getEstimatedCostToState ( const LevelNode& state ) const
                        {
                                Vector3 distance;
                                distance = state.mWorldPos - mWorldPos;
                                return distance.length ();
                        }


                        // ----------------------------------------------------------------------------
                        Vector3 getWorldPosition ()
                        {
                                return mWorldPos;
                        }

                        // ----------------------------------------------------------------------------
                        bool operator== ( const LevelNode& rhs ) const
                        {
                                return mId == rhs.mId;

                                Vector3 distance = mWorldPos - rhs.mWorldPos;
                                return distance.isZeroLength ();
                        }


                        // ----------------------------------------------------------------------------
                        bool isNode ( const LevelNode& rhs ) const
                        {
                                return operator== ( rhs );
                        }
                };

        // Data Types
        // ----------------------------------------------------------------------------
        public:
                typedef vector<Unit*>                           UnitList;
                typedef vector<Team*>                           TeamList;

        // Data Storage
        // ----------------------------------------------------------------------------
        private:
                int             mCellsWide;
                int             mCellsHigh;

                float   mCellWidth;
                float   mCellHeight;

                float   mWorldWidth;
                float   mWorldHeight;

                AStarSearchManager<LevelNode>*          mPathManager;

                vector<LevelNode>       mOccupied;

                TeamList                                                        mTeams;


        // Data Types
        // ----------------------------------------------------------------------------
        public:
                typedef VectorIterator<TeamList>        TeamIterator;



        // Construction
        // ----------------------------------------------------------------------------
        public:
                Level();
                ~Level(void);

                static Level& getSingleton(void);
                static Level* getSingletonPtr(void);

        // Setup
        // ----------------------------------------------------------------------------
        public:
                void setDimensions ( int cellsWide, int cellsHigh );

                void setWorldDimensions ( float worldWidth, float worldHeight );

                void setCellSize ( float width, float height );

                void reset ();

                void rebuild ();


        // Team Management
        // ----------------------------------------------------------------------------
        public:
                Team* createTeam ( const String& teamName, const ColourValue& teamColor );
                void removeAllTeams ();
                void removeTeam ( const String& teamName );
                void removeTeam ( Team* team );
                size_t getNumTeams ();
                Team* getTeam ( size_t teamIndex );
                TeamList getEnemyTeams ( const Team* friendlyTeam );

                TeamIterator getTeamIterator ();

        private:
                Team* _findTeam ( const String& teamName ) const;


        // Query Functions
        // ----------------------------------------------------------------------------
        public:
                LevelNode* getNode ( const Vector3& worldPos );
                void getCellLocation ( const Vector3& worldPos, int* x, int* z );
                Vector3 getNodeWorldPosition ( int cellX, int cellZ );
                LevelNode* getClosestNode ( const Vector3& worldPos );

                UnitList getAdjacentUnits ( const Vector3& position, float radius );

                void occupy ( float worldX, float worldZ );
                void unoccupy ( float worldX, float worldZ );

                void occupyRegion ( const AxisAlignedBox& worldRegion );
                void unoccupyRegion ( const AxisAlignedBox& worldRegion );

                bool isOccupied ( float worldX, float worldZ );

                int getWorldHeight () const;

                int getWorldWidth () const;

                int getNumNodesWide () const;

                int getNumNodesHigh () const;

                AStarSearchManager<LevelNode>* getPathManager () const;


                


        // Helpers
        // ----------------------------------------------------------------------------
        protected:
                void _markCell ( float worldX, float worldZ, bool status );
        };
}

---