D:/simple_rts/src/main.cpp

Go to the documentation of this file.

#include "ExampleApplication.h"

#include "Game.h"
#include "Client.h"



#include "RTSCamera.h"
#include "RTSCameraUpdater.h"

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

#include "UnitTypeManager.h"

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

#include "Level.h"
#include "LevelStatusVisualizer.h"

#include "OgreVector3.h"
#include "OgreMath.h"

#include <math.h>
#include <exception>

using namespace Ogre;
using namespace ASR;

using std::exception;


// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// HACK AREA
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

//const float UNIT_SCALE = 1.0f / 2.0f;
const float UNIT_SCALE = 1.0f;
const int UNIT_COUNT = 10;
const int BUILDING_COUNT = 5;

const float TERRAIN_QUERY_HEIGHT = 5000.0f;

RaySceneQuery* mSceneRayQuery;


// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
//
// END HACK AREA
//
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
class TutorialApplication : public ExampleApplication
{
// Data Storage
// ----------------------------------------------------------------------------
private:
        Client*                         mClient;
        Game*                           mGame;

        //
        // HACKS
        //
        LevelStatusVisualizer*  mLevelVisual;

        

// Construction
// ----------------------------------------------------------------------------
public:
        TutorialApplication()
        {
                mClient = NULL;
                mGame = NULL;

                //
                // HACKS
                //
                mSceneRayQuery = NULL;
                mLevelVisual = NULL;
        }

        ~TutorialApplication() 
        {
                //
                // HACKS
                //
                delete mLevelVisual;
                if ( mSceneRayQuery )
                        mSceneMgr->destroyQuery ( mSceneRayQuery );

                delete UnitTypeManager::getSingletonPtr();

                delete mClient;
                delete mGame;
        }


// ----------------------------------------------------------------------------
protected:
        // ----------------------------------------------------------------------------
        void chooseSceneManager()
        {
                mSceneMgr = mRoot->createSceneManager( "TerrainSceneManager" );
                mSceneMgr->setShadowTechnique( SHADOWTYPE_STENCIL_MODULATIVE );

                //mSceneMgr->setAmbientLight( ColourValue( 1.0f, 0.874, 0.6356 ) );
                mSceneRayQuery = mSceneMgr->createRayQuery( Ray() );

                mGame = new Game ( mSceneMgr, mWindow );
                mGame->createLevel ();

                mClient = new Client ( mWindow );
        }


        // ----------------------------------------------------------------------------
        void createFrameListener ()
        {
                Level* lev = Game::getSingleton ().getLevel ();
                Team* teamA = lev->getTeam ( 0 );
                SceneNode* baseNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( "levelVisualizer" );

                mLevelVisual = new LevelStatusVisualizer ( Game::getSingleton ().getLevel() );

                Game::getSingleton ().addUpdater ( mLevelVisual );

                //mRTSCamera->getCamera()->setPolygonMode ( Ogre::PM_WIREFRAME );
        }


        // ----------------------------------------------------------------------------
        void createCamera ()
        {
                mClient->createCamera ();
        }


        // ----------------------------------------------------------------------------
        void createViewports ()
        {

        }


        // ----------------------------------------------------------------------------
        void createUnitTypes ()
        {
                // TODO
                //              Load these in from a file instead of hard coding them
                new UnitTypeManager();
                UnitTypeManager* typeMgr = UnitTypeManager::getSingletonPtr();
                UnitType* robotType = typeMgr->createUnitType( "robot" );
                robotType->setMesh( "lizardman.mesh" );
        }


