D:/simple_rts/src/Unit.cpp

Go to the documentation of this file.

#include "Unit.h"

#include "Game.h"
#include "Timer.h"
#include "Projectile.h"

#include "OgreMath.h"
#include "OgreStringConverter.h"
#include "OgreException.h"
#include "OgreAnimationState.h"
#include "OgreAnimation.h"
#include "OgreMaterialManager.h"
#include "OgreMaterial.h"
#include "OgreSubEntity.h"
#include "OgreMovableObject.h"

using Ogre::MovableObject;
using Ogre::AnimationState;
using Ogre::AnimationStateSet;
using Ogre::AnimationStateIterator;
using Ogre::MaterialManager;
using Ogre::Material;
using Ogre::SubEntity;
using Ogre::MaterialPtr;
using Ogre::ColourValue;
using Ogre::Exception;
using Ogre::StringConverter;
using Ogre::Degree;
using Ogre::Math;
using Ogre::Radian;


namespace ASR
{
        int Unit::mNumUnits = 0;
        const float Unit::mSearchUpdateTime = 1.0f;
        String Unit::TYPE_NAME = "Unit";

        // ----------------------------------------------------------------------------
        Unit::Unit( SceneNode* parentNode, String meshName )
                : mMeshName ( meshName )
        {
                mNumUnits++;

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

                mUnitName = "unit_" + StringConverter::toString ( mNumUnits );
                mEntity = sceneMgr->createEntity ( mUnitName, mMeshName);
                mEntity->setUserObject( this );
                mEntity->setCastShadows ( true );

                mUnitNode = parentNode->createChildSceneNode( mUnitName + "_node" );
                mUnitNode->attachObject( mEntity );
                mUnitNode->setFixedYawAxis ( true );

                mNavDirty = false;

                mAnimationState = getEntity()->getAnimationState ( "Idle" );
                //getEntity ()->getAnimationState ("Die")->setLoop ( false );
                mStatus = US_DEAD;

                assignTarget ( NULL );
                setStatus ( US_IDLE );

                mSearch = NULL;
                mSearchElapsedTime = 0.0f;

                // HACKS
                mFireRate = 1.0f;
                mRange = 80.0f;
                mSightRadius = 200.0f;
                mMaxHitPoints = 100;
                mCurHitPoints = mMaxHitPoints;


                // HACKS
                String shieldName = mUnitName + "_shield";
                mShield = sceneMgr->createEntity( shieldName, "lizardmanShield1.mesh" );
                SceneNode *shield_Node = sceneMgr->getRootSceneNode()->createChildSceneNode( shieldName + "_Node" );
                shield_Node->yaw(Radian(Degree(90)));
                shield_Node->pitch(Radian(Degree(-90)));

                String shoulderName = mUnitName + "_shoulder";
                mShoulder = sceneMgr->createEntity( shoulderName, "lizardmanShoulder1.mesh" );
                SceneNode *shoulder_Node = sceneMgr->getRootSceneNode()->createChildSceneNode( shoulderName + "_Node" );
                shoulder_Node->roll(Radian(Degree(10)));

                String swordName = mUnitName + "_sword";
                mWeapon = sceneMgr->createEntity( swordName, "lizardmanWeapon1.mesh" );
                SceneNode *sword_Node = sceneMgr->getRootSceneNode()->createChildSceneNode( swordName + "_Node" );
                sword_Node->pitch(Radian(Degree(90)));
                sword_Node->roll(Radian(Degree(95)));

                mEntity->attachObjectToBone ("LeftShoulder", mShoulder, shoulder_Node->getOrientation(), Vector3(4.7, 0.5, 0.5));
                mEntity->attachObjectToBone ("LeftForearm", mShield, shield_Node->getOrientation(), Vector3(3.5, 3.0, 0.2));
                mEntity->attachObjectToBone ("RightHand", mWeapon, sword_Node->getOrientation(), Vector3(2.0, 0.0, 0.9));
        }


        // ----------------------------------------------------------------------------
        Unit::~Unit(void)
        {
                _destroyAttacks ();
                _destroySearch ();
        }


        // ----------------------------------------------------------------------------
        float Unit::getSightRadius () const
        {
                return mSightRadius;
        }


        // ----------------------------------------------------------------------------
        void Unit::clearWaypoints()
        {
                mNavDirty = true;
                mWaypoints.clear ();
        }


