Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Mar 25, 2009, 11:53:04 PM (16 years ago)
Author:
rgrieder
Message:
  • Started working on cleaning up the GameState mess ;)
  • Cleaned out GUIManager
  • Renamed GSGUI to GSMainMenu
  • "—state blah" has been changed to —server, —client, —standalone, —dedicated
  • —console starts the game in the console (no level loading there yet, but "loadMenu")
  • adjusted run scripts
Location:
code/branches/gui/src/orxonox/gamestates
Files:
7 edited
2 moved

Legend:

Unmodified
Added
Removed

  • code/branches/gui/src/orxonox/gamestates/CMakeLists.txt

    r2710 r2850  
    11ADD_SOURCE_FILES(ORXONOX_SRC_FILES
     2  GSClient.cc
    23  GSDedicated.cc
    3   GSClient.cc
    44  GSGraphics.cc
    5   GSGUI.cc
    65  GSIOConsole.cc
    76  GSLevel.cc
     7  GSMainMenu.cc
    88  GSRoot.cc
    99  GSServer.cc

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

    r2848 r2850  
    3535#include "util/Debug.h"
    3636#include "core/ConfigValueIncludes.h"
     37#include "core/Clock.h"
    3738#include "core/Core.h"
    3839#include "core/CoreIncludes.h"
    … …  
    146147        this->inputManager_->update(time);        // tick console
    147148        this->console_->update(time);
     149        this->guiManager_->update(time);
    148150
    149151        uint64_t timeAfterTick = time.getRealMicroseconds();
    … …  
    152154        Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
    153155
     156        // Render
    154157        this->graphicsManager_->update(time);
    155158    }

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

    r2844 r2850  
    5353    void GSIOConsole::activate()
    5454    {
     55        {
     56            FunctorMember<GSIOConsole>* functor = createFunctor(&GSIOConsole::loadMenu);
     57            functor->setObject(this);
     58            this->ccLoadMenu_ = createConsoleCommand(functor, "loadMenu");
     59            CommandExecutor::addConsoleCommandShortcut(this->ccLoadMenu_);
     60        }
    5561    }
    5662
    5763    void GSIOConsole::deactivate()
    5864    {
     65        if (this->ccLoadMenu_)
     66        {
     67            delete this->ccLoadMenu_;
     68            this->ccLoadMenu_ = 0;
     69        }
    5970    }
    6071
    6172    void GSIOConsole::update(const Clock& time)
    6273    {
     74        std::cout << ">";
    6375        std::string command;
    6476        std::getline(std::cin, command);
    6577        CommandExecutor::execute(command, true);
    6678    }
     79
     80    void GSIOConsole::loadMenu()
     81    {
     82        Game::getInstance().popState();
     83        Game::getInstance().requestStates("graphics, mainMenu");
     84    }
    6785}

  • code/branches/gui/src/orxonox/gamestates/GSIOConsole.h

    r2844 r2850  
    4646
    4747    private:
     48        void loadMenu();
    4849
     50        // console commands
     51        ConsoleCommand* ccLoadMenu_;
    4952    };
    5053}

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

    r2848 r2850  
    4949#include "LevelManager.h"
    5050#include "PlayerManager.h"
     51#include "gui/GUIManager.h"
    5152
    5253namespace orxonox
    … …  
    8687        if (GameMode::showsGraphics())
    8788        {
     89            {
     90                FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::toggleGUI);
     91                functor->setObject(this);
     92                this->ccToggleGUI_ = createConsoleCommand(functor, "toggleGUI");
     93                CommandExecutor::addConsoleCommandShortcut(this->ccToggleGUI_);
     94            }
     95
    8896            inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game");
    8997            keyBinder_ = new KeyBinder();
    … …  
    110118        if (GameMode::showsGraphics())
    111119        {
    112             // TODO: insert slomo console command with
    113             // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
    114 
    115120            // keybind console command
    116121            FunctorMember<GSLevel>* functor1 = createFunctor(&GSLevel::keybind);
    … …  
    125130            InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
    126131
     132            // InGame GUI test
     133            GUIManager::getInstance().showGUI("inGameTest");
     134
    127135            // level is loaded: we can start capturing the input
    128136            InputManager::getInstance().requestEnterState("game");
    … …  
    143151            this->ccTkeybind_ = 0;
    144152        }
     153        if (this->ccToggleGUI_)
     154        {
     155            delete this->ccToggleGUI_;
     156            this->ccToggleGUI_ = 0;
     157        }
     158
    145159
    146160        // this call will delete every BaseObject!
    … …  
    219233
    220234        delete this->startFile_;
     235    }
     236
     237    void GSLevel::toggleGUI()
     238    {
     239        if (GameMode::showsGraphics())
     240        {
     241            GUIManager::getInstance().executeCode("toggleGUI()");
     242        }
    221243    }
    222244

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

    r2844 r2850  
    4747        void update(const Clock& time);
    4848
     49        void toggleGUI();
     50
    4951    protected:
    5052        void loadLevel();
    … …  
    7072        ConsoleCommand*       ccKeybind_;
    7173        ConsoleCommand*       ccTkeybind_;
    72 
     74        ConsoleCommand*       ccToggleGUI_;
    7375    };
    7476}

  • code/branches/gui/src/orxonox/gamestates/GSMainMenu.cc

    r2848 r2850  
    2828
    2929#include "OrxonoxStableHeaders.h"
    30 #include "GSGUI.h"
     30#include "GSMainMenu.h"
    3131
    32 #include <OgreViewport.h>
     32//#include <OgreViewport.h>
     33#include <OgreSceneManager.h>
    3334#include "core/Clock.h"
    3435#include "core/ConsoleCommand.h"
    … …  
    3738#include "core/input/SimpleInputState.h"
    3839#include "gui/GUIManager.h"
     40#include "objects/Scene.h"
    3941#include "GraphicsManager.h"
    4042
    4143namespace orxonox
    4244{
    43     AddGameState(GSGUI, "mainMenu");
     45    AddGameState(GSMainMenu, "mainMenu");
    4446
    45     GSGUI::GSGUI(const std::string& name)
     47    GSMainMenu::GSMainMenu(const std::string& name)
    4648        : GameState(name)
     49        , inputState_(0)
    4750    {
    4851    }
    4952
    50     GSGUI::~GSGUI()
     53    GSMainMenu::~GSMainMenu()
    5154    {
    5255    }
    5356
    54     void GSGUI::activate()
     57    void GSMainMenu::activate()
    5558    {
    56         guiManager_ = GUIManager::getInstancePtr();
     59        inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("mainMenu");
     60        inputState_->setHandler(GUIManager::getInstancePtr());
     61        inputState_->setJoyStickHandler(&InputManager::EMPTY_HANDLER);
     62
     63        // create an empty Scene
     64        this->scene_ = new Scene(0);
     65        // and a Camera
     66        this->camera_ = this->scene_->getSceneManager()->createCamera("mainMenu/Camera");
    5767
    5868        // show main menu
    59         //guiManager_->loadScene("MainMenu");
    60         guiManager_->showGUI("MainMenu", 0);
    61         GraphicsManager::getInstance().getViewport()->setCamera(guiManager_->getCamera());
     69        GUIManager::getInstance().showGUI("mainMenu");
     70        GUIManager::getInstance().setCamera(this->camera_);
     71        GraphicsManager::getInstance().setCamera(this->camera_);
    6272
    6373        {
    64             // time factor console command
    65             FunctorMember<GSGUI>* functor = createFunctor(&GSGUI::startGame);
     74            FunctorMember<GSMainMenu>* functor = createFunctor(&GSMainMenu::startGame);
    6675            functor->setObject(this);
    6776            this->ccStartGame_ = createConsoleCommand(functor, "startGame");
    6877            CommandExecutor::addConsoleCommandShortcut(this->ccStartGame_);
    6978        }
     79       
     80        InputManager::getInstance().requestEnterState("mainMenu");
    7081    }
    7182
    72     void GSGUI::deactivate()
     83    void GSMainMenu::deactivate()
    7384    {
     85        InputManager::getInstance().requestLeaveState("game");
     86        InputManager::getInstance().requestDestroyState("game");
     87
    7488        if (this->ccStartGame_)
    7589        {
    … …  
    7892        }
    7993
    80         guiManager_->hideGUI();
     94        GUIManager::getInstance().executeCode("hideGUI()");
    8195    }
    8296
    83     void GSGUI::update(const Clock& time)
     97    void GSMainMenu::update(const Clock& time)
    8498    {
    85         // tick CEGUI
    86         guiManager_->update(time);
    8799    }
    88100
    89     void GSGUI::startGame()
     101    void GSMainMenu::startGame()
    90102    {
    91103        // HACK - HACK
    92104        Game::getInstance().popState();
    93         Game::getInstance().requestState("standalone");
    94         Game::getInstance().requestState("level");
     105        Game::getInstance().requestStates("standalone, level");
    95106    }
    96107}

  • code/branches/gui/src/orxonox/gamestates/GSMainMenu.h

    r2844 r2850  
    2727 */
    2828
    29 #ifndef _GSGUI_H__
    30 #define _GSGUI_H__
     29#ifndef _GSMainMenu_H__
     30#define _GSMainMenu_H__
    3131
    3232#include "OrxonoxPrereqs.h"
     33#include <OgrePrerequisites.h>
    3334#include "core/GameState.h"
    3435
    3536namespace orxonox
    3637{
    37     class _OrxonoxExport GSGUI : public GameState
     38    class _OrxonoxExport GSMainMenu : public GameState
    3839    {
    3940    public:
    40         GSGUI(const std::string& name);
    41         ~GSGUI();
     41        GSMainMenu(const std::string& name);
     42        ~GSMainMenu();
    4243
    4344        void activate();
    … …  
    4849
    4950    private:
    50         GUIManager* guiManager_;
     51        SimpleInputState* inputState_;
     52        Scene*            scene_;
     53        Ogre::Camera*     camera_;
    5154
    5255        // console commands
    … …  
    5558}
    5659
    57 #endif /* _GSGUI_H__ */
     60#endif /* _GSMainMenu_H__ */

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

    r2848 r2850  
    4444{
    4545    AddGameState(GSRoot, "root");
    46     SetCommandLineSwitch(startWithConsole);
     46    SetCommandLineSwitch(console);
     47    // Shortcuts for easy direct loading
     48    SetCommandLineSwitch(server);
     49    SetCommandLineSwitch(client);
     50    SetCommandLineSwitch(dedicated);
     51    SetCommandLineSwitch(standalone);
    4752
    4853    GSRoot::GSRoot(const std::string& name)
    … …  
    6368    {
    6469        // reset game speed to normal
    65         timeFactor_ = 1.0f;
     70        this->timeFactor_ = 1.0f;
    6671
    6772        {
    … …  
    8186        }
    8287
     88        // Load level directly?
     89        bool loadLevel = false;
     90        if (CommandLine::getValue("standalone").getBool())
     91        {
     92            Game::getInstance().requestStates("graphics, standalone, level");
     93            loadLevel = true;
     94        }
     95        if (CommandLine::getValue("server").getBool())
     96        {
     97            Game::getInstance().requestStates("graphics, server, level");
     98            loadLevel = true;
     99        }
     100        if (CommandLine::getValue("client").getBool())
     101        {
     102            Game::getInstance().requestStates("graphics, standalone, level");
     103            loadLevel = true;
     104        }
     105        if (CommandLine::getValue("dedicated").getBool())
     106        {
     107            Game::getInstance().requestStates("dedicated, level");
     108            loadLevel = true;
     109        }
     110       
    83111        // Determine where to start
    84         if (CommandLine::getValue("startWithConsole").getBool())
    85         {
    86             // Start the game in the console
    87             Game::getInstance().requestState("ioConsole");
    88         }
    89         else
    90         {
    91             // Start in GUI main menu
    92             Game::getInstance().requestState("graphics");
    93             Game::getInstance().requestState("mainMenu");
    94         }
    95 
     112        if (!loadLevel)
     113        {
     114            if (CommandLine::getValue("console").getBool())
     115            {
     116                // Start the game in the console without 3D graphics
     117                Game::getInstance().requestState("ioConsole");
     118            }
     119            else
     120            {
     121                // Start in GUI mode
     122                Game::getInstance().requestStates("graphics, mainMenu");
     123            }
     124        }
    96125    }
    97126
    … …  
    113142    void GSRoot::update(const Clock& time)
    114143    {
     144        if (this->getActivity().topState)
     145        {
     146            // This state can not 'survive' on its own.
     147            // Load a user interface therefore
     148            Game::getInstance().requestState("ioConsole");
     149        }
     150
    115151        uint64_t timeBeforeTick = time.getRealMicroseconds();
    116152
    … …  
    132168        uint64_t timeAfterTick = time.getRealMicroseconds();
    133169
    134         // Also add our tick time to the list in GSRoot
     170        // Also add our tick time
    135171        Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
    136172    }
Note: See TracChangeset for help on using the changeset viewer.