D:/simple_rts/src/Team.cpp

Go to the documentation of this file.

#include "Team.h"
#include "Game.h"

#include "FogOfWar.h"

#include "Unit.h"
#include "Building.h"
#include "TeamUpdater.h"

#include "TeamUnits.h"
#include "TeamBuildings.h"
#include "Level.h"
#include "ControlGroup.h"

#include "OgreEntity.h"
#include "OgreSubEntity.h"
#include "OgreException.h"
#include "OgreMaterial.h"
#include "OgreColourValue.h"
#include "OgreString.h"
#include "OgreStringConverter.h"
#include "OgreMaterialManager.h"
#include "Ogre.h"
using namespace Ogre;
using Ogre::SubEntity;
using Ogre::Entity;
using Ogre::MaterialManager;
using Ogre::Material;
using Ogre::ColourValue;
using Ogre::String;
using Ogre::StringConverter;
using Ogre::Exception;


namespace ASR
{
        // ----------------------------------------------------------------------------
        Team::Team ( const String& name, const ColourValue& teamColor )
                : mName ( name )
        {
                mUnits = new TeamUnits ( this );
                mBuildings = new TeamBuildings ();

                mFogOfWar = new FogOfWar ( Level::getSingleton ().getNumNodesWide (), Level::getSingleton ().getNumNodesHigh () );

                mUpdater = new TeamUpdater ( this );
                Game::getSingleton ().addUpdater ( mUpdater );

                mControlGroups.clear ();
                mActiveGroup = createControlGroup();
                setActiveControlGroup ( mActiveGroup );

                mUnits->setSpatialGridSize ( 12, 12 );

                // HACK
                //      Defining custom colors
                MaterialPtr baseMat = MaterialManager::getSingleton ().getByName ("LizardMan" );
                MaterialPtr feathersMat = MaterialManager::getSingleton ().getByName ("LizardMan_Feathers" );
                MaterialPtr shoulderMat = MaterialManager::getSingleton ().getByName ("Lizardman_Armor" );
                
                baseMat->load ();
                feathersMat->load ();
                shoulderMat->load ();
                
                mFeathersMaterialName = feathersMat->getName() + "_team" + StringConverter::toString ( Level::getSingleton().getNumTeams() );
                mBaseMaterialName = baseMat->getName() + "_team" + StringConverter::toString ( Level::getSingleton().getNumTeams() );
                mShoulderMaterialName = shoulderMat->getName() + "_team" + StringConverter::toString ( Level::getSingleton().getNumTeams() );
                
                MaterialPtr teamFeathersMaterial = feathersMat->clone ( mFeathersMaterialName );
                MaterialPtr teamBaseMaterial = baseMat->clone ( mBaseMaterialName );
                MaterialPtr teamShoulderMaterial = shoulderMat->clone ( mShoulderMaterialName );

                teamBaseMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setColourOperationEx(LBX_BLEND_TEXTURE_ALPHA, LBS_TEXTURE, LBS_MANUAL, ColourValue::White, teamColor );
                teamFeathersMaterial->getSupportedTechnique(0)->getPass(0)->getTextureUnitState(1)->setColourOperationEx(LBX_MODULATE, LBS_MANUAL, LBS_CURRENT, teamColor );
                teamShoulderMaterial->getSupportedTechnique(0)->getPass(0)->getTextureUnitState(0)->setColourOperationEx(LBX_BLEND_TEXTURE_ALPHA, LBS_TEXTURE, LBS_MANUAL, ColourValue::White, teamColor );
        }


        // ----------------------------------------------------------------------------
        Team::~Team ()
        {
                _destroyAllControlGroups ();
                delete mUnits;
                delete mBuildings;
                delete mUpdater;
                delete mFogOfWar;
        }


        // ----------------------------------------------------------------------------
        const String& Team::getName () const
        {
                return mName;
        }


        // ----------------------------------------------------------------------------
        Unit* Team::createUnit ( const UnitType& type )
        {
                Unit* newUnit = mUnits->createUnit( type.getMeshName() );
                _applyTeamColors ( newUnit );
                return newUnit;
        }


        // ----------------------------------------------------------------------------
        Building* Team::createBuilding ( const String& meshName, const Vector3& position )
        {
                Building* newBuilding = mBuildings->createBuilding( meshName, position );
                _applyTeamColors ( newBuilding );
                return newBuilding;
        }


        // ----------------------------------------------------------------------------
        void Team::findTargets ()
        {
                Level& lev = Level::getSingleton();

                TeamUnits::UnitIterator iter = mUnits->getUnitIterator();
                while ( iter.hasMoreElements() )
                {
                        Unit* unit = iter.getNext();

                        lev.getAdjacentUnits ( unit->getPosition(), unit->getSightRadius () );
                }
        }


        // ----------------------------------------------------------------------------
        ControlGroup* Team::createControlGroup ()
        {
                // TODO
                //      Make sure that when removing the last unit from a control group, it
                //      is deleted
                ControlGroup* group = new ControlGroup ();
                mControlGroups.push_back ( group );
                return group;
        }


        // ----------------------------------------------------------------------------
        void Team::destroyControlGroup ( ControlGroup* group )
        {
                ControlGroups::iterator iter = find ( mControlGroups.begin(), mControlGroups.end(), group );
                if ( iter == mControlGroups.end() )
                        throw Exception ( Exception::ERR_ITEM_NOT_FOUND, "Control group not found", "Team::destroyControlGroup" );

                delete (*iter);
                mControlGroups.erase ( iter );
        }


        // ----------------------------------------------------------------------------
        void Team::_destroyAllControlGroups ()
        {
                ControlGroups::iterator iter = mControlGroups.begin ();
                while ( iter != mControlGroups.end () )
                {
                        delete (*iter);
                        iter++;
                }

                mControlGroups.clear ();
        }


        // ----------------------------------------------------------------------------
        TeamUnits::UnitIterator Team::getUnitIterator () const
        {
                return mUnits->getUnitIterator ();
        }


        // ----------------------------------------------------------------------------
        void Team::setActiveControlGroup ( ControlGroup* group )
        {
                mActiveGroup = group;
        }


        // ----------------------------------------------------------------------------
        ControlGroup* Team::getActiveControlGroup () const
        {
                return mActiveGroup;
        }


        // ----------------------------------------------------------------------------
        void Team::destroyActiveControlGroup ()
        {
                destroyControlGroup ( mActiveGroup );
        }


        // ----------------------------------------------------------------------------
        void Team::_applyTeamColors ( Unit* unit )
        {
                unit->getEntity()->getSubEntity(1)->setMaterialName ( mFeathersMaterialName );
                unit->getEntity()->getSubEntity (0)->setMaterialName ( mBaseMaterialName );


                unit->mShield->setMaterialName ( mShoulderMaterialName );
                unit->mShoulder->setMaterialName ( mShoulderMaterialName );
        }


        // ----------------------------------------------------------------------------
        void Team::_applyTeamColors ( Building* building )
        {
                // TODO
                //              Fill this in
        }


        // ----------------------------------------------------------------------------
        TeamUnits::UnitList Team::getAdjacentUnits ( const Vector3& worldPos, float radius )
        {
                return mUnits->getAdjacentUnits ( worldPos, radius );
        }


        // ----------------------------------------------------------------------------
        FogOfWar* Team::getFogOfWar () const
        {
                return mFogOfWar;
        }
};

---