        // ----------------------------------------------------------------------------
        void Unit::addWaypoint( const Vector3& waypoint )
        {
                setStatus ( US_MOVING );
                assignTarget ( NULL );

                mNavDirty = true;
                mWaypoints.push_back ( waypoint );

                if ( mWaypoints.size() == 1 )
                        _alignToWaypoint ();
        }


        // ----------------------------------------------------------------------------
        void Unit::removeDestination()
        {
                assert ( !mWaypoints.empty() );
                mWaypoints.pop_front ();

                // Align ourselves to the next destination, if we have one
                if ( hasDestination () )
                {
                        _alignToWaypoint ();
                }
                else
                {
                        stopMovement ();
                }
        }


        // ----------------------------------------------------------------------------
        Vector3 Unit::getDestination()
        {
                assert ( !mWaypoints.empty() );
                return mWaypoints.front ();
        }


        // ----------------------------------------------------------------------------
        bool Unit::hasDestination()
        {
                return !mWaypoints.empty ();
        }


        // ----------------------------------------------------------------------------
        Entity* Unit::getEntity ()
        {
                return mEntity;
        }


        // ----------------------------------------------------------------------------
        const String& Unit::getTypeName () const
        {
                return Unit::TYPE_NAME;
        }


        // ----------------------------------------------------------------------------
        void Unit::scale ( Real x, Real y, Real z )
        {
                mUnitNode->scale ( x, y, z );
        }


        // ----------------------------------------------------------------------------
        void Unit::translate ( const Vector3& vec, Node::TransformSpace space )
        {
                mUnitNode->translate ( vec, space );
        }


        // ----------------------------------------------------------------------------
        Vector3 Unit::getPosition () const
        {
                return mUnitNode->getWorldPosition ();
        }


        // ----------------------------------------------------------------------------
        void Unit::setPosition ( const Vector3& pos )
        {
                mUnitNode->setPosition ( pos );
        }


        // ----------------------------------------------------------------------------
        void Unit::setDirection ( const Vector3& dir )
        {
                mUnitNode->setDirection ( dir );
        }


        // ----------------------------------------------------------------------------
        void Unit::setDirection ( float x, float y, float z )
        {
                mUnitNode->setDirection( x, y, z );
        }


        // ----------------------------------------------------------------------------
        void Unit::_alignToWaypoint ()
        {
                // Align to the next waypoint
                Vector3 dest = getDestination();
                dest.y = getPosition ().y;

                Vector3 direction = dest - getPosition ();

                // If we are close enough to our destination, move on
                if ( direction.isZeroLength () )
                {
                        return;
                }

                getEntity()->getParentSceneNode ()->lookAt ( dest, SceneNode::TS_WORLD, Vector3::UNIT_Z );
        }


        // ----------------------------------------------------------------------------
        Unit::WaypointIterator Unit::getWaypointIterator ()
        {
                return WaypointIterator ( mWaypoints.begin(), mWaypoints.end() );
        }


        // ----------------------------------------------------------------------------
        void Unit::assignTarget ( Unit* target )
        {
                // Can't target a dead unit
                if ( target != NULL && target->isDead() )
                        throw Exception ( Exception::ERR_INTERNAL_ERROR, "Targetting a dead unit", "Unit::assignTarget" );

                // We can only assign a target when we stop moving
                if ( mStatus == US_MOVING )
                        return;

                clearWaypoints ();

                mTarget = target;
                mAttackTime = 0.0f;

                if ( target == NULL )
                {
                        setStatus ( US_IDLE );
                }
                else
                {
                        // Determine if we need to chase or if we can engage from our current position
                        Vector3 distanceToTarget = target->getPosition() - getPosition();

                        // TODO
                        //              Use squared length here once we change how mRange is stored
                        if ( distanceToTarget.length () > getRange() )
                        {
                                _chaseTarget ();
                        }
                        else
                        {
                                setStatus ( US_ATTACKING );
                                _alignToTarget ();
                        }
                }
        }


        // ----------------------------------------------------------------------------
        bool Unit::isEngaged () const
        {
                return (mStatus == US_ATTACKING || mStatus == US_CHASING);
        }


        // ----------------------------------------------------------------------------
        Unit* Unit::getTarget () const
        {
                return mTarget;
        }


