D:/simple_rts/src/Level.cpp

Go to the documentation of this file.

#include "Level.h"

#include "Unit.h"
#include "Building.h"
#include "OgreColourValue.h"

#include "OgreException.h"

#include <math.h>
#include <assert.h>
#include <queue>

using Ogre::ColourValue;
using Ogre::Exception;
using std::queue;


template<> ASR::Level* Singleton<ASR::Level>::ms_Singleton = 0;


namespace ASR
{
        // ----------------------------------------------------------------------------
        Level* Level::getSingletonPtr(void)
        {
                return ms_Singleton;
        }
        Level& Level::getSingleton(void)
        {  
                assert( ms_Singleton );  return ( *ms_Singleton );  
        }

        // ----------------------------------------------------------------------------
        Level::Level()
        {
                mOccupied.clear ();
                mCellsWide = 0;
                mCellsHigh = 0;

                mCellWidth = 0.0f;
                mCellHeight = 0.0f;

                mWorldWidth = 0.0f;
                mWorldHeight = 0.0f;

                mPathManager = new AStarSearchManager<Level::LevelNode> ();
        }


        // ----------------------------------------------------------------------------
        Level::~Level(void)
        {
                mOccupied.clear ();
                removeAllTeams ();

                delete mPathManager;
        }


        // ----------------------------------------------------------------------------
        Level::LevelNode* Level::getNode ( const Vector3& worldPos )
        {
                assert ( mCellWidth > 0.0f );
                assert ( mCellHeight > 0.0f );

                assert ( worldPos.x >= 0.0f );
                assert ( worldPos.z >= 0.0f );

                int cellX = int(floor(worldPos.x / mCellWidth));
                int cellY = int(floor(worldPos.z / mCellHeight ));

                if ( cellX >= mCellsWide || cellY >= mCellsHigh )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Position is outside of the terrain bounds", "Level::getNode" );

                return &mOccupied[cellX + cellY * mCellsWide];
        }


        // ----------------------------------------------------------------------------
        void Level::setDimensions ( int cellsWide, int cellsHigh )
        {
                mCellsWide = cellsWide;
                mCellsHigh = cellsHigh;

                mCellWidth = mWorldWidth / (float)mCellsWide;
                mCellHeight = mWorldHeight / (float)mCellsHigh;
        }


        // ----------------------------------------------------------------------------
        void Level::setWorldDimensions ( float worldWidth, float worldHeight )
        {
                mWorldWidth = worldWidth;
                mWorldHeight = worldHeight;
        }


        // ----------------------------------------------------------------------------
        void Level::setCellSize ( float width, float height )
        {
                mCellWidth = width;
                mCellHeight = height;

                // There may be only a little bit of a cell at the edges
                mCellsWide = int(ceil( mWorldWidth / mCellWidth ));
                mCellsHigh = int(ceil( mWorldHeight / mCellHeight ));
        }


        // ----------------------------------------------------------------------------
        void Level::reset ()
        {
                mOccupied.clear ();
                //mOccupied.resize ( mCellsWide * mCellsHigh, false );
        }


        // ----------------------------------------------------------------------------
        void Level::rebuild ()
        {
                mOccupied.clear ();
                unsigned int Id = 0;

                for ( int z = 0; z < mCellsHigh; z++ )
                {
                        for ( int x = 0; x < mCellsWide; x++ )
                        {
                                LevelNode node ( Vector3(x * mCellWidth, 0, z * mCellHeight ) );
                                node.mId = Id++;
                                mOccupied.push_back ( node );
                        }
                }

                // Assign neighbours now that the level is built
                for ( int z = 0; z < mCellsHigh; z++ )
                {
                        for ( int x = 0; x < mCellsWide; x++ )
                        {
                                LevelNode& node = mOccupied[z * mCellsWide + x];
                                node.mNumNeighbours = 0;

                                // Use the tile above this one
                                if ( z != 0 )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[(z - 1) * mCellsWide + x];

                                // Use the tile below this one
                                if ( z < (mCellsHigh - 1) )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[(z + 1) * mCellsWide + x];

                                // Use the tile to the left of this one
                                if ( x != 0 )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[( z ) * mCellsWide + (x - 1)];

                                // Use the tile to the right of this one
                                if ( x < (mCellsWide - 1) )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[( z ) * mCellsWide + (x + 1)];

                                
                                // Use the top-left tile
                                if ( x > 0 && z > 0 )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[( z - 1 ) * mCellsWide + ( x - 1 )];

                                // Use the top-right tile
                                if ( x < (mCellsWide - 1) && z > 0 )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[( z - 1 ) * mCellsWide + ( x + 1 )];

                                // Use the bottom-left tile
                                if ( x > 0 && z < (mCellsHigh - 1) )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[( z + 1 ) * mCellsWide + ( x - 1 )];

                                // Use the bottom-right tile
                                if ( x < (mCellsWide - 1) && z < (mCellsHigh - 1) )
                                        node.mNeighbours[node.mNumNeighbours++] = &mOccupied[( z + 1 ) * mCellsWide + ( x + 1 )];
                                
                        }
                }
        }


