Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Oct 27, 2008, 10:56:51 PM (16 years ago)
Author:
rgrieder
Message:
  • Added support for dedicated server. Could not network test it yet, client still segfaults me.
  • Also kicked GraphicsEngine::levelSceneManager_, there are only the statistic methods left.
  • GSDedicated also derives from GSLevel, but GSLevel is not anymore a real GameState.
  • CameraHandler and LevelManager get created in GSLevel now.
Location:
code/branches/objecthierarchy/src/orxonox/gamestates
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSClient.cc

    r2004 r2023  
    4040
    4141    GSClient::GSClient()
    42         : GSLevel("client")
     42        : GameState<GSGraphics>("client")
    4343        , client_(0)
    4444    {
    … …  
    5353        Core::setIsClient(true);
    5454
    55         GSLevel::enter();
    56 
    5755        this->client_ = new network::Client(CommandLine::getValue("ip").getString(), CommandLine::getValue("port"));
    5856
    … …  
    6058            ThrowException(InitialisationFailed, "Could not establish connection with server.");
    6159
     60        GSLevel::enter(this->getParent()->getViewport());
     61
    6262        client_->tick(0);
    63 
    64         // level is loaded: we can start capturing the input
    65         InputManager::getInstance().requestEnterState("game");
    6663    }
    6764
    6865    void GSClient::leave()
    6966    {
    70         InputManager::getInstance().requestLeaveState("game");
    71 
    72         // TODO: How do we unload the level in client mode?
     67        GSLevel::leave();
    7368
    7469        client_->closeConnection();
    … …  
    7671        // destroy client
    7772        delete this->client_;
    78 
    79         GSLevel::leave();
    8073
    8174        Core::setIsClient(false);

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSClient.h

    r1755 r2023  
    3333#include "network/NetworkPrereqs.h"
    3434#include "GSLevel.h"
     35#include "GSGraphics.h"
    3536
    3637namespace orxonox
    3738{
    38     class _OrxonoxExport GSClient : public GSLevel
     39    class _OrxonoxExport GSClient : public GameState<GSGraphics>, public GSLevel
    3940    {
    4041    public:

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSDedicated.cc

    r2010 r2023  
    3030#include "GSDedicated.h"
    3131
    32 #include <OgreRoot.h>
    33 #include <OgreSceneManager.h>
    34 #include "core/ConsoleCommand.h"
    3532#include "core/CommandLine.h"
    36 #include "core/Loader.h"
    37 #include "core/XMLFile.h"
    3833#include "core/Core.h"
    3934#include "network/Server.h"
    40 #include "objects/Tickable.h"
    41 #include "Settings.h"
    42 #include "GraphicsEngine.h"
    4335
    4436namespace orxonox
    … …  
    4638    GSDedicated::GSDedicated()
    4739        : GameState<GSRoot>("dedicated")
    48         , timeFactor_(0)
    4940        , server_(0)
    50         , sceneManager_(0)
    51         , startFile_(0)
    5241    {
    5342    }
    … …  
    6150        Core::setHasServer(true);
    6251
    63         // create Ogre SceneManager for the level
    64         this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, "LevelSceneManager");
    65         COUT(4) << "Created SceneManager: " << sceneManager_->getName() << std::endl;
     52        this->server_ = new network::Server(CommandLine::getValue("port"));
     53        COUT(0) << "Loading scene in server mode" << std::endl;
    6654
    67         // temporary hack
    68         GraphicsEngine::getInstance().setLevelSceneManager(this->sceneManager_);
    69 
    70         // reset game speed to normal
    71         timeFactor_ = 1.0f;
    72 
    73         this->server_ = new network::Server(CommandLine::getValue("port"));
    74 
    75         // call the loader
    76         COUT(0) << "Loading level..." << std::endl;
    77         startFile_ = new XMLFile(Settings::getDataPath() + "levels/sample.oxw");
    78         Loader::open(startFile_);
     55        GSLevel::enter(0);
    7956
    8057        server_->open();
    81 
    82         // add console commands
    83         FunctorMember01<GSDedicated, float>* functor = createFunctor(&GSDedicated::setTimeFactor);
    84         functor->setObject(this);
    85         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
    8658    }
    8759
    8860    void GSDedicated::leave()
    8961    {
    90         // TODO: Remove and destroy console command
    91 
    92         Loader::unload(startFile_);
    93         delete this->startFile_;
     62        GSLevel::leave();
    9463
    9564        this->server_->close();
    9665        delete this->server_;
    97 
    98         Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
    9966
    10067        Core::setHasServer(false);
    … …  
    10370    void GSDedicated::ticked(const Clock& time)
    10471    {
    105         // Call the scene objects
    106         for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
    107             it->tick(time.getDeltaTime() * this->timeFactor_);
    108 
     72        GSLevel::ticked(time);
    10973        server_->tick(time.getDeltaTime());
    11074        this->tickChild(time);
    11175    }
    112 
    113     /**
    114     @brief
    115         Changes the speed of Orxonox
    116     */
    117     void GSDedicated::setTimeFactor(float factor)
    118     {
    119         this->timeFactor_ = factor;
    120     }
    12176}

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSDedicated.h

    r2010 r2023  
    3232#include "OrxonoxPrereqs.h"
    3333#include "network/NetworkPrereqs.h"
     34#include "GSLevel.h"
    3435#include "GSRoot.h"
    3536
    3637namespace orxonox
    3738{
    38     class _OrxonoxExport GSDedicated : public GameState<GSRoot>
     39    class _OrxonoxExport GSDedicated : public GameState<GSRoot>, public GSLevel
    3940    {
    4041    public:
    4142        GSDedicated();
    4243        ~GSDedicated();
    43 
    44         void setTimeFactor(float factor);
    45         float getTimeFactor() { return this->timeFactor_; }
    4644
    4745    private:
    … …  
    5048        void ticked(const Clock& time);
    5149
    52         void loadLevel();
    53         void unloadLevel();
    54 
    55         float                 timeFactor_;       //!< A factor to change the gamespeed
    5650        network::Server*      server_;
    57         Ogre::SceneManager*   sceneManager_;
    58         XMLFile*              startFile_;        //!< current hard coded default level
    5951    };
    6052}

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSGUI.cc

    r1755 r2023  
    3131
    3232#include <OgreViewport.h>
    33 #include "GraphicsEngine.h"
    3433#include "core/input/InputManager.h"
    3534#include "core/input/SimpleInputState.h"

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSGraphics.cc

    r2013 r2023  
    116116
    117117        // HACK: temporary:
    118         graphicsEngine_->renderWindow_  = this->renderWindow_;
    119         graphicsEngine_->root_          = this->ogreRoot_;
    120         graphicsEngine_->viewport_      = this->viewport_;
     118        //graphicsEngine_->renderWindow_  = this->renderWindow_;
     119        //graphicsEngine_->root_          = this->ogreRoot_;
     120        //graphicsEngine_->viewport_      = this->viewport_;
    121121
    122122
    … …  
    134134        // Load the InGameConsole
    135135        console_ = new InGameConsole();
    136         console_->initialise();
     136        console_->initialise(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
    137137
    138138        // load the CEGUI interface

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSIOConsole.cc

    r2013 r2023  
    3636
    3737#include "core/ConsoleCommand.h"
    38 #include "GraphicsEngine.h"
    3938
    4039namespace orxonox

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSLevel.cc

    r2010 r2023  
    3030#include "GSLevel.h"
    3131
    32 #include <OgreSceneManager.h>
    33 #include <OgreRoot.h>
    3432#include "core/input/InputManager.h"
    3533#include "core/input/SimpleInputState.h"
    … …  
    4139#include "core/ConfigValueIncludes.h"
    4240#include "core/CoreIncludes.h"
     41#include "core/Core.h"
    4342//#include "objects/Backlight.h"
     43#include "objects/CameraHandler.h"
    4444#include "objects/Tickable.h"
    4545#include "objects/Radar.h"
    4646//#include "tools/ParticleInterface.h"
    47 #include "GraphicsEngine.h"
     47#include "LevelManager.h"
    4848#include "Settings.h"
    4949
    5050namespace orxonox
    5151{
    52     GSLevel::GSLevel(const std::string& name)
    53         : GameState<GSGraphics>(name)
    54         , timeFactor_(1.0f)
    55         , sceneManager_(0)
     52    GSLevel::GSLevel()
     53//        : GameState<GSGraphics>(name)
     54        : timeFactor_(1.0f)
    5655        , keyBinder_(0)
    5756        , inputState_(0)
    5857        , radar_(0)
    5958        , startFile_(0)
     59        , cameraHandler_(0)
     60        , levelManager_(0)
    6061    {
    6162        RegisterObject(GSLevel);
    … …  
    7273    }
    7374
    74     void GSLevel::enter()
    75     {
    76         inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game", 20);
    77         keyBinder_ = new KeyBinder();
    78         keyBinder_->loadBindings("keybindings.ini");
    79         inputState_->setHandler(keyBinder_);
    80 
    81         // create Ogre SceneManager for the level
    82         this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, "LevelSceneManager");
    83         COUT(4) << "Created SceneManager: " << sceneManager_->getName() << std::endl;
    84 
    85         this->sceneManager_->setShadowTechnique(Ogre::SHADOWTYPE_STENCIL_ADDITIVE);
    86 
    87         // temporary hack
    88         GraphicsEngine::getInstance().setLevelSceneManager(this->sceneManager_);
    89 
    90         // Start the Radar
    91         this->radar_ = new Radar();
    92 
    93         // reset game speed to normal
    94         timeFactor_ = 1.0f;
    95 
    96         // TODO: insert slomo console command with
    97         // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
    98 
    99         // keybind console command
    100         FunctorMember<GSLevel>* functor1 = createFunctor(&GSLevel::keybind);
    101         functor1->setObject(this);
    102         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor1, "keybind"));
    103         FunctorMember<GSLevel>* functor2 = createFunctor(&GSLevel::tkeybind);
    104         functor2->setObject(this);
    105         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor2, "tkeybind"));
    106         // set our console command as callback for the key detector
    107         InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
     75    void GSLevel::enter(Ogre::Viewport* viewport)
     76    {
     77        if (Core::showsGraphics())
     78        {
     79            inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game", 20);
     80            keyBinder_ = new KeyBinder();
     81            keyBinder_->loadBindings("keybindings.ini");
     82            inputState_->setHandler(keyBinder_);
     83
     84            // create the global CameraHandler
     85            assert(viewport);
     86            this->cameraHandler_ = new CameraHandler(viewport);
     87
     88            // Start the Radar
     89            this->radar_ = new Radar();
     90        }
     91
     92        if (Core::isMaster())
     93        {
     94            // create the global LevelManager
     95            this->levelManager_ = new LevelManager();
     96
     97            // reset game speed to normal
     98            timeFactor_ = 1.0f;
     99
     100            this->loadLevel();
     101        }
     102
     103        if (Core::showsGraphics())
     104        {
     105            // TODO: insert slomo console command with
     106            // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
     107
     108            // keybind console command
     109            FunctorMember<GSLevel>* functor1 = createFunctor(&GSLevel::keybind);
     110            functor1->setObject(this);
     111            CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor1, "keybind"));
     112            FunctorMember<GSLevel>* functor2 = createFunctor(&GSLevel::tkeybind);
     113            functor2->setObject(this);
     114            CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor2, "tkeybind"));
     115            // set our console command as callback for the key detector
     116            InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
     117
     118            // level is loaded: we can start capturing the input
     119            InputManager::getInstance().requestEnterState("game");
     120        }
     121
     122        if (Core::isMaster())
     123        {
     124            // time factor console command
     125            FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
     126            functor->setObject(this);
     127            CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
     128        }
    108129    }
    109130
    … …  
    116137        //Loader::close();
    117138
    118         delete this->radar_;
    119 
    120         Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
    121 
    122         inputState_->setHandler(0);
    123         InputManager::getInstance().requestDestroyState("game");
    124         delete this->keyBinder_;
     139        if (Core::showsGraphics())
     140            InputManager::getInstance().requestLeaveState("game");
     141
     142        if (Core::isMaster())
     143            this->unloadLevel();
     144
     145        if (this->radar_)
     146            delete this->radar_;
     147
     148        if (this->cameraHandler_)
     149            delete this->cameraHandler_;
     150
     151        if (this->levelManager_)
     152            delete this->levelManager_;
     153
     154        if (Core::showsGraphics())
     155        {
     156            inputState_->setHandler(0);
     157            InputManager::getInstance().requestDestroyState("game");
     158            if (this->keyBinder_)
     159                delete this->keyBinder_;
     160        }
    125161    }
    126162
    … …  
    185221    void GSLevel::keybindInternal(const std::string& command, bool bTemporary)
    186222    {
    187         static std::string bindingString = "";
    188         static bool bTemporarySaved = false;
    189         static bool bound = true;
    190         // note: We use a long name to make 'sure' that the user doesn't use it accidentally.
    191         // Howerver there will be no real issue if it happens anyway.
    192         if (command.find(keyDetectorCallbackCode_) != 0)
    193         {
    194             if (bound)
     223        if (Core::showsGraphics())
     224        {
     225            static std::string bindingString = "";
     226            static bool bTemporarySaved = false;
     227            static bool bound = true;
     228            // note: We use a long name to make 'sure' that the user doesn't use it accidentally.
     229            // Howerver there will be no real issue if it happens anyway.
     230            if (command.find(keyDetectorCallbackCode_) != 0)
    195231            {
    196                 COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
    197                 InputManager::getInstance().requestEnterState("detector");
    198                 bindingString = command;
    199                 bTemporarySaved = bTemporary;
    200                 bound = false;
     232                if (bound)
     233                {
     234                    COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
     235                    InputManager::getInstance().requestEnterState("detector");
     236                    bindingString = command;
     237                    bTemporarySaved = bTemporary;
     238                    bound = false;
     239                }
     240                //else:  We're still in a keybind command. ignore this call.
    201241            }
    202             //else:  We're still in a keybind command. ignore this call.
    203         }
    204         else
    205         {
    206             if (!bound)
     242            else
    207243            {
    208                 // user has pressed the key
    209                 std::string name = command.substr(this->keyDetectorCallbackCode_.size());
    210                 COUT(0) << "Binding string \"" << bindingString << "\" on key '" << name << "'" << std::endl;
    211                 this->keyBinder_->setBinding(bindingString, name, bTemporarySaved);
    212                 InputManager::getInstance().requestLeaveState("detector");
    213                 bound = true;
     244                if (!bound)
     245                {
     246                    // user has pressed the key
     247                    std::string name = command.substr(this->keyDetectorCallbackCode_.size());
     248                    COUT(0) << "Binding string \"" << bindingString << "\" on key '" << name << "'" << std::endl;
     249                    this->keyBinder_->setBinding(bindingString, name, bTemporarySaved);
     250                    InputManager::getInstance().requestLeaveState("detector");
     251                    bound = true;
     252                }
     253                // else: A key was pressed within the same tick, ignore it.
    214254            }
    215             // else: A key was pressed within the same tick, ignore it.
    216255        }
    217256    }

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSLevel.h

    r2010 r2023  
    3737namespace orxonox
    3838{
    39     class _OrxonoxExport GSLevel : public GameState<GSGraphics>, public OrxonoxClass
     39    class _OrxonoxExport GSLevel : public OrxonoxClass //,public GameState<GSGraphics>
    4040    {
    4141        friend class ClassIdentifier<GSLevel>;
    4242    public:
    43         GSLevel(const std::string& name);
    44         virtual ~GSLevel();
     43        GSLevel();
     44        ~GSLevel();
    4545
    4646        // this has to be public because proteced triggers a bug in msvc
    … …  
    5050
    5151    protected:
    52         virtual void enter();
    53         virtual void leave();
    54         virtual void ticked(const Clock& time);
     52        void enter(Ogre::Viewport* viewport);
     53        void leave();
     54        void ticked(const Clock& time);
    5555
    5656        void loadLevel();
    5757        void unloadLevel();
    5858
    59         float timeFactor_;       //!< A factor to change the gamespeed
     59        float timeFactor_;       //!< A factor that sets the gamespeed. 1 is normal.
    6060
    6161        // console commands
    … …  
    6464        void keybindInternal(const std::string& command, bool bTemporary);
    6565
    66         Ogre::SceneManager*   sceneManager_;
    6766        KeyBinder*            keyBinder_;        //!< tool that loads and manages the input bindings
    6867        SimpleInputState*     inputState_;
    6968        Radar*                radar_;            //!< represents the Radar (not the HUD part)
    7069        XMLFile*              startFile_;        //!< current hard coded default level
     70        CameraHandler*        cameraHandler_;
     71        LevelManager*         levelManager_;
    7172
    7273        // config values

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSRoot.cc

    r2003 r2023  
    4141#include "core/TclThreadManager.h"
    4242#include "tools/Timer.h"
    43 #include "GraphicsEngine.h"
    4443#include "Settings.h"
    4544

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSServer.cc

    r2003 r2023  
    3030#include "GSServer.h"
    3131
    32 #include "core/ConsoleCommand.h"
    33 #include "core/input/InputManager.h"
    3432#include "core/CommandLine.h"
    3533#include "core/Core.h"
    … …  
    4139
    4240    GSServer::GSServer()
    43         : GSLevel("server")
     41        : GameState<GSGraphics>("server")
    4442        , server_(0)
    4543    {
    … …  
    5452        Core::setHasServer(true);
    5553
    56         GSLevel::enter();
    57 
    5854        this->server_ = new network::Server(CommandLine::getValue("port"));
    5955        COUT(0) << "Loading scene in server mode" << std::endl;
    6056
    61         this->loadLevel();
     57        GSLevel::enter(this->getParent()->getViewport());
    6258
    6359        server_->open();
    64 
    65         // add console commands
    66         FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
    67         functor->setObject(this);
    68         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
    69 
    70         // level is loaded: we can start capturing the input
    71         InputManager::getInstance().requestEnterState("game");
    7260    }
    7361
    7462    void GSServer::leave()
    7563    {
    76         InputManager::getInstance().requestLeaveState("game");
    77 
    78         // TODO: Remove and destroy console command
    79 
    80         this->unloadLevel();
     64        GSLevel::leave();
    8165
    8266        this->server_->close();
    8367        delete this->server_;
    84 
    85         GSLevel::leave();
    8668
    8769        Core::setHasServer(false);

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSServer.h

    r1755 r2023  
    3333#include "network/NetworkPrereqs.h"
    3434#include "GSLevel.h"
     35#include "GSGraphics.h"
    3536
    3637namespace orxonox
    3738{
    38     class _OrxonoxExport GSServer : public GSLevel
     39    class _OrxonoxExport GSServer : public GameState<GSGraphics>, public GSLevel
    3940    {
    4041    public:
    4142        GSServer();
    4243        ~GSServer();
    43 
    4444
    4545    private:

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc

    r1989 r2023  
    3030#include "GSStandalone.h"
    3131
    32 #include "core/input/InputManager.h"
    33 #include "core/ConsoleCommand.h"
    3432#include "core/Core.h"
    3533
    … …  
    3735{
    3836    GSStandalone::GSStandalone()
    39         : GSLevel("standalone")
     37        : GameState<GSGraphics>("standalone")
    4038    {
    4139    }
    … …  
    4745    void GSStandalone::enter()
    4846    {
    49         GSLevel::enter();
     47        Core::setIsStandalone(true);
    5048
    51         Core::setIsStandalone(true);
    52         this->loadLevel();
    53 
    54         // add console commands
    55         FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
    56         functor->setObject(this);
    57         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
    58 
    59         // level is loaded: we can start capturing the input
    60         InputManager::getInstance().requestEnterState("game");
     49        GSLevel::enter(this->getParent()->getViewport());
    6150    }
    6251
    6352    void GSStandalone::leave()
    6453    {
    65         InputManager::getInstance().requestLeaveState("game");
    66 
    67         // TODO: Remove and destroy console command
    68 
    69         this->unloadLevel();
    70 
    7154        GSLevel::leave();
    7255

  • code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.h

    r1755 r2023  
    3232#include "OrxonoxPrereqs.h"
    3333#include "GSLevel.h"
     34#include "GSGraphics.h"
    3435
    3536namespace orxonox
    3637{
    37     class _OrxonoxExport GSStandalone : public GSLevel
     38    class _OrxonoxExport GSStandalone : public GameState<GSGraphics>, public GSLevel
    3839    {
    3940    public:
Note: See TracChangeset for help on using the changeset viewer.