        // ----------------------------------------------------------------------------
        void Unit::doAttack ()
        {
                _updateProjectiles ();

                if ( isDead () )
                {
                        clearWaypoints ();
                        setStatus ( US_DYING );

                        // HACK
                        hide ();
                        return;
                }

                if ( mTarget == NULL || !isEngaged() )
                        return;

                float targetDist = _getDistanceToTarget ();
                
                //  The target moved away from us
                if ( targetDist > getSightRadius() )
                {
                        assignTarget ( NULL );
                        _destroyAttacks ();
                        return;
                }


                if ( mStatus == US_CHASING )
                {
                        if (  targetDist <= getRange() )
                        {
                                // Change into the attacking phase of combat
                                clearWaypoints ();
                                setStatus ( US_ATTACKING );
                        }
                        else
                        {
                                mSearchElapsedTime += Timer::getSingleton ().getTimeSinceLastFrame ();
                                if ( mSearchElapsedTime >= mSearchUpdateTime )
                                {
                                        mSearchElapsedTime -= mSearchUpdateTime;
                                        // TODO
                                        //              Cache positions since we may not have to re-path
                                        
                                        // Re-path to the target
                                        setDestination ( mTarget->getPosition() );
                                        setStatus ( US_CHASING );
                                }
                        }
                }
                else if ( mStatus == US_ATTACKING )
                {
                        // We need to chase the target (we allow some lee-way)
                        if ( targetDist > (getRange () + 10.0f) )
                        {
                                _chaseTarget ();
                                return;
                        }


                        // Make sure we are always facing the target
                        _alignToTarget ();

                        mAttackTime += Timer::getSingleton ().getTimeSinceLastFrame();

                        if ( mAttackTime > _getTimeBetweenAttacks() )
                        {
                                _spawnAttack ();

                                // Check if the target is dead here so that come next frame, we
                                // will acquire a new target to fight and we won't be idle for 
                                // any frames
                                if ( mTarget->isDead() )
                                {
                                        assignTarget ( NULL );
                                }
                        }
                }
        }


        // ----------------------------------------------------------------------------
        float Unit::_getTimeBetweenAttacks ()
        {
                return mFireRate;
        }


        // ----------------------------------------------------------------------------
        void Unit::_spawnAttack ()
        {
                // HACK
                float projectileSpeed = 150.0f;

                Projectile* newBullet = new Projectile ( this, mTarget );
                newBullet->setDamage ( _calcDamage(mTarget) );
                newBullet->setSpeed ( projectileSpeed );

                mProjectiles.push_back ( newBullet );

                mAttackTime = 0.0f;
        }


        // ----------------------------------------------------------------------------
        void Unit::_updateProjectiles ()
        {
                vector<Projectile*>::iterator iter = mProjectiles.begin();
                vector<Projectile*> toRemove;

                while ( iter != mProjectiles.end() )
                {
                        if ( (*iter)->update () )
                                toRemove.push_back ( (*iter) );

                        iter++;
                }

                iter = toRemove.begin();
                while ( iter != toRemove.end() )
                {
                        vector<Projectile*>::iterator projIter = find ( mProjectiles.begin(), mProjectiles.end(), (*iter) );
                        mProjectiles.erase ( projIter );

                        delete (*iter);
                        iter++;
                }
        }


        // ----------------------------------------------------------------------------
        float Unit::_getDistanceToTarget ()
        {
                OgreAssert ( mTarget != NULL, "No target to get distance to" );
                Vector3 targPos = mTarget->getPosition();
                targPos.y = 0.0f;

                Vector3 ourPos = getPosition();
                ourPos.y = 0.0f;

                return ( targPos - ourPos ).length();
        }


        // ----------------------------------------------------------------------------
        void Unit::_destroyAttacks ()
        {
                BulletList::iterator iter = mProjectiles.begin();
                while ( iter != mProjectiles.end() )
                {
                        delete (*iter);
                        iter++;
                }

                mProjectiles.clear ();
        }


        // ----------------------------------------------------------------------------
        void Unit::stopMovement ()
        {
                setStatus ( US_IDLE );
                mWaypoints.clear ();

                assignTarget ( NULL );
        }


        // ----------------------------------------------------------------------------
        void Unit::setStatus ( UnitStatus status )
        {
                if ( mStatus == status )
                        return;

                mStatus = status;

                mAnimationState->setEnabled ( false );

                switch ( mStatus )
                {
                case US_MOVING:
                case US_CHASING:
                        mAnimationState = getEntity()->getAnimationState( "Run" );
                        break;

                case US_IDLE:
                case US_ATTACKING:
                case US_DEAD:
                case US_DYING:
                default:
                        mAnimationState = getEntity()->getAnimationState( "Idle" );
                        break;
                }

                mAnimationState->setEnabled( true );
                mAnimationState->setTimePosition ( 0.0 );
        }


        // ----------------------------------------------------------------------------
        void Unit::updateAnimation (float deltaTime )
        {
                mAnimationState->addTime ( deltaTime );
        }


