root/simulator/trunk/src/simulator/system.cpp

//    OSRail -- a network enabled railroad operations simulator and utilities
//    Copyright (C) 2007,2008 Samuel E. Henley sehenley@comcast.net
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License along
//    with this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
/// \file
/// Implementation file for System manager of the simulator and the ISystem factory.

// Pre-Compiled Header for Simulator
#include "presimulator.h"

// Always include required headers before this: reduce coupling
#include "system.h"


/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup system "System"
    /// @{

extern IAi*              createAi( ISystem& system );
extern IConsoleClient*   createConsoleClient( ISystem& system );
extern IFactory*         createFactory( ISystem& system );
extern IGraphics*        createGraphics( ISystem& system );
extern IGui*             createGui( ISystem& system );
extern IInput*           createInput( ISystem& system );
extern INetwork*         createNetwork( ISystem& system );
extern IPropertyManager* createPropertyManager( ISystem& system );
extern ISimulation*      createSimulation( ISystem& system );
extern ISound*           createSound( ISystem& system );
extern ISystem*          createSystem();
extern ITask*            createTask( ISystem& system );
extern ITest*            createTest( ISystem& system );

/// The ISystem factory
/// \return a System instance.
extern ISystem* createSystem()
{
    return new System;
}

System::System()
{
}

System::~System()
{
}

void System::setOptions( const boost::program_options::variables_map& map )
{

}


//virtual
void System::startup()
{
    MESSAGE( "Simulator", "System", "Startup" )

    /// \note Initialize simulation program.
    /// Initialize
    /// - console
    /// - tweaker
    /// - test
    /// - factory
    /// - property manager
    /// - ogre (graphics)
    /// - openal (sound)
    /// - ois (input)
    /// - gui
    /// - raknet (network)
    /// - ai
    /// - simulation
    /// - angelcode (simulation scripts)
    /// - splashscreen - after scripts, ogre and openal
    /// - go to running state

    states.push_back( boost::shared_ptr<SystemState>( new System::StartupState ) );
    ASSERT( !states.empty(), "Simulator", "System", "Should be in StartupState state" )
    states.back()->startup(*this); //state

    /// start console
    if( !( console = boost::shared_ptr<IConsoleClient>( createConsoleClient( *this ) ) )  )
        throw std::logic_error( _("Could not create console client"));
    ASSERT( console.unique(), "Simulator", "System", "Should be only one ConsoleClient" )
//    assert( console.unique() );
    console->startup();

    /// start realtime test
    if( !( test = boost::shared_ptr<ITest>( createTest( *this ) ) )  )
        throw std::logic_error( _("Could not create test software"));
    ASSERT( test.unique(), "Simulator", "System", "Should be only one Test manager" )
    test->startup();

    /// start factory
    if( !( factory = boost::shared_ptr<IFactory>( createFactory( *this ) ) )  )
        throw std::logic_error( _("Could not create factory software"));
    ASSERT( factory.unique(), "Simulator", "System", "Should be only one Factory" )
    factory->startup();

    /// start propertymanager
    if( !( propertymanager = boost::shared_ptr<IPropertyManager>( createPropertyManager( *this ) ) )  )
        throw std::logic_error( _("Could not create property manager software"));
    ASSERT( propertymanager.unique(), "Simulator", "System", "Should be only one Property manager" )
    propertymanager->startup();

    // ogre initialization
    /// \todo build simulator exception class
    if( !( graphics = boost::shared_ptr<IGraphics>( createGraphics( *this ) ) )  )
        throw std::logic_error( _("Could not create 3d graphics device"));
    ASSERT( graphics.unique(), "Simulator", "System", "Should be only one Graphics manager" )
    graphics->startup();

    // openal initialization
    if( !( sound = boost::shared_ptr<ISound>( createSound( *this ) ) )  )
        throw std::logic_error( _("Could not create sound device"));
    ASSERT( sound.unique(), "Simulator", "System", "Should be only one Sound manager" )
    sound->startup();

    // ois initialization
    if( !( input = boost::shared_ptr<IInput>( createInput( *this ) ) )  )
        throw std::logic_error( _("Could not create input device"));
    ASSERT( input.unique(), "Simulator", "System", "Should be only one Input manager" )
    input->startup();

    // gui initialization
    if( !( gui = boost::shared_ptr<IGui>( createGui( *this ) ) )  )
        throw std::logic_error( _("Could not create 2d graphics software"));
    ASSERT( gui.unique(), "Simulator", "System", "Should be only one GUI manager" )
    gui->startup();

    // raknet initialization
    if( !( network = boost::shared_ptr<INetwork>( createNetwork( *this ) ) )  )
        throw std::logic_error( _("Could not create network device"));
    ASSERT( network.unique(), "Simulator", "System", "Should be only one Network manager" )
    network->startup();

    // start ai
    if( !( ai = boost::shared_ptr<IAi>( createAi( *this ) ) )  )
        throw std::logic_error( _("Could not create ai client"));
    ASSERT( ai.unique(), "Simulator", "System", "Should be only one AI manager" )
    ai->startup();


    // start simulation
    if( !( simulation = boost::shared_ptr<ISimulation>( createSimulation( *this ) ) )  )
        throw std::logic_error( _("Could not create simulation client"));
    ASSERT( simulation.unique(), "Simulator", "System", "Should be only one Simulation manager" )
    simulation->startup();


    // start scripts machinery, must be last requires interface pointers
    if( !( task = boost::shared_ptr<ITask>( createTask( *this ) ) )  )
        throw std::logic_error( _("Could not create taskl/scripts software"));
    ASSERT( task.unique(), "Simulator", "System", "Should be only one Task manager" )
    task->startup();

}


