ASR::TeamUnits Class Reference

#include <TeamUnits.h>

Collaboration diagram for ASR::TeamUnits:

[legend]List of all members.

Public Types
typedef vector< Unit * >	UnitList
typedef VectorIterator< UnitList >	UnitIterator
Public Member Functions
	TeamUnits (Team *parentTeam, unsigned int initialUnits=0)
	~TeamUnits ()
void	findTargets ()
Unit *	createUnit (String meshName)
void	moveUnits (float deltaTime)
void	animateUnits (float deltaTime)
UnitIterator	getUnitIterator ()
Unit *	getUnit (size_t index)
size_t	getNumUnits ()
void	performAttacks ()
void	setSpatialGridSize (int numBucketsWide, int numBucketsHigh)
UnitList	getAdjacentUnits (const Vector3 &worldPos, float radius)
	Returns a list of Units within the given radius of the specified world position.
void	updateSpatialGrid ()
	Updates the spatial information of each unit inside of the grid.
Private Types
typedef vector< UnitList >	SpatialColumn
typedef vector< SpatialColumn >	SpatialGrid
Private Member Functions
void	_clearSpatialGrid ()
	Removes all units from the grid but does not change the size.
Private Attributes
SceneNode *	mTeamNode
RaySceneQuery *	mRaySceneQuery
UnitList	mUnits
Team *	mTeam
SpatialGrid	mUnitGrid
Static Private Attributes
static int	mNumTeams = 0

---

Detailed Description

Definition at line 29 of file TeamUnits.h.

---

Member Typedef Documentation

typedef vector<UnitList> ASR::TeamUnits::SpatialColumn [private]

Definition at line 52 of file TeamUnits.h.

typedef vector<SpatialColumn> ASR::TeamUnits::SpatialGrid [private]

Definition at line 53 of file TeamUnits.h.

typedef VectorIterator<UnitList> ASR::TeamUnits::UnitIterator

Definition at line 35 of file TeamUnits.h.

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

Definition at line 34 of file TeamUnits.h.

---

Constructor & Destructor Documentation

ASR::TeamUnits::TeamUnits	(	Team *	parentTeam,
		unsigned int	initialUnits = 0
	)

Definition at line 43 of file TeamUnits.cpp.

References ASR::Team::getName(), ASR::Game::getSceneManager(), ASR::Game::getSingletonPtr(), mRaySceneQuery, mTeamNode, and mUnits.

                : mTeam ( parentTeam )
        {
                // TODO
                //      Create this on the Team SceneNode, not the Root SceneNode
                SceneManager* sceneMgr = Game::getSingletonPtr ()->getSceneManager ();
                mTeamNode = sceneMgr->getRootSceneNode()->createChildSceneNode( parentTeam->getName () );

                mRaySceneQuery = sceneMgr->createRayQuery( Ray() );

                mUnits.reserve ( initialUnits );
        }

ASR::TeamUnits::~TeamUnits

(

)

Definition at line 58 of file TeamUnits.cpp.

References ASR::Game::getSceneManager(), ASR::Game::getSingletonPtr(), mRaySceneQuery, and mUnits.

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

                SceneManager* sceneMgr = Game::getSingletonPtr ()->getSceneManager ();
                sceneMgr->destroyQuery ( mRaySceneQuery );
        }

---

Member Function Documentation

void ASR::TeamUnits::_clearSpatialGrid

(

)

[private]

Removes all units from the grid but does not change the size.

Definition at line 305 of file TeamUnits.cpp.

References mUnitGrid.

Referenced by updateSpatialGrid().

        {
                for ( size_t i = 0; i < mUnitGrid.size(); i++ )
                {
                        for ( size_t j = 0; j < mUnitGrid[i].size(); j++ )
                        {
                                mUnitGrid[i][j].clear ();
                        }
                }
        }

void ASR::TeamUnits::animateUnits

(

float

deltaTime

)

Definition at line 182 of file TeamUnits.cpp.

References mUnits.

Referenced by ASR::TeamUpdater::updateBeforeFrame().

        {
                // Apply all animations
                UnitList::iterator iter;
                for ( iter = mUnits.begin(); iter != mUnits.end(); iter++ )
                {
                        (*iter)->updateAnimation ( deltaTime );
                }
        }

Unit * ASR::TeamUnits::createUnit

(

String

meshName

)

Definition at line 73 of file TeamUnits.cpp.

References mTeamNode, and mUnits.

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

        {
                Unit* newUnit = new Unit ( mTeamNode, meshName );

                mUnits.push_back ( newUnit );

                return newUnit;
        }

void ASR::TeamUnits::findTargets

(

)

