ASR::Level Class Reference

A Level manages which squares on the map are occupied and which ones are free to walk across. More...

#include <Level.h>

List of all members.

Public Types
typedef vector< Unit * >	UnitList
typedef vector< Team * >	TeamList
typedef VectorIterator< TeamList >	TeamIterator
Public Member Functions
	Level ()
	~Level (void)
void	setDimensions (int cellsWide, int cellsHigh)
	Sets the dimension of the grid.
void	setWorldDimensions (float worldWidth, float worldHeight)
void	setCellSize (float width, float height)
void	reset ()
	Resets the occupied status of all squares on the grid.
void	rebuild ()
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 ()
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)
	Returns a list of all the units within the given radius of the position.
void	occupy (float worldX, float worldZ)
	Occupies the square given which would be under (worldX, worldZ) which assumes the map hasn't been rotated.
void	unoccupy (float worldX, float worldZ)
void	occupyRegion (const AxisAlignedBox &worldRegion)
void	unoccupyRegion (const AxisAlignedBox &worldRegion)
bool	isOccupied (float worldX, float worldZ)
	Determines if the given coordinates are already occupied by something.
int	getWorldHeight () const
	Retrieve the size of the world.
int	getWorldWidth () const
	Retrieve the size of the world.
int	getNumNodesWide () const
	Retrieve the number of 'level nodes' in the x-axis.
int	getNumNodesHigh () const
	Retrieve the number of 'level nodes' in the z-axis.
AStarSearchManager< LevelNode > *	getPathManager () const
	Retrieves the pathing manager.
Static Public Member Functions
static Level &	getSingleton (void)
	Override standard Singleton retrieval.
static Level *	getSingletonPtr (void)
	Override standard Singleton retrieval.
Protected Member Functions
void	_markCell (float worldX, float worldZ, bool status)
Private Member Functions
Team *	_findTeam (const String &teamName) const
Private Attributes
int	mCellsWide
	The number of grid squares per dimension.
int	mCellsHigh
float	mCellWidth
	The size of the grid cells.
float	mCellHeight
float	mWorldWidth
	The world space dimensions this Level overlays.
float	mWorldHeight
AStarSearchManager< LevelNode > *	mPathManager
vector< LevelNode >	mOccupied
	Cell occupied status ( column + [row * mCellsWide] form).
TeamList	mTeams
Friends
class	LevelStatusVisualizer
	Debugging utility.
Classes
class	LevelNode

---

Detailed Description

A Level manages which squares on the map are occupied and which ones are free to walk across.

Users specify the world space dimensions of the map this Level should overlay as well as the dimensions of the grid system used by the Level. For example, a world that is 100x100 may contain a level which uses a grid system of 10x10. This would obviously result in poor path finding.

A grid square is occupied if any object is within the bounds of the world space area the grid square covers. In the example above, if any unit is in the first 10x10 area in world space, the entire area is marked as being occupied. Smaller regions should be used to allow only a single unit to stand in a grid square.

NOTE Almost every method in this class is dependent on the resolution of the grid.

TODO Support paging so that the map can be broken up into smaller pieces.

Add support for rotated maps

Definition at line 53 of file Level.h.

---

Member Typedef Documentation

typedef VectorIterator<TeamList> ASR::Level::TeamIterator

Definition at line 186 of file Level.h.

typedef vector<Team*> ASR::Level::TeamList

Definition at line 158 of file Level.h.

typedef vector<Unit*> ASR::Level::UnitList

Definition at line 157 of file Level.h.

---

Constructor & Destructor Documentation

ASR::Level::Level

(

)

Definition at line 34 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, mCellWidth, mOccupied, mPathManager, mWorldHeight, and mWorldWidth.

        {
                mOccupied.clear ();
                mCellsWide = 0;
                mCellsHigh = 0;

                mCellWidth = 0.0f;
                mCellHeight = 0.0f;

                mWorldWidth = 0.0f;
                mWorldHeight = 0.0f;

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

ASR::Level::~Level

(

void

)

Definition at line 51 of file Level.cpp.

References mOccupied, mPathManager, and removeAllTeams().

        {
                mOccupied.clear ();
                removeAllTeams ();

                delete mPathManager;
        }

---

Member Function Documentation

Team * ASR::Level::_findTeam

(

const String &

teamName

)

const [private]

Definition at line 314 of file Level.cpp.

References mTeams.

Referenced by createTeam().

        {
                TeamList::const_iterator iter = mTeams.begin();
                while ( iter != mTeams.end() )
                {
                        if ( (*iter)->getName() == teamName )
                        {
                                return ( *iter );
                        }
                        iter++;
                }

                return NULL;
        }

void ASR::Level::_markCell	(	float	worldX,
		float	worldZ,
		bool	status
	)			[protected]

Definition at line 384 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, mCellWidth, and mOccupied.

Referenced by occupyRegion(), and unoccupyRegion().

        {
                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 );
        }