//virtual
void System::shutdown()
{
    MESSAGE( "Simulator", "System", "Shutdown" )

    ASSERT( simulation.unique(), "Simulator", "System", "Should be only one Simulation manager" )
    simulation->shutdown();

    ASSERT( ai.unique(), "Simulator", "System", "Should be only one AI manager" )
    ai->shutdown();

    ASSERT( network.unique(), "Simulator", "System", "Should be only one Network manager" )
    network->shutdown( );

    ASSERT( gui.unique(), "Simulator", "System", "Should be only one GUI manager" )
    gui->shutdown();

    ASSERT( input.unique(), "Simulator", "System", "Should be only one Input manager" )
    input->shutdown();

    ASSERT( sound.unique(), "Simulator", "System", "Should be only one Sound manager" )
    sound->shutdown();

    ASSERT( task.unique(), "Simulator", "System", "Should be only one Task manager" )
    task->shutdown();

    ASSERT( graphics.unique(), "Simulator", "System", "Should be only one Graphics manager" )
    graphics->shutdown();

    ASSERT( propertymanager.unique(), "Simulator", "System", "Should be only one Property manager" )
    propertymanager->shutdown( );

    ASSERT( factory.unique(), "Simulator", "System", "Should be only one Factory" )
    factory->shutdown();

    ASSERT( test.unique(), "Simulator", "System", "Should be only one Test manager" )
    test->shutdown();

    ASSERT( console.unique(), "Simulator", "System", "Should be only one ConsoleClient" )
    console->shutdown();
}

/// Run the current simulator state.
void System::operator()()
{
    ASSERT( !states.empty(), "Simulator", "System", "Should be some state" )

    std::vector< boost::shared_ptr<SystemState> >::iterator it = states.begin();

    while( it != states.end() )(*it++)->background( *this );  //do every states background processing

    /// \note System State Mechine - foreground state
    /// Do only the top state foreground processing.
    /// Foreground processing can modify states - so
    /// therefore only one foreground state is allowed.
    states.back()->operator()( *this );

}

bool System::running() const
{
    IGraphics* p = dynamic_cast<IGraphics*>( graphics.get() );
    return !p->isClosed() && !states.empty();
}

bool System::anyState() const
{
    return !states.empty();
}

    /// @}   group system
/// @}   group simulator

// ////////////////////////// System State Machine /////////////////////////////
/// \addtogroup simulator "Simulator"
/// @{
    /// \addtogroup system "System"
    /// @{
        /// \addtogroup systemstate "System State Machine"
        /// @{

/// Simulation progran initization and splish screen.
/// Initialize the graphics, show the splash screen and
/// move to the GUI state.
/// \param system the containing class
template<> void System::StartupState::operator()( System& system ) //forground
{
    /// \todo splish screen
    system.states.back()->shutdown( system );
}

/// Move to the GUI state.
/// \param system the containing class
template<> void System::StartupState::shutdown( System& system )
{
    MESSAGE( "Simulator", "System::State", "StartupState::shutdown" )
    system.states.pop_back();
    system.states.push_back( boost::shared_ptr<SystemState>( new System::GuiState ) );
    system.states.back()->startup(system);
}

/// No operation
/// \param system the containing class
template<> void System::StartupState::startup( System& system )
{
    MESSAGE( "Simulator", "System::State", "StartupState::startup" )
}

/// No operation
/// \param system the containing class
template<> void System::StartupState::background( System& system )
{
}

