Changeset 3243 for code/branches/core4/src/core/Game.cc

Timestamp:

Jun 28, 2009, 6:22:40 PM (15 years ago)

Author:

rgrieder

Message:

Moved GameState construction from pre-main() to after Core creation. That makes it possible to use Core features (like configValues) in the GameState constructor.

File:

• code/branches/core4/src/core/Game.cc (modified) (9 diffs)

code/branches/core4/src/core/Game.cc

@@ -54 +54 @@
     using boost::weak_ptr;
 
-    std::map<std::string, GameState*> Game::allStates_s;
-    Game* Game::singletonRef_s = 0;
-
     static void stop_game()
         { Game::getInstance().stop(); }
     SetConsoleCommandShortcutExternAlias(stop_game, "exit");
-    // Add an empty gamestate that serves as internal root state
-    AddGameState(GameState, "emptyRootGameState");
 
     struct _CoreExport GameStateTreeNode
@@ -69 +64 @@
         std::vector<shared_ptr<GameStateTreeNode> > children_;
     };
+
+    std::map<std::string, Game::GameStateInfo> Game::gameStateDeclarations_s;
+    Game* Game::singletonRef_s = 0;
 
     /**
@@ -76 +74 @@
     Game::Game(int argc, char** argv)
     {
-        assert(singletonRef_s == 0);
+        if (singletonRef_s != 0)
+        {
+            COUT(0) << "Error: The Game singleton cannot be recreated! Shutting down." << std::endl;
+            abort();
+        }
         singletonRef_s = this;
 
         this->bAbort_ = false;
         bChangingState_ = false;
-        // The empty root state is ALWAYS loaded!
-        this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
-        this->rootStateNode_->state_ = getState("emptyRootGameState");
-        this->activeStateNode_ = this->rootStateNode_;
-        this->activeStates_.push_back(this->rootStateNode_->state_);
+
+        // Create an empty root state
+        declareGameState<GameState>("GameState", "emptyRootGameState", true, false);
 
         // reset statistics
@@ -98 +98 @@
         this->gameClock_ = new Clock();
 
+        // Create the Core
         this->core_ = new orxonox::Core();
         this->core_->initialise(argc, argv);
 
+        // After the core has been created, we can safely instantiate the GameStates
+        for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin();
+            it != gameStateDeclarations_s.end(); ++it)
+        {
+            // Only create the states appropriate for the game mode
+            //if (GameMode::showsGraphics || !it->second.bGraphicsMode)
+            GameStateConstrParams params = { it->second.stateName, it->second.bIgnoreTickTime };
+            gameStates_[getLowercase(it->second.stateName)] = GameStateFactory::fabricate(it->second.className, params);
+        }
+
+        // The empty root state is ALWAYS loaded!
+        this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode());
+        this->rootStateNode_->state_ = getState("emptyRootGameState");
+        this->activeStateNode_ = this->rootStateNode_;
+        this->activeStates_.push_back(this->rootStateNode_->state_);
+
+        // Do this after Core creation!
         RegisterRootObject(Game);
         this->setConfigValues();
@@ -110 +128 @@
     Game::~Game()
     {
-        // Destroy pretty much everyhting left
+        // Destroy the GameStates (note that the nodes still point to them, but doesn't matter)
+        for (std::map<std::string, GameState*>::const_iterator it = gameStates_.begin();
+            it != gameStates_.end(); ++it)
+            delete it->second;
+
+        // Destroy the Core and with it almost everything
         delete this->core_;
-
         delete this->gameClock_;
 
-        assert(singletonRef_s);
-        singletonRef_s = 0;
+        // Also, take care of the GameStateFactories
+        GameStateFactory::destroyFactories();
+
+        // Don't assign singletonRef_s with NULL! Recreation is not supported
     }
 
@@ -165 +189 @@
 
             // STATISTICS
-            statisticsTickInfo tickInfo = {currentTime, 0};
+            StatisticsTickInfo tickInfo = {currentTime, 0};
             statisticsTickTimes_.push_back(tickInfo);
             this->periodTime_ += this->gameClock_->getDeltaTimeMicroseconds();
@@ -240 +264 @@
             if (this->periodTime_ > statisticsRefreshCycle_)
             {
-                std::list<statisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
+                std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();
                 assert(it != this->statisticsTickTimes_.end());
                 int64_t lastTime = currentTime - this->statisticsAvgLength_;
@@ -356 +380 @@
     GameState* Game::getState(const std::string& name)
     {
-        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(name));
-        if (it != allStates_s.end())
+        std::map<std::string, GameState*>::const_iterator it = gameStates_.find(getLowercase(name));
+        if (it != gameStates_.end())
             return it->second;
         else
@@ -448 +472 @@
     }
 
-    /*static*/ bool Game::addGameState(GameState* state)
-    {
-        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(state->getName()));
-        if (it == allStates_s.end())
-            allStates_s[getLowercase(state->getName())] = state;
-        else
-            ThrowException(GameState, "Cannot add two GameStates with the same name to 'Game'.");
-
-        // just a required dummy return value
-        return true;
-    }
-
-    /*static*/ void Game::destroyStates()
-    {
-        // Delete all GameStates created by the macros
-        for (std::map<std::string, GameState*>::const_iterator it = allStates_s.begin(); it != allStates_s.end(); ++it)
+    std::map<std::string, Game::GameStateFactory*> Game::GameStateFactory::factories_s;
+
+    /*static*/ GameState* Game::GameStateFactory::fabricate(const std::string& className, const GameStateConstrParams& params)
+    {
+        std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.find(className);
+        assert(it != factories_s.end());
+        return it->second->fabricate(params);
+    }
+
+    /*static*/ void Game::GameStateFactory::destroyFactories()
+    {
+        for (std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.begin(); it != factories_s.end(); ++it)
             delete it->second;
-        allStates_s.clear();
+        factories_s.clear();
     }
 }