Changeset 1689 for code/branches/gui/src/core

Timestamp:

Aug 31, 2008, 6:07:57 PM (16 years ago)

Author:

rgrieder

Message:

• renamed:

GameState —> GameStateBase
GameStateTyped<T> —> GameState

• moved command line parsing from GSRoot to RootGameState.

Location:

code/branches/gui/src/core

Files:

• CorePrereqs.h (modified) (1 diff)
• GameState.cc (modified) (21 diffs)
• GameState.h (modified) (5 diffs)
• RootGameState.cc (modified) (6 diffs)
• RootGameState.h (modified) (2 diffs)

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

@@ -162 +162 @@
 
   // game states
+  class GameStateBase;
+  template <class ParentType>
   class GameState;
-  template <class ParentType>
-  class GameStateTyped;
   class RootGameState;
 

code/branches/gui/src/core/GameState.cc

@@ -30 +30 @@
 @file
 @brief
-    Implementation of GameState class.
+    Implementation of GameStateBase class.
 */
 
@@ -43 +43 @@
         Constructor only initialises variables and sets the name permanently.
     */
-    GameState::GameState(const std::string& name)
+    GameStateBase::GameStateBase(const std::string& name)
         : name_(name)
         //, parent_(0)
@@ -57 +57 @@
         Destructor only checks that we don't delete an active state.
     */