        // ----------------------------------------------------------------------------
        void Unit::_alignToTarget ()
        {
                Vector3 direction = mTarget->getPosition () - getPosition();
                if ( direction.isZeroLength () )
                        return;

                direction.normalise ();

                Vector3 target = mTarget->getPosition ();
                target.y = getPosition().y;

                mUnitNode->lookAt ( target, SceneNode::TS_WORLD, Vector3::UNIT_Z );
        }


        // ----------------------------------------------------------------------------
        void Unit::assignDamage ( int damage )
        {
                mCurHitPoints -= damage;
        }


        // ----------------------------------------------------------------------------
        bool Unit::isDead () const
        {
                return mCurHitPoints <= 0;
        }


        // ----------------------------------------------------------------------------
        float Unit::_calcDamage ( const Unit* target ) const
        {
                // HACK
                return 5;
        }


        // ----------------------------------------------------------------------------
        String Unit::getUnitName() const
        {
                return mUnitName;
        }


        // ----------------------------------------------------------------------------
        bool Unit::setDestination ( const Vector3& destination )
        {
                AStarSearch<Level::LevelNode>* search = NULL;
                Level* lev = Level::getSingletonPtr ();

                _destroySearch ();

                // Create the leader path
                Level::LevelNode* startNode = lev->getNode ( getPosition () );
                Level::LevelNode* endNode = lev->getNode ( destination );

                // Create a new path for the unit
                mSearch = Level::getSingleton().getPathManager()->createSearch ( getEntity ()->getName(), startNode, endNode );
                while ( mSearch->isRunnable() )
                {
                        mSearch->advanceSearch();
                }

                if ( mSearch->isSolved() )
                {
                        _assignWaypoints ();
                        return true;
                }

                return false;
        }


        // ----------------------------------------------------------------------------
        void Unit::_assignWaypoints ()
        {
                OgreAssert ( mSearch, "There is no search defined" );
                if ( !mSearch->isSolved() )
                        throw Ogre::Exception ( Exception::ERR_INTERNAL_ERROR, "Copying from an unsolved search", "Unit::_assignWaypoints" );

                clearWaypoints();

                const WaypointList<Level::LevelNode>* waypoints = mSearch->getSolutionPath();

                // Build a waypoint list starting at the second waypoint instead of moving
                // to the center of the node first
                if ( waypoints->getNumWaypoints () > 1 )
                {
                        // Go up to but not including the last waypoint
                        for ( unsigned int i = 1; i < waypoints->getNumWaypoints() - 1; i++ )
                        {
                                addWaypoint( waypoints->getWaypoint(i)->getWorldPosition() );
                        }
                        // Add the mouse click position to the list
                }
                // Otherwise, just move to the waypoint inside of the same cell
                // TODO
                //              Make sure that the waypoint becomes the point of clicking and not
                //              the center of the cell
                else if ( waypoints->getNumWaypoints () == 1 )
                {
                        addWaypoint ( waypoints->getWaypoint (0)->getWorldPosition () );
                }
        }


        // ----------------------------------------------------------------------------
        void Unit::_destroySearch ()
        {
                if ( mSearch )
                {
                        Level::getSingleton().getPathManager()->destroySearch( getEntity ()->getName() );
                        mSearch = NULL;
                }
        }


        // ----------------------------------------------------------------------------
        float Unit::getRange() const
        {
                return mRange;
        }


        // ----------------------------------------------------------------------------
        void Unit::_chaseTarget ()
        {
                OgreAssert ( mTarget, "Unit has no target to chase" );

                mSearchElapsedTime = 0.0f;
                setDestination ( mTarget->getPosition() );
                setStatus ( US_CHASING );
        }


        // ----------------------------------------------------------------------------
        void Unit::hide ()
        {
                getEntity ()->getParentSceneNode ()->setVisible ( false );
                Entity::ChildObjectListIterator iter = getEntity ()->getAttachedObjectIterator ();
                while ( iter.hasMoreElements () )
                {
                        MovableObject* obj = iter.getNext ();
                        obj->setVisible ( false );
                }
        }


        // ----------------------------------------------------------------------------
        void Unit::show ()
        {
                getEntity ()->getParentSceneNode ()->setVisible ( true );
                Entity::ChildObjectListIterator iter = getEntity ()->getAttachedObjectIterator ();
                while ( iter.hasMoreElements () )
                {
                        MovableObject* obj = iter.getNext ();
                        obj->setVisible ( true );
                }
        }
}

---