Changeset 3243 for code/branches/core4/src/core
- Timestamp:
- Jun 28, 2009, 6:22:40 PM (16 years ago)
- Location:
- code/branches/core4/src/core
- Files:
-
- 5 edited
Legend:
- Unmodified
- Added
- Removed
-
code/branches/core4/src/core/CorePrereqs.h
r3196 r3243 165 165 // game states 166 166 class Game; 167 struct GameStateConstrParams; 167 168 class GameState; 168 169 struct GameStateTreeNode; -
code/branches/core4/src/core/Game.cc
r3238 r3243 54 54 using boost::weak_ptr; 55 55 56 std::map<std::string, GameState*> Game::allStates_s;57 Game* Game::singletonRef_s = 0;58 59 56 static void stop_game() 60 57 { Game::getInstance().stop(); } 61 58 SetConsoleCommandShortcutExternAlias(stop_game, "exit"); 62 // Add an empty gamestate that serves as internal root state63 AddGameState(GameState, "emptyRootGameState");64 59 65 60 struct _CoreExport GameStateTreeNode … … 69 64 std::vector<shared_ptr<GameStateTreeNode> > children_; 70 65 }; 66 67 std::map<std::string, Game::GameStateInfo> Game::gameStateDeclarations_s; 68 Game* Game::singletonRef_s = 0; 71 69 72 70 /** … … 76 74 Game::Game(int argc, char** argv) 77 75 { 78 assert(singletonRef_s == 0); 76 if (singletonRef_s != 0) 77 { 78 COUT(0) << "Error: The Game singleton cannot be recreated! Shutting down." << std::endl; 79 abort(); 80 } 79 81 singletonRef_s = this; 80 82 81 83 this->bAbort_ = false; 82 84 bChangingState_ = false; 83 // The empty root state is ALWAYS loaded! 84 this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode()); 85 this->rootStateNode_->state_ = getState("emptyRootGameState"); 86 this->activeStateNode_ = this->rootStateNode_; 87 this->activeStates_.push_back(this->rootStateNode_->state_); 85 86 // Create an empty root state 87 declareGameState<GameState>("GameState", "emptyRootGameState", true, false); 88 88 89 89 // reset statistics … … 98 98 this->gameClock_ = new Clock(); 99 99 100 // Create the Core 100 101 this->core_ = new orxonox::Core(); 101 102 this->core_->initialise(argc, argv); 102 103 104 // After the core has been created, we can safely instantiate the GameStates 105 for (std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.begin(); 106 it != gameStateDeclarations_s.end(); ++it) 107 { 108 // Only create the states appropriate for the game mode 109 //if (GameMode::showsGraphics || !it->second.bGraphicsMode) 110 GameStateConstrParams params = { it->second.stateName, it->second.bIgnoreTickTime }; 111 gameStates_[getLowercase(it->second.stateName)] = GameStateFactory::fabricate(it->second.className, params); 112 } 113 114 // The empty root state is ALWAYS loaded! 115 this->rootStateNode_ = shared_ptr<GameStateTreeNode>(new GameStateTreeNode()); 116 this->rootStateNode_->state_ = getState("emptyRootGameState"); 117 this->activeStateNode_ = this->rootStateNode_; 118 this->activeStates_.push_back(this->rootStateNode_->state_); 119 120 // Do this after Core creation! 103 121 RegisterRootObject(Game); 104 122 this->setConfigValues(); … … 110 128 Game::~Game() 111 129 { 112 // Destroy pretty much everyhting left 130 // Destroy the GameStates (note that the nodes still point to them, but doesn't matter) 131 for (std::map<std::string, GameState*>::const_iterator it = gameStates_.begin(); 132 it != gameStates_.end(); ++it) 133 delete it->second; 134 135 // Destroy the Core and with it almost everything 113 136 delete this->core_; 114 115 137 delete this->gameClock_; 116 138 117 assert(singletonRef_s); 118 singletonRef_s = 0; 139 // Also, take care of the GameStateFactories 140 GameStateFactory::destroyFactories(); 141 142 // Don't assign singletonRef_s with NULL! Recreation is not supported 119 143 } 120 144 … … 165 189 166 190 // STATISTICS 167 statisticsTickInfo tickInfo = {currentTime, 0};191 StatisticsTickInfo tickInfo = {currentTime, 0}; 168 192 statisticsTickTimes_.push_back(tickInfo); 169 193 this->periodTime_ += this->gameClock_->getDeltaTimeMicroseconds(); … … 240 264 if (this->periodTime_ > statisticsRefreshCycle_) 241 265 { 242 std::list< statisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin();266 std::list<StatisticsTickInfo>::iterator it = this->statisticsTickTimes_.begin(); 243 267 assert(it != this->statisticsTickTimes_.end()); 244 268 int64_t lastTime = currentTime - this->statisticsAvgLength_; … … 356 380 GameState* Game::getState(const std::string& name) 357 381 { 358 std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(name));359 if (it != allStates_s.end())382 std::map<std::string, GameState*>::const_iterator it = gameStates_.find(getLowercase(name)); 383 if (it != gameStates_.end()) 360 384 return it->second; 361 385 else … … 448 472 } 449 473 450 /*static*/ bool Game::addGameState(GameState* state) 451 { 452 std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(state->getName())); 453 if (it == allStates_s.end()) 454 allStates_s[getLowercase(state->getName())] = state; 455 else 456 ThrowException(GameState, "Cannot add two GameStates with the same name to 'Game'."); 457 458 // just a required dummy return value 459 return true; 460 } 461 462 /*static*/ void Game::destroyStates() 463 { 464 // Delete all GameStates created by the macros 465 for (std::map<std::string, GameState*>::const_iterator it = allStates_s.begin(); it != allStates_s.end(); ++it) 474 std::map<std::string, Game::GameStateFactory*> Game::GameStateFactory::factories_s; 475 476 /*static*/ GameState* Game::GameStateFactory::fabricate(const std::string& className, const GameStateConstrParams& params) 477 { 478 std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.find(className); 479 assert(it != factories_s.end()); 480 return it->second->fabricate(params); 481 } 482 483 /*static*/ void Game::GameStateFactory::destroyFactories() 484 { 485 for (std::map<std::string, GameStateFactory*>::const_iterator it = factories_s.begin(); it != factories_s.end(); ++it) 466 486 delete it->second; 467 allStates_s.clear();487 factories_s.clear(); 468 488 } 469 489 } -
code/branches/core4/src/core/Game.h
r3238 r3243 46 46 #include <boost/preprocessor/cat.hpp> 47 47 48 #include "util/Debug.h" 48 49 #include "OrxonoxClass.h" 49 50 … … 53 54 and every following paramter is a constructor argument (which is usually non existent) 54 55 */ 55 #define AddGameState(classname, ...) \56 static bool BOOST_PP_CAT(bGameStateDummy_##class name, __LINE__) = orxonox::Game::addGameState(new classname(__VA_ARGS__))56 #define DeclareGameState(className, stateName, bIgnoreTickTime, bGraphicsMode) \ 57 static bool BOOST_PP_CAT(bGameStateDummy_##className, __LINE__) = orxonox::Game::declareGameState<className>(#className, stateName, bIgnoreTickTime, bGraphicsMode) 57 58 58 59 // tolua_begin … … 91 92 void addTickTime(uint32_t length); 92 93 93 static bool addGameState(GameState* state);94 static void destroyStates();94 template <class T> 95 static bool declareGameState(const std::string& className, const std::string& stateName, bool bIgnoreTickTime, bool bConsoleMode); 95 96 static Game& getInstance() { assert(singletonRef_s); return *singletonRef_s; } //tolua_export 96 97 … … 99 100 100 101 private: 101 struct statisticsTickInfo 102 class _CoreExport GameStateFactory 103 { 104 public: 105 virtual ~GameStateFactory() { } 106 static GameState* fabricate(const std::string& className, const GameStateConstrParams& params); 107 template <class T> 108 static void createFactory(const std::string& className) 109 { factories_s[className] = new TemplateGameStateFactory<T>(); } 110 static void destroyFactories(); 111 private: 112 virtual GameState* fabricate(const GameStateConstrParams& params) = 0; 113 static std::map<std::string, GameStateFactory*> factories_s; 114 }; 115 template <class T> 116 class TemplateGameStateFactory : public GameStateFactory 117 { 118 public: 119 GameState* fabricate(const GameStateConstrParams& params) 120 { return new T(params); } 121 }; 122 123 struct GameStateInfo 124 { 125 std::string stateName; 126 std::string className; 127 bool bIgnoreTickTime; 128 bool bGraphicsMode; 129 }; 130 131 struct StatisticsTickInfo 102 132 { 103 133 uint64_t tickTime; … … 110 140 void unloadState(GameState* state); 111 141 112 std::vector<GameState*> activeStates_; 142 std::map<std::string, GameState*> gameStates_; 143 std::vector<GameState*> activeStates_; 113 144 boost::shared_ptr<GameStateTreeNode> rootStateNode_; 114 145 boost::shared_ptr<GameStateTreeNode> activeStateNode_; … … 123 154 // variables for time statistics 124 155 uint64_t statisticsStartTime_; 125 std::list< statisticsTickInfo> statisticsTickTimes_;156 std::list<StatisticsTickInfo> statisticsTickTimes_; 126 157 uint32_t periodTime_; 127 158 uint32_t periodTickTime_; … … 134 165 std::string levelName_; 135 166 136 static std::map<std::string, GameState *> allStates_s;167 static std::map<std::string, GameStateInfo> gameStateDeclarations_s; 137 168 static Game* singletonRef_s; //!< Pointer to the Singleton 138 // tolua_begin 139 }; 140 } 141 //tolua_end 169 }; // tolua_export 170 171 template <class T> 172 /*static*/ bool Game::declareGameState(const std::string& className, const std::string& stateName, bool bIgnoreTickTime, bool bGraphicsMode) 173 { 174 std::map<std::string, GameStateInfo>::const_iterator it = gameStateDeclarations_s.find(getLowercase(stateName)); 175 if (it == gameStateDeclarations_s.end()) 176 { 177 GameStateInfo& info = gameStateDeclarations_s[getLowercase(stateName)]; 178 info.stateName = stateName; 179 info.className = className; 180 info.bIgnoreTickTime = bIgnoreTickTime; 181 info.bGraphicsMode = bGraphicsMode; 182 } 183 else 184 { 185 COUT(0) << "Error: Cannot declare two GameStates with the same name." << std::endl; 186 COUT(0) << " Ignoring second one ('" << stateName << "')." << std::endl; 187 } 188 189 // Create a factory to delay GameState creation 190 GameStateFactory::createFactory<T>(className); 191 192 // just a required dummy return value 193 return true; 194 } 195 } // tolua_export 196 142 197 #endif /* _Game_H__ */ -
code/branches/core4/src/core/GameState.cc
r3238 r3243 45 45 Constructor only initialises variables and sets the name permanently. 46 46 */ 47 GameState::GameState(const std::string& name, bool ignoreTickTime)48 : name_( name)49 , bIgnoreTickTime_( ignoreTickTime)47 GameState::GameState(const GameStateConstrParams& params) 48 : name_(params.name) 49 , bIgnoreTickTime_(params.bIgnoreTickTime) 50 50 , parent_(0) 51 51 { -
code/branches/core4/src/core/GameState.h
r3238 r3243 45 45 /** 46 46 @brief 47 Helper class to group construction parameters for better genericity. 48 */ 49 struct GameStateConstrParams 50 { 51 std::string name; 52 bool bIgnoreTickTime; 53 }; 54 55 /** 56 @brief 47 57 An implementation of a tree to manage game states. 48 58 This leads to a certain hierarchy that is created at runtime. … … 77 87 78 88 public: 79 GameState(const std::string& name, bool ignoreTicktime = false);89 GameState(const GameStateConstrParams& params); 80 90 virtual ~GameState(); 81 91
Note: See TracChangeset
for help on using the changeset viewer.