        // ----------------------------------------------------------------------------
        Vector3 Level::getNodeWorldPosition ( int cellX, int cellZ )
        {
                float worldPosX = cellX * mCellWidth;
                float worldPosY = cellZ * mCellHeight;

                return Vector3( worldPosX, 0.0f, worldPosY );
        }


        // ----------------------------------------------------------------------------
        // TEAM MANAGEMENT //
        // ----------------------------------------------------------------------------

        // ----------------------------------------------------------------------------
        Team* Level::createTeam ( const String& teamName, const ColourValue& teamColor )
        {
                if ( _findTeam ( teamName ) != NULL )
                        throw Exception ( Exception::ERR_DUPLICATE_ITEM, "Team already exists", "Level::createTeam" );

                Team* newTeam = new Team ( teamName, teamColor );
                mTeams.push_back ( newTeam );

                // TODO
                //              Register an updater for the team
                return newTeam;
        }


        // ----------------------------------------------------------------------------
        void Level::removeAllTeams ()
        {
                TeamList::iterator iter = mTeams.begin();
                while ( iter != mTeams.end() )
                {
                        delete (*iter);
                        iter++;
                }

                mTeams.clear ();
        }


        // ----------------------------------------------------------------------------
        void Level::removeTeam ( const String& teamName )
        {
                TeamList::iterator iter = mTeams.begin();
                while ( iter != mTeams.end () )
                {
                        if ( (*iter)->getName() == teamName )
                        {
                                delete (*iter);
                                mTeams.erase ( iter );
                                return;
                        }
                        iter++;
                }

                throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Cannot find team", "Team::removeTeam" );
        }


        // ----------------------------------------------------------------------------
        void Level::removeTeam ( Team* team )
        {
                TeamList::iterator iter = mTeams.begin();
                while ( iter != mTeams.end() )
                {
                        if ( (*iter) == team )
                        {
                                delete (*iter);
                                mTeams.erase ( iter );
                                return;
                        }
                        iter++;
                }

                throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Cannot find team", "Team::removeTeam" );
        }


        // ----------------------------------------------------------------------------
        size_t Level::getNumTeams ()
        {
                return mTeams.size();
        }


        // ----------------------------------------------------------------------------
        Team* Level::getTeam ( size_t teamIndex )
        {
                assert ( teamIndex < mTeams.size() );
                return mTeams[teamIndex];
        }


        // ----------------------------------------------------------------------------
        Level::TeamIterator Level::getTeamIterator ()
        {
                return TeamIterator ( mTeams.begin(), mTeams.end() );
        }


        // ----------------------------------------------------------------------------
        Level::TeamList Level::getEnemyTeams ( const Team* friendlyTeam )
        {
                TeamList enemyTeams;

                TeamList::iterator baseTeam = find ( mTeams.begin(), mTeams.end(), friendlyTeam );
                if ( baseTeam == mTeams.end() )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Couldn't find team", "Level::getEnemyTeams" );

                TeamList::iterator curIter = mTeams.begin();

                // Up to but not including the base team
                while ( curIter != baseTeam )
                {
                        enemyTeams.push_back ( *curIter );
                        curIter++;
                }

                // Now the other half of the list
                curIter = baseTeam + 1;
                while (curIter != mTeams.end() )
                {
                        enemyTeams.push_back ( *curIter );
                        curIter++;
                }

                return enemyTeams;
        }


        // ----------------------------------------------------------------------------
        Team* Level::_findTeam ( const String& teamName ) const
        {
                TeamList::const_iterator iter = mTeams.begin();
                while ( iter != mTeams.end() )
                {
                        if ( (*iter)->getName() == teamName )
                        {
                                return ( *iter );
                        }
                        iter++;
                }

                return NULL;
        }


        // ----------------------------------------------------------------------------
        Level::UnitList Level::getAdjacentUnits ( const Vector3& position, float radius )
        {
                UnitList units;

                // TODO
                //              Loop over each team
                //                      Loop over each unit from each team
                //                              if the unit is within 'radius' units of 'position'
                //                              add it to the list
                //
                //              This can be done a lot more efficiently with a quadtree structure
                return units;
        }


        // ----------------------------------------------------------------------------
        void Level::occupyRegion ( const AxisAlignedBox& worldRegion )
        {
                // TODO
                //              Possibly use only 90% of mCellHeight to account for floating point
                //              errors which may end up making us skip a cell. With 90%, we have
                //              overlap but at least we cover all the cells
                for ( float worldZ = worldRegion.getMinimum ().z; worldZ < worldRegion.getMaximum ().z; worldZ += mCellHeight )
                {
                        for ( float worldX = worldRegion.getMinimum ().x; worldX < worldRegion.getMaximum ().x; worldX += mCellWidth )
                        {
                                _markCell ( worldX, worldZ, true );
                        }
                }
        }


