D:/simple_rts/src/TeamUnits.cpp

Go to the documentation of this file.

#include "TeamUnits.h"
#include "Game.h"

#include "Team.h"
#include "Level.h"
#include "Unit.h"

#include <cassert>

#include "OgreSceneManager.h"
#include "OgreStringConverter.h"
#include "OgreEntity.h"
#include "OgreRay.h"
#include "OgreNode.h"
#include "OgreMath.h"
#include "OgreException.h"
#include "OgreQuaternion.h"
#include "OgreLogManager.h"
#include "OgreStringConverter.h"


using Ogre::SceneManager;
using Ogre::Exception;
using Ogre::LogManager;
using Ogre::StringConverter;
using Ogre::Quaternion;
using Ogre::Degree;

using Ogre::RaySceneQueryResult;
using Ogre::Ray;
using Ogre::StringConverter;
using Ogre::Node;
using Ogre::Math;


namespace ASR
{
        const int UNIT_SPEED = 60;

        int TeamUnits::mNumTeams = 0;

        // ----------------------------------------------------------------------------
        TeamUnits::TeamUnits ( Team* parentTeam, unsigned int initialUnits )
                : 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 );
        }


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

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


        // ----------------------------------------------------------------------------
        Unit* TeamUnits::createUnit ( String meshName )
        {
                Unit* newUnit = new Unit ( mTeamNode, meshName );

                mUnits.push_back ( newUnit );

                return newUnit;
        }


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

                return mUnits[index];
        }


        // ----------------------------------------------------------------------------
        size_t TeamUnits::getNumUnits ()
        {
                return mUnits.size();
        }


        // ----------------------------------------------------------------------------
        void TeamUnits::moveUnits ( float deltaTime )
        {
                // 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 TeamUnits::animateUnits ( float deltaTime )
        {
                // Apply all animations
                UnitList::iterator iter;
                for ( iter = mUnits.begin(); iter != mUnits.end(); iter++ )
                {
                        (*iter)->updateAnimation ( deltaTime );
                }
        }


        // ----------------------------------------------------------------------------
        void TeamUnits::findTargets ()
        {
                // 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::UnitIterator TeamUnits::getUnitIterator ()
        {
                return UnitIterator ( mUnits.begin(), mUnits.end() );
        }


        // ----------------------------------------------------------------------------
        void TeamUnits::setSpatialGridSize ( int numBucketsWide, int numBucketsHigh )
        {
                // 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 TeamUnits::updateSpatialGrid ()
        {
                // 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 );
                }
        }


        // ----------------------------------------------------------------------------
        void TeamUnits::_clearSpatialGrid ()
        {
                for ( size_t i = 0; i < mUnitGrid.size(); i++ )
                {
                        for ( size_t j = 0; j < mUnitGrid[i].size(); j++ )
                        {
                                mUnitGrid[i][j].clear ();
                        }
                }
        }


        // ----------------------------------------------------------------------------
        TeamUnits::UnitList TeamUnits::getAdjacentUnits ( const Vector3& worldPos, float radius )
        {
                // 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;
        }


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

---