Changeset 2844 for code/branches/gui/src/core/Game.h

Timestamp:

Mar 25, 2009, 5:23:00 PM (16 years ago)

Author:

rgrieder

Message:

Implemented new GameState concept. It doesn't differ that much from the old one, but there's still lots of changes.
The most important change is that one GameState can occur multiple times in the hierarchy.

Short log:

• No RootGameState anymore. Simply the highest is root.
• Game::requestGameState(name) can refer to the parent, grandparent, great-grandparent, etc. or one of the children.
• Requested states are saved. So if you select "level", the next request (even right after the call) will be relative to "level"
• Game::popState() will simply unload the current one
• Re added Main.cc again because Game as well as GameState have been moved to the core
• Adapted all GameStates to the new system

Things should already work, except for network support because standalone only works with a little hack.
We can now start creating a better hierarchy.

File:

• code/branches/gui/src/core/Game.h (moved) (moved from code/branches/gui/src/orxonox/Game.h) (5 diffs)

code/branches/gui/src/core/Game.h

@@ -36 +36 @@
 #define _Game_H__
 
-#include "OrxonoxPrereqs.h"
+#include "CorePrereqs.h"
 #include <cassert>
 #include <list>
-#include "core/OrxonoxClass.h"
+#include <map>
+#include <vector>
+#include "OrxonoxClass.h"
+
+#define AddGameState(classname, name, ...) \
+    static bool bGameStateDummy_##classname##__LINE__ = orxonox::Game::addGameState(new classname(name, __VA_ARGS__))
 
 namespace orxonox
@@ -47 +52 @@
         Main class responsible for running the game.
     */
-    class _OrxonoxExport Game : public OrxonoxClass
+    class _CoreExport Game : public OrxonoxClass
     {
     public:
@@ -54 +59 @@
         void setConfigValues();
 
+        void setStateHierarchy(const std::string& str);
+        GameState* getState(const std::string& name);
+
         void run();
         void stop();
+
+        void requestState(const std::string& name);
+        void popState();
 
         float getAvgTickTime() { return this->avgTickTime_; }
@@ -62 +73 @@
         void addTickTime(uint32_t length);
 
+        static bool addGameState(GameState* state);
         static Game& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
 
@@ -73 +85 @@
         Game(Game&); // don't mess with singletons
 
-        Core* core_;
-        Clock* gameClock_;
+        void loadState(GameState* state);
+        void unloadState(GameState* state);
 
-        bool abort_;
+        std::vector<GameState*>         activeStates_;
+        GameStateTreeNode*              rootStateNode_;
+        GameStateTreeNode*              activeStateNode_;
+        std::vector<GameStateTreeNode*> requestedStateNodes_;
+
+        Core*                           core_;
+        Clock*                          gameClock_;
+
+        bool                            abort_;
 
         // variables for time statistics
-        uint64_t              statisticsStartTime_;
-        std::list<statisticsTickInfo>
-                              statisticsTickTimes_;
-        uint32_t              periodTime_;
-        uint32_t              periodTickTime_;
-        float                 avgFPS_;
-        float                 avgTickTime_;
+        uint64_t                        statisticsStartTime_;
+        std::list<statisticsTickInfo>   statisticsTickTimes_;
+        uint32_t                        periodTime_;
+        uint32_t                        periodTickTime_;
+        float                           avgFPS_;
+        float                           avgTickTime_;
 
         // config values
-        unsigned int          statisticsRefreshCycle_;
-        unsigned int          statisticsAvgLength_;
+        unsigned int                    statisticsRefreshCycle_;
+        unsigned int                    statisticsAvgLength_;
 
+        static std::map<std::string, GameState*> allStates_s;
         static Game* singletonRef_s;        //!< Pointer to the Singleton
     };