Definition at line 194 of file TeamUnits.cpp.

References ASR::Level::getEnemyTeams(), ASR::Level::getSingleton(), getUnitIterator(), and mTeam.

Referenced by ASR::TeamUpdater::updateAfterFrame().

        {
                // TODO
                //              Use the spatial grid to make this search a lot faster

                // Grab a list of the enemy teams
                Level::TeamList enemyTeams = Level::getSingleton ().getEnemyTeams ( mTeam );

                //              For each unit
                //                      If the unit already has a target, move on to the next unit
                //                      Grab a list of adjacent enemy units
                //                      Loop through and find the best target (for now, the closest)
                //                      Assign the target
                //                      Notify the target of attack
                UnitIterator iter = getUnitIterator ();
                while ( iter.hasMoreElements () )
                {
                        Unit* curUnit = iter.getNext ();
                        if ( curUnit->isEngaged() || curUnit->isDead () )
                                continue;

                        UnitList allEnemies;
                        Level::TeamIterator curEnemyTeam ( enemyTeams.begin(), enemyTeams.end() );

                        while ( curEnemyTeam.hasMoreElements () )
                        {
                                Team* enemy = curEnemyTeam.getNext ();
                                UnitList unitList = enemy->getAdjacentUnits ( curUnit->getPosition(), curUnit->getSightRadius () );
                                allEnemies.insert ( allEnemies.end(), unitList.begin(), unitList.end() );
                        }
                        
                        // Determine the closest unit to us
                        float distance = Math::POS_INFINITY;
                        Unit* bestTarget = NULL;

                        UnitIterator secondIter ( allEnemies.begin(), allEnemies.end() );
                        while ( secondIter.hasMoreElements () )
                        {
                                Unit* enemyUnit = secondIter.getNext ();

                                if ( enemyUnit->isDead() )
                                        continue;

                                Vector3 targetLine = enemyUnit->getPosition () - curUnit->getPosition ();
                                if ( targetLine.length() < distance )
                                {
                                        bestTarget = enemyUnit;
                                        distance = targetLine.length();
                                }
                        }

                        if ( distance <= curUnit->getSightRadius () )
                                curUnit->assignTarget ( bestTarget );
                }
        }

TeamUnits::UnitList ASR::TeamUnits::getAdjacentUnits	(	const Vector3 &	worldPos,
		float	radius
	)

Returns a list of Units within the given radius of the specified world position.

This is only an approximation and may return units further than 'radius' units away. This is just a very fast prune technique.

Definition at line 318 of file TeamUnits.cpp.

References ASR::Level::getNumNodesHigh(), ASR::Level::getNumNodesWide(), ASR::Level::getSingleton(), ASR::Level::getWorldHeight(), ASR::Level::getWorldWidth(), and mUnitGrid.

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

        {
                // TODO
                //              Take the radius into account
                //
                //              Possibly return a list of indices in a vector that can be used
                //              to obtain a reference to the internal list that's store (const)
                //              so that we don't build a huge unit list each and every frame

                UnitList units;

                int worldWidth = Level::getSingleton ().getWorldWidth ();
                int worldHeight = Level::getSingleton ().getWorldHeight ();

                unsigned int cellWidth = worldWidth / mUnitGrid.size ();
                unsigned int cellHeight = worldHeight / mUnitGrid[0].size();

                unsigned int cellX = worldPos.x / cellWidth;
                unsigned int cellZ = worldPos.z / cellHeight;

                if ( cellX >= mUnitGrid.size () || cellZ >= mUnitGrid[cellX].size() )
                        throw Exception ( Exception::ERR_INVALIDPARAMS, "World position is outside of grid", "TeamUnits::getAdjacentUnits" );

                if ( cellX < 0 || cellZ < 0 )
                        throw Exception ( Exception::ERR_INVALIDPARAMS, "World position is outside of grid", "TeamUnits::getAdjacentUnits" );

                // Add all Units in the current list as well as all neighbouring lists
                units = mUnitGrid[cellX][cellZ];

                OgreAssert ( Level::getSingleton().getNumNodesWide(), "Must have at least one node width" );
                OgreAssert ( Level::getSingleton().getNumNodesHigh(), "Must have at least one node height" );

                unsigned int cellsWide = Level::getSingleton ().getNumNodesWide () - 1;
                unsigned int cellsHigh = Level::getSingleton ().getNumNodesHigh () - 1;


                // Top-left
                if ( cellX > 0 && cellZ > 0 )
                        units.insert ( units.end(), mUnitGrid[cellX - 1][cellZ - 1].begin(), mUnitGrid[cellX - 1][cellZ - 1].end () );
                // Bottom-left
                if ( cellX > 0 &&  cellZ < cellsWide )
                        units.insert ( units.end(), mUnitGrid[cellX - 1][cellZ + 1].begin(), mUnitGrid[cellX - 1][cellZ + 1].end () );
                // Middle-left
                if ( cellX > 0 )
                        units.insert ( units.end(), mUnitGrid[cellX - 1][cellZ].begin(), mUnitGrid[cellX - 1][cellZ].end () );
                // Top-right
                if ( cellX < cellsWide && cellZ > 0 )
                        units.insert ( units.end(), mUnitGrid[cellX + 1][cellZ - 1].begin(), mUnitGrid[cellX + 1][cellZ - 1].end () );
                // Bottom-right
                if ( cellX < cellsWide && cellZ < cellsWide )
                        units.insert ( units.end(), mUnitGrid[cellX + 1][cellZ + 1].begin(), mUnitGrid[cellX + 1][cellZ + 1].end () );
                // Middle-right
                if ( cellX < cellsWide )
                        units.insert ( units.end(), mUnitGrid[cellX + 1][cellZ].begin(), mUnitGrid[cellX + 1][cellZ].end () );
                // Top-middle
                if ( cellZ > 0 )
                        units.insert ( units.end(), mUnitGrid[cellX][cellZ - 1].begin(), mUnitGrid[cellX][cellZ - 1].end () );
                // Bottom-middle
                if ( cellZ < cellsHigh )
                        units.insert ( units.end(), mUnitGrid[cellX][cellZ + 1].begin(), mUnitGrid[cellX][cellZ + 1].end () );

                return units;
        }

