Changeset 1661 for code/branches/gui/src

Timestamp:

Aug 18, 2008, 9:17:30 PM (16 years ago)

Author:

rgrieder

Message:

started implementing the GameStates. Not much for now, but most of the Orxonox.cc code has been copied to GSRoot, GSGraphics and GSLevel.
There is no level currently, but the main menu is shown. This is more of an svn save because I would really like to have Member ConsoleCommands.

Location:

code/branches/gui/src

Files:

• core/GameState.cc (modified) (4 diffs)
• core/GameState.h (modified) (3 diffs)
• orxonox/Main.cc (modified) (4 diffs)
• orxonox/Orxonox.cc (modified) (1 diff)
• orxonox/gamestates (added)
• orxonox/gamestates/GSGUI.cc (added)
• orxonox/gamestates/GSGUI.h (added)
• orxonox/gamestates/GSGraphics.cc (added)
• orxonox/gamestates/GSGraphics.h (added)
• orxonox/gamestates/GSLevel.cc (added)
• orxonox/gamestates/GSLevel.h (added)
• orxonox/gamestates/GSRoot.cc (added)
• orxonox/gamestates/GSRoot.h (added)
• orxonox/gui/GUIManager.cc (modified) (3 diffs)
• orxonox/gui/GUIManager.h (modified) (1 diff)

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

@@ -56 +56 @@
     /**
     @brief
+        Destructor only checks that we don't delete an active state.
+    */
+    GameState::~GameState()
+    {
+        if (this->bActive_)
+        {
+            if (this->parent_)
+                this->requestState(this->parent_->getName());
+            else
+                this->requestState("");
+        }
+    }
+
+    /**
+    @brief
         Adds a child to the current tree. The Child can contain children of its own.
         But you cannot a state tree that already has an active state.
@@ -104 +119 @@
         // mark us as parent
         state->parent_ = this;
+    }
+
+    /**
+    @brief
+        Removes a child by instance. This splits the tree in two parts,
+        each of them functional on its own.
+    @param state
+        GameState by instance pointer
+    */
+    void GameState::removeChild(GameState* state)
+    {
+        std::map<GameState*, GameState*>::iterator it = this->grandchildrenToChildren_.find(state);
+        if (it != this->grandchildrenToChildren_.end())
+        {
+            if (state->isActive())
+            {
+                ThrowException(GameState, "Cannot remove active game state child '"
+                    + state->getName() + "' from '" + name_ + "'.");
+                //COUT(2) << "Warning: Cannot remove active game state child '" << state->getName()
+                //    << "' from '" << name_ << "'." << std::endl;
+            }
+            else
+            {
+                for (std::map<GameState*, GameState*>::const_iterator it = state->grandchildrenToChildren_.begin();
+                    it != state->grandchildrenToChildren_.end(); ++it)
+                {
+                    this->grandchildRemoved(it->first);
+                }
+                this->grandchildRemoved(state);
+            }
+        }
+        else
+        {
+            ThrowException(GameState, "Game state '" + name_ + "' doesn't have a child named '"
+                + state->getName() + "'. Removal skipped.");
+            //COUT(2) << "Warning: Game state '" << name_ << "' doesn't have a child named '"
+            //    << state->getName() << "'. Removal skipped." << std::endl;
+        }
+    }
+
+    /**
+    @brief
+        Removes a child by name. This splits the tree in two parts,
+        each of them functional on its own.
+    @param state
+        GameState by name
+    */
+
+    void GameState::removeChild(const std::string& name)
+    {
+        GameState* state = checkState(name);
+        if (state)
+        {
+            removeChild(state);
+        }
+        else
+        {
+            ThrowException(GameState, "GameState '" + name + "' doesn't exist.");
+            //COUT(2) << "Warning: GameState '" << name << "' doesn't exist." << std::endl;
+        }
     }
 