/// Simulation program menu system.
/// Bring up the option and route seletion menus.
/// Stay in this state until a route or quit is selected.
/// If a route is selected request the initialization state.
/// \param system the containing class
template<> void System::GuiState::operator()( System& system ) //forground
{

    /// \todo forground GUI menu processing


    system.states.back()->shutdown( system );
}

/// Move to RouteStartupState
/// \param system the containing class
template<> void System::GuiState::shutdown( System& system )
{
    MESSAGE( "Simulator", "System::State", "GuiState::shutdown" )
    if( !system.running() )
    {
        system.states.pop_back();
        system.states.push_back( boost::shared_ptr<SystemState>( new System::ShutdownState ) );
        system.states.back()->startup( system );
    }
    else
    {
        system.states.pop_back();
        system.states.push_back( boost::shared_ptr<SystemState>( new System::RouteStartupState ) );
        system.states.back()->startup( system );
    }
}

/// Initialize GUI state
/// \param system the containing class
template<> void System::GuiState::startup( System& system )
{
    MESSAGE( "Simulator", "System::State", "GuiState::startup" )
    /// \todo Initialize GUI State
}

/// GUI State background processing
/// \param system the containing class
template<> void System::GuiState::background( System& system )
{
    /// \todo Background processing for visable menus and control keys
}

/// Load and startup a route.
/// Loads a selected route, started from GUIState.
/// After load is completeed requests Simulation state.
template<> void System::RouteStartupState::operator()( System& system )
{
    system.states.back()->shutdown( system );
}

template<> void System::RouteStartupState::startup( System& system )
{
    MESSAGE( "Simulator", "System::State", "RouteStartupState::startup" )
}

template<> void System::RouteStartupState::shutdown( System& system )
{
    MESSAGE( "Simulator", "System::State", "RouteStartupState::shutdown" )
    system.states.pop_back();
    system.states.push_back( boost::shared_ptr<SystemState>( new System::SimulationState ) );
    system.states.back()->startup( system );
}

template<> void System::RouteStartupState::background( System& system )
{
}

/// Unload and shutdown a route.
/// UnLoads a selected route, and moves to the GUIState.
/// After unload is completed requests GUIState state.
template<> void System::RouteShutdownState::operator()( System& system )
{
    system.states.back()->shutdown( system );
}

template<> void System::RouteShutdownState::startup( System& system )
{
    MESSAGE( "Simulator", "System::State", "RouteShutdownState::startup" )
}

template<> void System::RouteShutdownState::shutdown( System& system )
{
    MESSAGE( "Simulator", "System::State", "RouteShutdownState::shutdown" )
    system.states.pop_back();
    system.states.push_back( boost::shared_ptr<SystemState>( new System::GuiState ) );
    system.states.back()->startup( system );
}

template<> void System::RouteShutdownState::background( System& system )
{
}

/// Run the simulation.
/// Runs the simulation and returns to the GUI state.
template<> void System::SimulationState::operator()( System& system )
{
    //Input
    ASSERT( system.input != 0, "Simulator", "SimulationState", "Input should be initialized" )
    system.input->operator()(); //Will throw errors

    //Graphics
    ASSERT( system.graphics != 0, "Simulator", "SimulationState", "Graphics should be initialized" )
    system.graphics->operator()(); //Will throw errors

    if( !system.running() )system.states.back()->shutdown( system );
}

template<> void System::SimulationState::startup( System& system )
{
    MESSAGE( "Simulator", "System::State", "SimulationState::startup" )
}

template<> void System::SimulationState::shutdown( System& system )
{
    MESSAGE( "Simulator", "System::State", "SimulationState::shutdown" )
    system.states.pop_back();
    system.states.push_back( boost::shared_ptr<SystemState>( new System::RouteShutdownState ) );
    system.states.back()->startup( system );
}

template<> void System::SimulationState::background( System& system )
{
}

/// Simulation progran shutdown.
template<> void System::ShutdownState::operator()( System& system )
{
    system.states.back()->shutdown( system );
}

template<> void System::ShutdownState::startup( System& system )
{
    MESSAGE( "Simulator", "System::State", "ShutdownState::startup" )
}

template<> void System::ShutdownState::shutdown( System& system )
{
    MESSAGE( "Simulator", "System::State", "ShutdownState::shutdown" )
    system.states.pop_back();
    ASSERT( system.states.empty(), "Simulator", "System::State", "Should be no system states remainig at ShutdownState" )
    system.shutdown();
}

template<> void System::ShutdownState::background( System& system )
{
}

        /// @}   group systemstate
    /// @}   group system
/// @}   group simulator