Team * ASR::Level::createTeam	(	const String &	teamName,
		const ColourValue &	teamColor
	)

Definition at line 195 of file Level.cpp.

References _findTeam(), and mTeams.

Referenced by TutorialApplication::_createTeamB(), TutorialApplication::_createTeamC(), and ASR::Client::createTeam().

        {
                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;
        }

Level::UnitList ASR::Level::getAdjacentUnits	(	const Vector3 &	position,
		float	radius
	)

Returns a list of all the units within the given radius of the position.

Definition at line 331 of file Level.cpp.

Referenced by ASR::Team::findTargets().

        {
                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 ASR::Level::getCellLocation	(	const Vector3 &	worldPos,
		int *	x,
		int *	z
	)

Definition at line 469 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, and mCellWidth.

Referenced by ASR::LevelStatusVisualizer::_paintUnitPaths().

        {
                (*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" );
        }

Level::LevelNode * ASR::Level::getClosestNode

(

const Vector3 &

worldPos

)

Definition at line 408 of file Level.cpp.

References ASR::Level::LevelNode::getNeighbour(), ASR::Level::LevelNode::getNumNeighbours(), ASR::Level::LevelNode::getTraversalCost(), mCellHeight, mCellsHigh, mCellsWide, mCellWidth, ASR::Level::LevelNode::mChecked, and mOccupied.

Referenced by ASR::UnitSelecter::_moveUnits().

        {
                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" );
        }

Level::TeamList ASR::Level::getEnemyTeams

(

const Team *

friendlyTeam

)

Definition at line 284 of file Level.cpp.

References mTeams.

Referenced by ASR::ClientUpdater::_findVisibleObjects(), and ASR::TeamUnits::findTargets().

        {
                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;
        }

Level::LevelNode * ASR::Level::getNode

(

const Vector3 &

worldPos

)

Definition at line 61 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, mCellWidth, and mOccupied.

        {
                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];
        }

Vector3 ASR::Level::getNodeWorldPosition	(	int	cellX,
		int	cellZ
	)

Definition at line 181 of file Level.cpp.

References mCellHeight, and mCellWidth.

        {
                float worldPosX = cellX * mCellWidth;
                float worldPosY = cellZ * mCellHeight;

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

int ASR::Level::getNumNodesHigh

(

)

const

Retrieve the number of 'level nodes' in the z-axis.

Definition at line 501 of file Level.cpp.

References mCellsHigh.

Referenced by ASR::TeamUnits::getAdjacentUnits(), and ASR::FogOfWar::isUnitVisible().

        {
                return mCellsHigh;
        }

int ASR::Level::getNumNodesWide

(

)

const

Retrieve the number of 'level nodes' in the x-axis.

Definition at line 494 of file Level.cpp.

References mCellsWide.

Referenced by ASR::TeamUnits::getAdjacentUnits(), and ASR::FogOfWar::isUnitVisible().

        {
                return mCellsWide;
        }

size_t ASR::Level::getNumTeams

(

)

Definition at line 262 of file Level.cpp.

References mTeams.

        {
                return mTeams.size();
        }

AStarSearchManager< Level::LevelNode > * ASR::Level::getPathManager

(

)

const

Retrieves the pathing manager.

TODO Move this into it's own PathManager so that we can just retrieve the interface and use a generic pathing engine instead of relying on the fact that we are using A*

Definition at line 508 of file Level.cpp.

References mPathManager.

        {
                return mPathManager;
        }

Level & ASR::Level::getSingleton

(

void

)

[static]

Override standard Singleton retrieval.

Remarks:

Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll.

This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors.

Definition at line 28 of file Level.cpp.

Referenced by ASR::ClientUpdater::_findVisibleObjects(), ASR::UnitSelecter::_moveUnits(), ASR::Building::Building(), ASR::Client::createTeam(), ASR::TeamUnits::findTargets(), ASR::Team::findTargets(), ASR::TeamUnits::getAdjacentUnits(), ASR::FogOfWar::isUnitVisible(), ASR::FogOfWar::setVisible(), ASR::Team::Team(), ASR::Building::translate(), and ASR::TeamUnits::updateSpatialGrid().

        {  
                assert( ms_Singleton );  return ( *ms_Singleton );  
        }

Level * ASR::Level::getSingletonPtr

(

void

)

[static]

Override standard Singleton retrieval.

Remarks:

Why do we do this? Well, it's because the Singleton implementation is in a .h file, which means it gets compiled into anybody who includes it. This is needed for the Singleton template to work, but we actually only want it compiled into the implementation of the class based on the Singleton, not all of them. If we don't change this, we get link errors when trying to use the Singleton-based class from an outside dll.

This method just delegates to the template version anyway, but the implementation stays in this single compilation unit, preventing link errors.

Definition at line 24 of file Level.cpp.

        {
                return ms_Singleton;
        }

Team * ASR::Level::getTeam

(

size_t

teamIndex

)

Definition at line 269 of file Level.cpp.

References mTeams.

Referenced by TutorialApplication::createFrameListener().

        {
                assert ( teamIndex < mTeams.size() );
                return mTeams[teamIndex];
        }

Level::TeamIterator ASR::Level::getTeamIterator

(

)

Definition at line 277 of file Level.cpp.

References mTeams.

Referenced by ASR::LevelStatusVisualizer::_paintUnitPaths().

        {
                return TeamIterator ( mTeams.begin(), mTeams.end() );
        }

int ASR::Level::getWorldHeight

(

)

const

Retrieve the size of the world.

Definition at line 487 of file Level.cpp.

References mWorldHeight.

Referenced by ASR::TeamUnits::getAdjacentUnits(), ASR::FogOfWar::isUnitVisible(), and ASR::TeamUnits::updateSpatialGrid().

        {
                return mWorldHeight;
        }

int ASR::Level::getWorldWidth

(

)

const

Retrieve the size of the world.

Definition at line 480 of file Level.cpp.

References mWorldWidth.

Referenced by ASR::TeamUnits::getAdjacentUnits(), ASR::FogOfWar::isUnitVisible(), and ASR::TeamUnits::updateSpatialGrid().

        {
                return mWorldWidth;
        }

bool ASR::Level::isOccupied	(	float	worldX,
		float	worldZ
	)

Determines if the given coordinates are already occupied by something.

void ASR::Level::occupy	(	float	worldX,
		float	worldZ
	)

Occupies the square given which would be under (worldX, worldZ) which assumes the map hasn't been rotated.

void ASR::Level::occupyRegion

(

const AxisAlignedBox &

worldRegion

)

Definition at line 347 of file Level.cpp.

References _markCell(), mCellHeight, and mCellWidth.

Referenced by ASR::Building::Building(), and ASR::Building::translate().

        {
                // 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 ASR::Level::rebuild

(

)

Definition at line 119 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, mCellWidth, and mOccupied.

Referenced by TutorialApplication::createScene().

        {
                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 )];
                                
                        }
                }
        }