@@ -126 +201 @@
     /**
     @brief
+        Tells a state that one of its children has removed a child. This is necessary
+        to fill the internal maps correctly.
+    @param child
+        The child who notices this state.
+    @param grandchild
+        The child that has been removed.
+    */
+    void GameState::grandchildRemoved(GameState* grandchild)
+    {
+        // adjust the two maps correctly.
+        this->allChildren_.erase(grandchild->getName());
+        this->grandchildrenToChildren_.erase(grandchild);
+        if (this->parent_)
+            this->parent_->grandchildRemoved(grandchild);
+    }
+
+    /**
+    @brief
         Checks whether a specific game states exists in the hierarchy.
     @remarks
@@ -191 +284 @@
     void GameState::requestState(const std::string& name)
     {
-        GameState* request = checkState(name);
-        GameState* current = getCurrentState();
-        if (request)
-        {
+        if (name == "")
+        {
+            // user would like to leave every state.
+            GameState* current = getCurrentState();
             if (current)
             {
-                // There is already an active state
-                current->makeTransition(request);
-            }
-            else
-            {
-                // no active state --> we have to activate the root node first.
+                // Deactivate all states but root
                 GameState* root = getRootNode();
-                root->activate();
-                root->makeTransition(request);
-            }
-        }
-        else
-        {
-            COUT(2) << "Warning: GameState '" << name << "' doesn't exist." << std::endl;
+                current->makeTransition(root);
+                // Kick root too
+                root->deactivate();
+            }
+        }
+        else
+        {
+            GameState* request = checkState(name);
+            GameState* current = getCurrentState();
+            if (request)
+            {
+                if (current)
+                {
+                    // There is already an active state
+                    current->makeTransition(request);
+                }
+                else
+                {
+                    // no active state --> we have to activate the root node first.
+                    GameState* root = getRootNode();
+                    root->activate();
+                    root->makeTransition(request);
+                }
+            }
+            else
+            {
+                COUT(2) << "Warning: GameState '" << name << "' doesn't exist." << std::endl;
+            }
         }
     }

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

@@ -62 +62 @@
     public:
         GameState(const std::string& name);
-        virtual ~GameState() { }
+        virtual ~GameState();
 
         const std::string& getName() const { return name_; }
 
         void addChild(GameState* state);
+        void removeChild(GameState* state);
+        void removeChild(const std::string& name);
         void requestState(const std::string& name);
 
@@ -76 +78 @@
         bool isCurrentState() { return this->bActive_ && !this->activeChild_; }
 
+        virtual bool tick(float dt) { return true; }
+
     protected:
+        //virtual void enter() = 0;
+        //virtual void leave() = 0;
+        //virtual void tick(float dt) = 0;
         virtual void enter() { }
         virtual void leave() { }
-        virtual void tick(float dt) { }
+
+        GameState* getActiveChild() { return this->activeChild_; }
 
     private:
@@ -86 +94 @@
         GameState* getRootNode();
         void grandchildAdded(GameState* child, GameState* grandchild);
+        void grandchildRemoved(GameState* grandchild);
         void makeTransition(GameState* state);
         void activate();

code/branches/gui/src/orxonox/Main.cc

@@ -45 +45 @@
 #include "Settings.h"
 #include "Orxonox.h"
+
+#include "gamestates/GSRoot.h"
+#include "gamestates/GSGraphics.h"
+#include "gamestates/GSLevel.h"
+#include "gamestates/GSGUI.h"
 
 using namespace orxonox;
@@ -140 +145 @@
     state2->addChild(state3);
     state2->addChild(state5);
-    state3->addChild(state1);
     state6->addChild(state2);
+
+    state6->removeChild("state2");
 
     state5->requestState("state3");
@@ -160 +166 @@
     COUT(2) << std::endl;*/
 
+
+    GSRoot root;
+    GSGraphics graphics;
+    GSLevel level;
+    GSGUI gui;
+
+    root.addChild(&graphics);
+    graphics.addChild(&level);
+    graphics.addChild(&gui);
+
+    root.requestState("gui");
+    root.tick(0.0f);
+    root.requestState("");
 
 
@@ -169 +188 @@
         orxonoxInstance.start(macBundlePath());
 #else
-        orxonoxInstance.start();
+        //orxonoxInstance.start();
 #endif
     }

code/branches/gui/src/orxonox/Orxonox.cc

@@ -43 +43 @@
 //****** OGRE ******
 #include <OgreFrameListener.h>
-#include <OgreOverlay.h>
-#include <OgreOverlayManager.h>
 #include <OgreRoot.h>
 #include <OgreTimer.h>

code/branches/gui/src/orxonox/gui/GUIManager.cc

@@ -84 +84 @@
 
         if (backgroundSceneManager_)
+        {
+            // We have to make sure the SceneManager is not anymore referenced.
+            // For the case that the target SceneManager was yet another one, it
+            // wouldn't matter anyway since this is the destructor.
+            guiRenderer_->setTargetSceneManager(0);
             Ogre::Root::getSingleton().destroySceneManager(backgroundSceneManager_);
+        }
 
         InputManager::getInstance().destroyState("gui");
@@ -218 +224 @@
         {
             if (state_ == OnDisplay)
-                _hideGUI();
+                hideGUI();
 
             COUT(3) << "Loading GUI " << name << std::endl;
@@ -264 +270 @@
     }
 
-    void GUIManager::_hideGUI()
+    void GUIManager::hideGUI()
     {
         if (this->state_ != OnDisplay)

code/branches/gui/src/orxonox/gui/GUIManager.h

@@ -71 +71 @@
         }
         void showGUI(const std::string& name, Ogre::SceneManager* sceneManager);// bool showBackground); // tolua_export
-        void _hideGUI(); // tolua_export
+        void hideGUI(); // tolua_export
 
         Ogre::Camera* getCamera() { return this->backgroundCamera_; }