        // ----------------------------------------------------------------------------
        void createScene(void)
        {
                mSceneMgr->setWorldGeometry( "ASR_terrain.cfg" );

                createUnitTypes ();

                Level* curLevel = Game::getSingleton ().getLevel ();

                curLevel->setWorldDimensions ( 2560, 2560 );
                //mLevel->setCellSize ( 10.0f, 10.0f );
                //curLevel->setCellSize ( 10.0f, 10.0f );
                curLevel->setDimensions ( 256, 256 );
                curLevel->rebuild ();

                _createTeamA ();
                _createTeamB ();
                _createTeamC ();

                mSceneMgr->setAmbientLight( ColourValue( 0.5, 0.5, 0.5 ) );

                Light* light = mSceneMgr->createLight( "Light1" );
                light->setType( Light::LT_DIRECTIONAL );
                light->setDirection ( Vector3(-0.5, -1, -1 ) );
                //light->setPosition( Vector3(50, 250, 100) );
                light->setDiffuseColour( 1.0, 1.0, 1.0 );
                light->setSpecularColour( 1.0, 1.0, 1.0 );
        }

        
        // ----------------------------------------------------------------------------
        void _createTeamA ()
        {
                Team* teamA = mClient->createTeam ( "TeamA", ColourValue ( 1.0, 0.0, 0.0 ) );
                //mTeamA->setSpatialGridSize ( 100, 100 );

                // Create some buildings
                for ( int i = 0; i < BUILDING_COUNT; i++ )
                {
                        float x = 300 + (i % (int)sqrt(double(BUILDING_COUNT) ) ) * 290;
                        float z = 800 + (i / (int)sqrt(double(BUILDING_COUNT) ) ) * 250;

                        Ray barracksRay ( Vector3(x, TERRAIN_QUERY_HEIGHT, z), Vector3::NEGATIVE_UNIT_Y );
                        mSceneRayQuery->setRay ( barracksRay );
                        RaySceneQueryResult& result = mSceneRayQuery->execute();
                        RaySceneQueryResult::iterator iter = result.begin();
                        if ( iter != result.end() )
                        {
                                if ( iter->worldFragment )
                                {
                                        // TODO
                                        //              Make the buildings themselves figure out where they should be placed (y-axis)
                                        Real terrainHeight = iter->worldFragment->singleIntersection.y;
                                        Building* building = teamA->createBuilding( "blacksmith.mesh", Vector3(x, terrainHeight, z ) );
                                }
                                iter++;
                        }
                }

                // Create some units
                for ( int i = 0; i < UNIT_COUNT; i++ )
                {
                        Unit* unit = teamA->createUnit ( *(UnitTypeManager::getSingleton().getUnitType ( "robot" )) );
                        unit->scale ( UNIT_SCALE, UNIT_SCALE, UNIT_SCALE );
                        unit->translate( Vector3((i % (int)sqrt(double(UNIT_COUNT))) * 60 + 10, 120, (i / (int)sqrt((double)UNIT_COUNT)) * 60 + 10) );
                }

                /*
                Unit* unit;
                
                unit = teamA->createUnit ( *(UnitTypeManager::getSingleton().getUnitType ( "robot" )) );
                unit->translate( Vector3( 10, 0, 10 ) );

                unit = teamA->createUnit ( *(UnitTypeManager::getSingleton().getUnitType ( "robot" )) );
                unit->translate( Vector3 (500, 0, 10) );
                */
        }


        // ----------------------------------------------------------------------------
        void _createTeamB ()
        {
                Level* curLevel = Game::getSingleton ().getLevel ();
                Team* teamB = curLevel->createTeam ( "TeamB", ColourValue ( 0.0, 0.0, 1.0 ) );

                for ( int i = 0; i < UNIT_COUNT * 3; i++ )
                {
                        Unit* unit = teamB->createUnit ( *(UnitTypeManager::getSingleton ().getUnitType ( "robot" ) ) );
                        unit->scale ( UNIT_SCALE, UNIT_SCALE, UNIT_SCALE );
                        unit->translate( Vector3( 100, 120, i * 60) );
                }

                for ( int i = 0; i < UNIT_COUNT * 2; i++ )
                {
                        Unit* unit = teamB->createUnit ( *(UnitTypeManager::getSingleton ().getUnitType ( "robot" ) ) );
                        unit->scale ( UNIT_SCALE, UNIT_SCALE, UNIT_SCALE );
                        unit->translate( Vector3( 200, 120, i * 60) );
                }

                /*
                Unit* unit;

                unit = teamB->createUnit ( *(UnitTypeManager::getSingleton().getUnitType ( "robot" )) );
                unit->translate( Vector3( 120, 0, 10 ) );
                */
        }


        // ----------------------------------------------------------------------------
        void _createTeamC ()
        {
                Level* curLevel = Game::getSingleton ().getLevel ();
                Team* teamC = curLevel->createTeam ( "TeamC", ColourValue ( 0.0, 1.0, 1.0 ) );

                for ( int i = 0; i < 10; i++ )
                {
                        Unit* unit = teamC->createUnit ( *(UnitTypeManager::getSingleton ().getUnitType ( "robot" ) ) );
                        unit->scale ( UNIT_SCALE, UNIT_SCALE, UNIT_SCALE );
                        unit->translate( Vector3(300, 120, i * 60) );
                }
        }
};



// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------


#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
#define WIN32_LEAN_AND_MEAN
#include "windows.h"

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
#else
int main(int argc, char **argv)
#endif
{
        // Create application object
        TutorialApplication app;

        try {
                app.go();
        } catch( Exception& e ) {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 
                MessageBoxA( NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
                fprintf(stderr, "An exception has occured: %s\n",
                        e.getFullDescription().c_str());
#endif
        }
        catch ( exception& e )
        {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 
                MessageBoxA( NULL, e.what (), "An unknown exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
                fprintf(stderr, "An non Ogre exception has occured: %s\n",
                        e.what() );
#endif
        }

        return 0;
}

---