-    GameState::~GameState()
+    GameStateBase::~GameStateBase()
     {
         OrxAssert(!isInSubtree(getCurrentState()), "Deleting an active GameState is a very bad idea..");
@@ -69 +69 @@
         The state to be added.
     */
-    void GameState::addChild(GameState* state)
+    void GameStateBase::addChild(GameStateBase* state)
     {
         if (!state)
             return;
         // check if the state/tree to be added has states in it that already exist in this tree.
-        for (std::map<std::string, GameState*>::const_iterator it = state->allChildren_.begin();
+        for (std::map<std::string, GameStateBase*>::const_iterator it = state->allChildren_.begin();
             it != state->allChildren_.end(); ++it)
         {
@@ -96 +96 @@
 
         // merge the child's children into this tree
-        for (std::map<std::string, GameState*>::const_iterator it = state->allChildren_.begin();
+        for (std::map<std::string, GameStateBase*>::const_iterator it = state->allChildren_.begin();
             it != state->allChildren_.end(); ++it)
             this->grandchildAdded(state, it->second);
@@ -113 +113 @@
         GameState by instance pointer
     */
-    void GameState::removeChild(GameState* state)
-    {
-        std::map<GameState*, GameState*>::iterator it = this->grandchildrenToChildren_.find(state);
+    void GameStateBase::removeChild(GameStateBase* state)
+    {
+        std::map<GameStateBase*, GameStateBase*>::iterator it = this->grandchildrenToChildren_.find(state);
         if (it != this->grandchildrenToChildren_.end())
         {
@@ -127 +127 @@
             else
             {
-                for (std::map<GameState*, GameState*>::const_iterator it = state->grandchildrenToChildren_.begin();
+                for (std::map<GameStateBase*, GameStateBase*>::const_iterator it = state->grandchildrenToChildren_.begin();
                     it != state->grandchildrenToChildren_.end(); ++it)
                     this->grandchildRemoved(it->first);
@@ -150 +150 @@
     */
 
-    void GameState::removeChild(const std::string& name)
-    {
-        GameState* state = getState(name);
+    void GameStateBase::removeChild(const std::string& name)
+    {
+        GameStateBase* state = getState(name);
         if (state)
         {
@@ -173 +173 @@
         The child that has been added.
     */
-    inline void GameState::grandchildAdded(GameState* child, GameState* grandchild)
+    inline void GameStateBase::grandchildAdded(GameStateBase* child, GameStateBase* grandchild)
     {
         // fill the two maps correctly.
@@ -191 +191 @@
         The child that has been removed.
     */
-    inline void GameState::grandchildRemoved(GameState* grandchild)
+    inline void GameStateBase::grandchildRemoved(GameStateBase* grandchild)
     {
         // adjust the two maps correctly.
@@ -206 +206 @@
         Remember that the every node has a map with all its child nodes.
     */
-    GameState* GameState::getState(const std::string& name)
+    GameStateBase* GameStateBase::getState(const std::string& name)
     {
         if (this->getParent())
@@ -216 +216 @@
                 return this;
             // Search in the map. If there is no entry, we can be sure the state doesn't exist.
-            std::map<std::string, GameState*>::const_iterator it = this->allChildren_.find(name);
+            std::map<std::string, GameStateBase*>::const_iterator it = this->allChildren_.find(name);
             return (it!= this->allChildren_.end() ? it->second : 0);
         }
@@ -225 +225 @@
         Returns the root node of the tree.
     */
-    GameState* GameState::getRoot()
+    GameStateBase* GameStateBase::getRoot()
     {
         if (this->getParent())
@@ -240 +240 @@
         have active children itself. Many states can be active at once.
     */
-    GameState* GameState::getCurrentState()
+    GameStateBase* GameStateBase::getCurrentState()
     {
         if (this->operation_.active)
@@ -262 +262 @@
         Determines whether 'state' is in this subtree, including this node.
     */
-    bool GameState::isInSubtree(GameState* state) const
+    bool GameStateBase::isInSubtree(GameStateBase* state) const
     {
         return (grandchildrenToChildren_.find(state) != grandchildrenToChildren_.end()
@@ -275 +275 @@
         The state to be entered, has to exist in the tree.
     */
-    void GameState::requestState(const std::string& name)
+    void GameStateBase::requestState(const std::string& name)
     {
         assert(getRoot());
@@ -286 +286 @@
         the method can assume certain things to be granted (like 'this' is always active).
     */
-    void GameState::makeTransition(GameState* source, GameState* destination)
+    void GameStateBase::makeTransition(GameStateBase* source, GameStateBase* destination)
     {
         if (source == this->getParent())
@@ -308 +308 @@
 
         // Check for 'destination' in the children map first
-        std::map<GameState*, GameState*>::const_iterator it
+        std::map<GameStateBase*, GameStateBase*>::const_iterator it
             = this->grandchildrenToChildren_.find(destination);
         if (it != this->grandchildrenToChildren_.end())
@@ -330 +330 @@
         Activates the state. Only sets bActive_ to true and notifies the parent.
     */
-    void GameState::activate()
+    void GameStateBase::activate()
     {
         this->operation_.active = true;
@@ -341 +341 @@
         Activates the state. Only sets bActive_ to false and notifies the parent.
     */
-    void GameState::deactivate()
+    void GameStateBase::deactivate()
     {
         this->operation_.leaving = true;
@@ -358 +358 @@
         This method is not virtual! You cannot override it therefore.
     */
-    void GameState::tick(const Clock& time)
+    void GameStateBase::tick(const Clock& time)
     {
         this->operation_.running = true;

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

@@ -61 +61 @@
         Then Bar stores Foo in map by its name. The other one then maps Foo to Foofoo.
     */
-    class _CoreExport GameState
+    class _CoreExport GameStateBase
     {
         friend class RootGameState;
         template <class ParentType>
-        friend class GameStateTyped;
+        friend class GameState;
 
     public:
@@ -82 +82 @@
 
     public:
-        virtual ~GameState();
+        virtual ~GameStateBase();
 
         const std::string& getName() const { return name_; }
         const Operations getOperation() const { return this->operation_; }
-        bool isInSubtree(GameState* state) const;
+        bool isInSubtree(GameStateBase* state) const;
 
-        GameState* getState(const std::string& name);
-        GameState* getRoot();
+        GameStateBase* getState(const std::string& name);
+        GameStateBase* getRoot();
         //! Returns the currently active game state
-        virtual GameState* getCurrentState();
+        virtual GameStateBase* getCurrentState();
 
         virtual void requestState(const std::string& name);
 
-        void addChild(GameState* state);
-        void removeChild(GameState* state);
+        void addChild(GameStateBase* state);
+        void removeChild(GameStateBase* state);
         void removeChild(const std::string& name);
 
@@ -104 +104 @@
         virtual void ticked(const Clock& time) = 0;
 
-        GameState* getActiveChild() { return this->activeChild_; }
+        GameStateBase* getActiveChild() { return this->activeChild_; }
 
         void tickChild(const Clock& time) { if (this->getActiveChild()) this->getActiveChild()->tick(time); }
 
-        virtual GameState* getParent() const = 0;
-        virtual void setParent(GameState* state) = 0;
+        virtual GameStateBase* getParent() const = 0;
+        virtual void setParent(GameStateBase* state) = 0;
 
     private:
         // Making the constructor private ensures that game states
-        // are always derivates of GameStateTyped<T>. Note the friend declaration above.
-        GameState(const std::string& name);
+        // are always derivates of GameState<T>. Note the friend declaration above.
+        GameStateBase(const std::string& name);
 
         //! Performs a transition to 'destination'
-        virtual void makeTransition(GameState* source, GameState* destination);
+        virtual void makeTransition(GameStateBase* source, GameStateBase* destination);
 
-        void grandchildAdded(GameState* child, GameState* grandchild);
-        void grandchildRemoved(GameState* grandchild);
+        void grandchildAdded(GameStateBase* child, GameStateBase* grandchild);
+        void grandchildRemoved(GameStateBase* grandchild);
 
         void tick(const Clock& time);
@@ -126 +126 @@
         void deactivate();
 
-        const std::string                   name_;
-        Operations                          operation_;
-        GameState*                          activeChild_;
-        //bool                                bPauseParent_;
-        std::map<std::string, GameState*>   allChildren_;
-        std::map<GameState*, GameState*>    grandchildrenToChildren_;
+        const std::string                        name_;
+        Operations                               operation_;
+        GameStateBase*                           activeChild_;
+        //bool                                     bPauseParent_;
+        std::map<std::string, GameStateBase*>    allChildren_;
+        std::map<GameStateBase*, GameStateBase*> grandchildrenToChildren_;
     };
 
+
     template <class ParentType>
-    class GameStateTyped : public GameState
+    class GameState : public GameStateBase
     {
     public:
-        GameStateTyped(const std::string& name) : GameState(name) { }
-        virtual ~GameStateTyped() { }
+        GameState(const std::string& name) : GameStateBase(name) { }
+        virtual ~GameState() { }
 
         ParentType* getParent() const
@@ -145 +146 @@
 
     protected:
-        void setParent(GameState* state)
+        void setParent(GameStateBase* state)
         {
             assert(dynamic_cast<ParentType*>(state) != 0);

code/branches/gui/src/core/RootGameState.cc

@@ -39 +39 @@
 
     RootGameState::RootGameState(const std::string& name)
-        : GameStateTyped<GameState>(name)
+        : GameState<GameStateBase>(name)
         , stateRequest_("")
     {
@@ -53 +53 @@
         the method can assume certain things to be granted (like 'this' is always active).
     */
-    void RootGameState::makeTransition(GameState* source, GameState* destination)
+    void RootGameState::makeTransition(GameStateBase* source, GameStateBase* destination)
     {
         if (source != 0)
@@ -68 +68 @@
 
         // Check for 'destination' in the children map first
-        std::map<GameState*, GameState*>::const_iterator it
+        std::map<GameStateBase*, GameStateBase*>::const_iterator it
             = this->grandchildrenToChildren_.find(destination);
         if (it != this->grandchildrenToChildren_.end())
         {
-            OrxAssert(dynamic_cast<GameState*>(it->second) != 0,
+            OrxAssert(dynamic_cast<GameStateBase*>(it->second) != 0,
                 "There was a mix with RootGameState and GameState, could not cast.");
-            GameState* child = static_cast<GameState*>(it->second);
+            GameStateBase* child = static_cast<GameStateBase*>(it->second);
             // child state. Don't use 'state', might be a grandchild!
             this->activeChild_ = child;
@@ -88 +88 @@
     void RootGameState::gotoState(const std::string& name)
     {
-        GameState* request = getState(name);
+        GameStateBase* request = getState(name);
         if (request)
         {
-            GameState* current = getCurrentState();
+            GameStateBase* current = getCurrentState();
             if (current)
             {
@@ -127 +127 @@
         State to start with (usually main menu or specified by command line)
     */
-    void RootGameState::start()
+    void RootGameState::start(int argc, char** argv)
     {
+        parseCommandLine(argc, argv);
+
         this->activate();
 
@@ -149 +151 @@
         this->deactivate();
     }
+
+    void RootGameState::parseCommandLine(int argc, char** argv)
+    {
+        std::vector<std::string> args;
+        for (int i = 1; i < argc; ++i)
+            args.push_back(argv[i]);
+
+        try
+        {
+            orxonox::CommandLine::parse(args);
+        }
+        catch (orxonox::ArgumentException& ex)
+        {
+            COUT(1) << ex.what() << std::endl;
+            COUT(0) << "Usage:" << std::endl << "orxonox " << CommandLine::getUsageInformation() << std::endl;
+        }
+    }
 }

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

@@ -35 +35 @@
 namespace orxonox
 {
-    class _CoreExport RootGameState : public GameStateTyped<GameState>
+    class _CoreExport RootGameState : public GameState<GameStateBase>
     {
     public:
@@ -42 +42 @@
 
         void requestState(const std::string& name);
-        void start();
+        void start(int argc, char** argv);
 
     private:
-        void makeTransition(GameState* source, GameState* destination);
+        void makeTransition(GameStateBase* source, GameStateBase* destination);
         void gotoState(const std::string& name);
+
+        void parseCommandLine(int argc, char** argv);
 
         std::string           stateRequest_;