size_t ASR::TeamUnits::getNumUnits

(

)

Definition at line 94 of file TeamUnits.cpp.

References mUnits.

        {
                return mUnits.size();
        }

Unit * ASR::TeamUnits::getUnit

(

size_t

index

)

Definition at line 84 of file TeamUnits.cpp.

References mUnits.

Referenced by ASR::TeamUpdater::updateAfterFrame().

        {
                if ( index >= mUnits.size() )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Unit index to high", "TeamUnits::GetUnit" );

                return mUnits[index];
        }

TeamUnits::UnitIterator ASR::TeamUnits::getUnitIterator

(

)

Definition at line 252 of file TeamUnits.cpp.

References mUnits.

Referenced by findTargets(), ASR::Team::findTargets(), ASR::Team::getUnitIterator(), performAttacks(), and updateSpatialGrid().

        {
                return UnitIterator ( mUnits.begin(), mUnits.end() );
        }

void ASR::TeamUnits::moveUnits

(

float

deltaTime

)

Definition at line 101 of file TeamUnits.cpp.

References mRaySceneQuery, mUnits, and ASR::UNIT_SPEED.

Referenced by ASR::TeamUpdater::updateBeforeFrame().

        {
                // Move all the units, keeping them on the terrain
                UnitList::iterator unitIter;
                Vector3 nodePos;

                for ( unitIter = mUnits.begin(); unitIter != mUnits.end(); unitIter++ )
                {
                        // Update the Unit to move towards any destination if it has one
                        if ( (*unitIter)->hasDestination () )
                        {
                                Vector3 destPos = (*unitIter)->getDestination();
                                Vector3 srcPos = (*unitIter)->getPosition ();
                                destPos.y = srcPos.y;

                                // See if we reached the current destination
                                Vector3 diff = destPos - srcPos;
                                
                                if ( diff.isZeroLength() )
                                {
                                        // Move on to the next waypoint
                                        (*unitIter)->setPosition ( destPos );
                                        (*unitIter)->removeDestination ();
                                }
                                else
                                {
                                        // Update the position
                                        Vector3 translation = diff.normalisedCopy();
                                        translation = translation * (deltaTime * UNIT_SPEED);

                                        // Check if they hit the destination and if so, snap them

                                        // TODO
                                        //              Use the left over movement to go to the next waypoint
                                        if ( translation.length() > diff.length() )
                                        {
                                                (*unitIter)->setPosition( destPos );
                                                (*unitIter)->removeDestination();
                                        }
                                        else
                                        {
                                                (*unitIter)->translate ( Vector3(translation.x, 0.0, translation.z), Node::TS_WORLD );
                                        }
                                }

                                /*
                                (*unitIter)->getEntity()->getAnimationState ( "Idle" )->setEnabled( false );
                                (*unitIter)->getEntity()->getAnimationState ( "Walk" )->setEnabled( true );
                                (*unitIter)->getEntity()->getAnimationState ( "Walk" )->addTime ( deltaTime );
                                */
                        }
                        else
                        {
                                /*
                                (*unitIter)->getEntity()->getAnimationState ( "Idle" )->setEnabled( true );
                                (*unitIter)->getEntity()->getAnimationState ( "Idle" )->addTime ( deltaTime );
                                (*unitIter)->getEntity()->getAnimationState ( "Walk" )->setEnabled( false );
                                */
                        }

                        nodePos = (*unitIter)->getPosition ();

                        // Setup the query
                        Ray unitRay ( Vector3( nodePos.x, 5000.0f, nodePos.z ), Vector3::NEGATIVE_UNIT_Y );
                        mRaySceneQuery->setRay ( unitRay );

                        // Perform the query
                        RaySceneQueryResult& result = mRaySceneQuery->execute ();
                        RaySceneQueryResult::iterator iter = result.begin();

                        // Use the query
                        if ( iter != result.end() && iter->worldFragment )
                        {
                                Real terrainHeight = iter->worldFragment->singleIntersection.y;
                                (*unitIter)->setPosition ( Vector3((*unitIter)->getPosition().x, terrainHeight, (*unitIter)->getPosition().z ));
                        }
                }
        }