void ASR::Level::removeAllTeams

(

)

Definition at line 210 of file Level.cpp.

References mTeams.

Referenced by ~Level().

        {
                TeamList::iterator iter = mTeams.begin();
                while ( iter != mTeams.end() )
                {
                        delete (*iter);
                        iter++;
                }

                mTeams.clear ();
        }

void ASR::Level::removeTeam

(

Team *

team

)

Definition at line 243 of file Level.cpp.

References mTeams.

        {
                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" );
        }

void ASR::Level::removeTeam

(

const String &

teamName

)

Definition at line 224 of file Level.cpp.

References mTeams.

        {
                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 ASR::Level::reset

(

)

Resets the occupied status of all squares on the grid.

Definition at line 111 of file Level.cpp.

References mOccupied.

        {
                mOccupied.clear ();
                //mOccupied.resize ( mCellsWide * mCellsHigh, false );
        }

void ASR::Level::setCellSize	(	float	width,
		float	height
	)

Definition at line 99 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, mCellWidth, mWorldHeight, and mWorldWidth.

        {
                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 ASR::Level::setDimensions	(	int	cellsWide,
		int	cellsHigh
	)

Sets the dimension of the grid.

Previous occupied status is maintained for squares that remain valid (in the new dimensions) after the call. A call to 'reset' can change them

Grid square sizes are determined by [worldWidth / cellsWide] and [worldHeight / cellsHigh]. If control over the size of the grid squares is desired, use setCellSize instead.

Definition at line 80 of file Level.cpp.

References mCellHeight, mCellsHigh, mCellsWide, mCellWidth, mWorldHeight, and mWorldWidth.

Referenced by TutorialApplication::createScene().

        {
                mCellsWide = cellsWide;
                mCellsHigh = cellsHigh;

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

void ASR::Level::setWorldDimensions	(	float	worldWidth,
		float	worldHeight
	)

Definition at line 91 of file Level.cpp.

References mWorldHeight, and mWorldWidth.

Referenced by TutorialApplication::createScene().

        {
                mWorldWidth = worldWidth;
                mWorldHeight = worldHeight;
        }

void ASR::Level::unoccupy	(	float	worldX,
		float	worldZ
	)

void ASR::Level::unoccupyRegion

(

const AxisAlignedBox &

worldRegion

)

Definition at line 364 of file Level.cpp.

References _markCell(), mCellHeight, and mCellWidth.

Referenced by ASR::Building::translate().

        {
                // 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 );
                        }
                }
        }

---

Friends And Related Function Documentation

friend class LevelStatusVisualizer [friend]

Debugging utility.

Definition at line 56 of file Level.h.

---

Member Data Documentation

float ASR::Level::mCellHeight [private]

Definition at line 169 of file Level.h.

Referenced by _markCell(), getCellLocation(), getClosestNode(), getNode(), getNodeWorldPosition(), Level(), occupyRegion(), rebuild(), setCellSize(), setDimensions(), and unoccupyRegion().

int ASR::Level::mCellsHigh [private]

Definition at line 165 of file Level.h.

Referenced by _markCell(), ASR::LevelStatusVisualizer::_paintBlockedTiles(), getCellLocation(), getClosestNode(), getNode(), getNumNodesHigh(), Level(), ASR::LevelStatusVisualizer::LevelStatusVisualizer(), rebuild(), setCellSize(), and setDimensions().

int ASR::Level::mCellsWide [private]

The number of grid squares per dimension.

Definition at line 164 of file Level.h.

Referenced by _markCell(), ASR::LevelStatusVisualizer::_paintBlockedTiles(), ASR::LevelStatusVisualizer::_paintUnitPaths(), getCellLocation(), getClosestNode(), getNode(), getNumNodesWide(), Level(), ASR::LevelStatusVisualizer::LevelStatusVisualizer(), rebuild(), setCellSize(), and setDimensions().

float ASR::Level::mCellWidth [private]

The size of the grid cells.

Definition at line 168 of file Level.h.

Referenced by _markCell(), getCellLocation(), getClosestNode(), getNode(), getNodeWorldPosition(), Level(), occupyRegion(), rebuild(), setCellSize(), setDimensions(), and unoccupyRegion().

vector<LevelNode> ASR::Level::mOccupied [private]

Cell occupied status ( column + [row * mCellsWide] form).

Definition at line 178 of file Level.h.

Referenced by _markCell(), ASR::LevelStatusVisualizer::_paintBlockedTiles(), getClosestNode(), getNode(), Level(), rebuild(), reset(), and ~Level().

AStarSearchManager<LevelNode>* ASR::Level::mPathManager [private]

Definition at line 175 of file Level.h.

Referenced by getPathManager(), Level(), and ~Level().

TeamList ASR::Level::mTeams [private]

Definition at line 180 of file Level.h.

Referenced by _findTeam(), createTeam(), getEnemyTeams(), getNumTeams(), getTeam(), getTeamIterator(), removeAllTeams(), and removeTeam().

float ASR::Level::mWorldHeight [private]

Definition at line 173 of file Level.h.

Referenced by getWorldHeight(), Level(), setCellSize(), setDimensions(), and setWorldDimensions().

float ASR::Level::mWorldWidth [private]

The world space dimensions this Level overlays.

Definition at line 172 of file Level.h.

Referenced by getWorldWidth(), Level(), setCellSize(), setDimensions(), and setWorldDimensions().

---

The documentation for this class was generated from the following files:

• D:/simple_rts/include/Level.h
• D:/simple_rts/src/Level.cpp

---