        // ----------------------------------------------------------------------------
        void Level::unoccupyRegion ( const AxisAlignedBox& worldRegion )
        {
                // TODO
                //              Possibly use only 90% of mCellHeight to account for floating point
                //              errors which may end up making us skip a cell. With 90%, we have
                //              overlap but at least we cover all the cells
                float startX = (worldRegion.getMinimum ().x < 0.0f) ? 0.0f : worldRegion.getMinimum ().x;
                float startZ = (worldRegion.getMinimum ().z < 0.0f) ? 0.0f : worldRegion.getMinimum ().z;

                for ( float worldZ = startZ; worldZ < worldRegion.getMaximum ().z; worldZ += mCellHeight )
                {
                        for ( float worldX = startX; worldX < worldRegion.getMaximum ().x; worldX += mCellWidth )
                        {
                                _markCell ( worldX, worldZ, false );
                        }
                }
        }


        // ----------------------------------------------------------------------------
        void Level::_markCell ( float worldX, float worldZ, bool status )
        {
                assert ( mCellWidth > 0.0f );
                assert ( mCellHeight > 0.0f );

                assert ( worldX >= 0.0f );
                assert ( worldZ >= 0.0f );

                int cellX;
                int cellY;

                cellX = int(floor(worldX / mCellWidth));
                cellY = int(floor(worldZ / mCellHeight ));

                if ( cellX >= mCellsWide || cellY >= mCellsHigh )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Position is outside of the bounds of the terrain", "Level::_markCell" );

                float cost;
                cost = ( status ) ? -1.0f : 1.0f;
                mOccupied[cellX + cellY * mCellsWide].setTraversalCost ( cost );
        }


        // ----------------------------------------------------------------------------
        Level::LevelNode* Level::getClosestNode ( const Vector3& worldPos )
        {
                assert ( mCellWidth > 0.0f );
                assert ( mCellHeight > 0.0f );

                assert ( worldPos.x >= 0.0f );
                assert ( worldPos.z >= 0.0f );

                int cellX = int(floor(worldPos.x / mCellWidth));
                int cellY = int(floor(worldPos.z / mCellHeight ));

                if ( cellX >= mCellsWide || cellY >= mCellsHigh )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Position is out of the terrain bounds", "Level::getClosestNode" );

                if ( mOccupied[cellX + cellY * mCellsWide].getTraversalCost () >= 0.0f )
                        return &mOccupied[cellX + cellY * mCellsWide];

                // Perform a breadth-first search to find the closest cell
                std::queue<Level::LevelNode*> open;
                mOccupied[cellX + cellY * mCellsWide].mChecked = true;
                open.push ( &mOccupied[cellX + cellY * mCellsWide] );

                // TODO
                //              Come up with a better way other than resetting every single node
                //              in the entire level
                for ( int z = 0; z < mCellsHigh; z++ )
                {
                        for ( int x = 0; x < mCellsWide; x++ )
                        {
                                mOccupied[x + z * mCellsWide].mChecked = false;
                        }
                }

                Level::LevelNode* node;
                Level::LevelNode* curNeighbour;
                while ( !open.empty() )
                {
                        node = open.front();
                        open.pop();
                        for ( int i = 0; i < node->getNumNeighbours (); i++ )
                        {
                                curNeighbour = node->getNeighbour (i);
                                if ( !curNeighbour->mChecked )
                                {
                                        // We found a neighbour that we can use
                                        if ( curNeighbour->getTraversalCost () >= 0.0f )
                                        {
                                                return curNeighbour;
                                        }
                                        
                                        curNeighbour->mChecked = true;
                                        open.push ( curNeighbour );
                                }
                        }
                }

                throw Exception ( Exception::ERR_INTERNAL_ERROR, "Cannot find a valid node in the entire level", "Level::getClosestNode" );
        }


        // ----------------------------------------------------------------------------
        void Level::getCellLocation (const Vector3& worldPos, int* x, int* z )
        {
                (*x) = int(floor(worldPos.x / mCellWidth));
                (*z) = int(floor(worldPos.z / mCellHeight ));

                if ( (*x) >= mCellsWide || (*z) >= mCellsHigh || (*z) < 0 || (*x) < 0 )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Position is outside of the bounds of the terrain", "Level::getCellLocation" );
        }


        // ----------------------------------------------------------------------------
        int Level::getWorldWidth () const
        {
                return mWorldWidth;
        }


        // ----------------------------------------------------------------------------
        int Level::getWorldHeight () const
        {
                return mWorldHeight;
        }


        // ----------------------------------------------------------------------------
        int Level::getNumNodesWide () const
        {
                return mCellsWide;
        }


        // ----------------------------------------------------------------------------
        int Level::getNumNodesHigh () const
        {
                return mCellsHigh;
        }


        // ----------------------------------------------------------------------------
        AStarSearchManager<Level::LevelNode>* Level::getPathManager () const
        {
                return mPathManager;
        }
}

---