void ASR::TeamUnits::performAttacks

(

)

Definition at line 384 of file TeamUnits.cpp.

References getUnitIterator().

Referenced by ASR::TeamUpdater::updateAfterFrame().

        {
                UnitIterator iter = getUnitIterator ();
                while ( iter.hasMoreElements () )
                {
                        Unit* curUnit = iter.getNext ();
                        //if ( curUnit->isEngaged () )
                        curUnit->doAttack ();
                }
        }

void ASR::TeamUnits::setSpatialGridSize	(	int	numBucketsWide,
		int	numBucketsHigh
	)

Definition at line 259 of file TeamUnits.cpp.

References mUnitGrid.

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

        {
                // Erase the old grid
                // TODO
                //              Do we need to go through and erase each column?
                mUnitGrid.clear ();

                for ( int i = 0; i < numBucketsWide; i++ )
                {
                        SpatialColumn col;
                        col.resize ( numBucketsHigh );
                        mUnitGrid.push_back ( col );
                }
        }

void ASR::TeamUnits::updateSpatialGrid

(

)

Updates the spatial information of each unit inside of the grid.

Definition at line 276 of file TeamUnits.cpp.

References _clearSpatialGrid(), ASR::Level::getSingleton(), getUnitIterator(), ASR::Level::getWorldHeight(), ASR::Level::getWorldWidth(), and mUnitGrid.

Referenced by ASR::TeamUpdater::updateBeforeFrame().

        {
                // TODO
                //              Instead of clearing this every frame, use the movement of
                //              the Unit to determine if it crosses the boundaries of a cell
                //              and then remove it from it's current grid cell and put it
                //              in the new grid cell
                _clearSpatialGrid ();

                int worldWidth = Level::getSingleton ().getWorldWidth ();
                int worldHeight = Level::getSingleton ().getWorldHeight ();

                unsigned int cellWidth = worldWidth / mUnitGrid.size ();
                unsigned int cellHeight = worldHeight / mUnitGrid[0].size();

                UnitIterator iter = getUnitIterator ();
                while ( iter.hasMoreElements () )
                {
                        Unit* curUnit = iter.getNext ();

                        unsigned int cellX = curUnit->getPosition ().x / cellWidth;
                        unsigned int cellZ = curUnit->getPosition ().z / cellHeight;

                        mUnitGrid[cellX][cellZ].push_back ( curUnit );
                }
        }

---

Member Data Documentation

int ASR::TeamUnits::mNumTeams = 0 [static, private]

Definition at line 45 of file TeamUnits.h.

RaySceneQuery* ASR::TeamUnits::mRaySceneQuery [private]

Definition at line 41 of file TeamUnits.h.

Referenced by moveUnits(), TeamUnits(), and ~TeamUnits().

Team* ASR::TeamUnits::mTeam [private]

Definition at line 46 of file TeamUnits.h.

Referenced by findTargets().

SceneNode* ASR::TeamUnits::mTeamNode [private]

Definition at line 40 of file TeamUnits.h.

Referenced by createUnit(), and TeamUnits().

SpatialGrid ASR::TeamUnits::mUnitGrid [private]

Definition at line 54 of file TeamUnits.h.

Referenced by _clearSpatialGrid(), getAdjacentUnits(), setSpatialGridSize(), and updateSpatialGrid().

UnitList ASR::TeamUnits::mUnits [private]

Definition at line 43 of file TeamUnits.h.

Referenced by animateUnits(), createUnit(), getNumUnits(), getUnit(), getUnitIterator(), moveUnits(), TeamUnits(), and ~TeamUnits().

---

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

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

---