D:/simple_rts/src/ControlGroup.cpp

Go to the documentation of this file.

#include "ControlGroup.h"

#include "Unit.h"
#include "LineFormation.h"

#include "OgreException.h"
#include "OgreMath.h"

#include <cassert>

using Ogre::Exception;
using Ogre::Math;

namespace ASR
{
        // ----------------------------------------------------------------------------
        ControlGroup::ControlGroup ()
                : mForward ( Vector3::ZERO ), mRight ( Vector3::ZERO )
        {
                mCurFormation = new LineFormation ();
                mUnits.clear ();
                mDirty = false;
        }


        // ----------------------------------------------------------------------------
        ControlGroup::~ControlGroup ()
        {
                delete mCurFormation;
                mUnits.clear ();
        }


        // ----------------------------------------------------------------------------
        int ControlGroup::addUnit ( Unit* unit )
        {
                mUnits.push_back ( unit );
                mDirty = true;
                return mUnits.size() - 1;
        }


        // ----------------------------------------------------------------------------
        void ControlGroup::removeUnit ( size_t index )
        {
                assert ( index < mUnits.size() && index <= 0 );
                UnitList::iterator iter = mUnits.begin();
                
                for ( size_t i = 0; i < index; i++ )
                {
                        iter++;
                }

                mUnits.erase ( iter );
                mDirty = true;
        }


        // ----------------------------------------------------------------------------
        void ControlGroup::removeUnit ( Unit* unit )
        {
                UnitList::iterator iter = find ( mUnits.begin(), mUnits.end(), unit );
                if ( iter == mUnits.end () )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Unit not found", "ControlGroup::removeUnit" );

                mUnits.erase ( iter );
                mDirty = true;
        }


        // ----------------------------------------------------------------------------
        Vector3 ControlGroup::getFormationCenter ()
        {
                if ( mDirty )
                        _updateFormation ();

                return mFormationCenter;
        }


        // ----------------------------------------------------------------------------
        void ControlGroup::_updateFormation ()
        {
                _calcCenter ();
                _calcOrientation ();

                mDirty = false;
        }


        // ----------------------------------------------------------------------------
        void ControlGroup::_calcCenter ()
        {
                UnitList::iterator iter;
                Vector3 total = Vector3::ZERO;

                if ( mUnits.size () == 0 )
                        return;

                for ( iter = mUnits.begin(); iter != mUnits.end(); iter++ )
                {
                        total += Vector3( (*iter)->getPosition ().x, 0.0f, (*iter)->getPosition ().z );
                }

                mFormationCenter = total / mUnits.size();
        }


        // ----------------------------------------------------------------------------
        Vector3 ControlGroup::getUnitOffset ( Unit* unit )
        {
                int index = getUnitIndex ( unit );

                // TODO
                //              Ask the Formation for the offset
                //              Currently just returning a huge line
                int position;
                if ( index % 2 == 0 )
                        position = index / 2;
                else
                        int position = -( index + 1 ) / 2;

                Vector3 singleOffset ( 0, 0, 10 );
                Vector3 localPos = getFormationCenter () + ( singleOffset * position );
                return localPos;
        }


        // ----------------------------------------------------------------------------
        int ControlGroup::getUnitIndex ( Unit* unit )
        {
                for ( size_t i = 0; i < mUnits.size(); i++ )
                {
                        if ( mUnits[i] == unit )
                                return i;
                }

                throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Unit not found", "ControlGroup::getUnitIndex" );
        }


        // ----------------------------------------------------------------------------
        void ControlGroup::setDestination ( const Vector3& dest )
        {
                // TODO
                //      Figure out a path for each and every unit in this list
                //      using their offsets. We just move each unit as close
                //      to where it is supposed to be as possible
                mDestination = dest;
        }


        // ----------------------------------------------------------------------------
        Unit* ControlGroup::getLeaderUnit ()
        {
                assert ( !mUnits.empty() );
                return mUnits[0];
        }


        // ----------------------------------------------------------------------------
        Vector3 ControlGroup::getUnitDestination ( Unit* unit )
        {
                if ( mDirty )
                        _updateFormation ();

                int index = getUnitIndex ( unit );

                return getUnitDestination ( index );
        }


        // ----------------------------------------------------------------------------
        Vector3 ControlGroup::getUnitDestination ( int index )
        {
                OgreAssert ( index < mUnits.size (), "Unit index out of bounds" );

                //update ();

                // TODO
                //              Ask the Formation for the offset
                //              Currently just returning a huge line
                int xPos;
                if ( (index % 5) % 2 == 0 )
                        xPos = (index % 5) / 2;
                else
                        xPos = -( (index % 5) + 1 ) / 2;

                int zPos;
                zPos = -(index / 5);

                // TODO
                //              Take the orientation of the ControlGroup into account
                //              Use the "right" vector as well as the negated "forward"
                //              vector (mOrientation)
                //              Possibly snap to 90° rotations ala Starcraft
                Vector3 xOffset = mRight * 30;
                Vector3 zOffset = mForward * 30;

                Vector3 localPos = mDestination + ( xOffset * xPos ) + ( zOffset * zPos );
                return localPos;
        }


        // ----------------------------------------------------------------------------
        Unit* ControlGroup::getUnit ( int index )
        {
                OgreAssert ( index < mUnits.size (), "Unit index out of bounds" );
                return mUnits[index];
        }


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


        // ----------------------------------------------------------------------------
        void ControlGroup::_calcOrientation ()
        {
                mForward = mDestination - mFormationCenter;
                mForward.normalise ();

                // X-axis heavy
                if ( Math::Abs(mForward.x) >= Math::Abs(mForward.z) )
                        mForward.y = mForward.z = 0.0f;
                // Z-axis heavy
                else
                        mForward.y = mForward.x = 0.0f;

                mForward.normalise ();
        
                mRight = mForward.crossProduct ( -Vector3::UNIT_Y );
                mRight.normalise ();
        }


        // ----------------------------------------------------------------------------
        void ControlGroup::update ()
        {
                _calcCenter ();
                _calcOrientation ();
        }
}

---