Index: code/branches/objecthierarchy/src/orxonox/CMakeLists.txt
===================================================================
--- code/branches/objecthierarchy/src/orxonox/CMakeLists.txt	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/CMakeLists.txt	(revision 1940)
@@ -42,4 +42,6 @@
   tools/WindowEventListener.cc
 
+  objects/worldentities/WorldEntity.cc
+  objects/worldentities/PositionableEntity.cc
 #  objects/Backlight.cc
   objects/Camera.cc
@@ -50,4 +52,10 @@
   objects/RadarViewable.cc
   objects/Tickable.cc
+
+  objects/infos/Info.cc
+  objects/infos/LevelInfo.cc
+  objects/infos/PlayerInfo.cc
+
+  objects/gametypes/Gametype.cc
 
   tolua/tolua_bind.cc
Index: code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h	(revision 1940)
@@ -81,7 +81,18 @@
 
     // objects
+    class WorldEntity;
+    class PositionableEntity;
+    class MovableEntity;
+    class ControllableEntity;
+
     class Backlight;
     class Camera;
     class ParticleSpawner;
+
+    class Info;
+    class LevelInfo;
+    class PlayerInfo;
+
+    class Gametype;
 
     // tools
Index: code/branches/objecthierarchy/src/orxonox/Settings.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/Settings.cc	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/Settings.cc	(revision 1940)
@@ -52,4 +52,6 @@
         , bHasServer_(false)
         , bIsClient_(false)
+        , bIsStandalone_(false)
+        , bIsMaster_(false)
     {
         RegisterRootObject(Settings);
Index: code/branches/objecthierarchy/src/orxonox/Settings.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/Settings.h	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/Settings.h	(revision 1940)
@@ -54,4 +54,5 @@
         friend class GSClient;
         friend class GSDedicated;
+        friend class GSStandalone;
 
     public:
@@ -65,10 +66,14 @@
         static bool hasServer()     { assert(singletonRef_s); return singletonRef_s->bHasServer_; }
         static bool isClient()      { assert(singletonRef_s); return singletonRef_s->bIsClient_; }
+        static bool isStandalone()  { assert(singletonRef_s); return singletonRef_s->bIsStandalone_; }
+        static bool isMaster()      { assert(singletonRef_s); return singletonRef_s->bIsMaster_; }
 
     private:
         // GSRoot has access to these
-        static void setShowsGraphics(bool val) { assert(singletonRef_s); singletonRef_s->bShowsGraphics_ = val; }
-        static void setHasServer    (bool val) { assert(singletonRef_s); singletonRef_s->bHasServer_     = val; }
-        static void setIsClient     (bool val) { assert(singletonRef_s); singletonRef_s->bIsClient_      = val; }
+        static void setShowsGraphics(bool val) { assert(singletonRef_s); singletonRef_s->bShowsGraphics_ = val; singletonRef_s->updateIsMaster(); }
+        static void setHasServer    (bool val) { assert(singletonRef_s); singletonRef_s->bHasServer_     = val; singletonRef_s->updateIsMaster(); }
+        static void setIsClient     (bool val) { assert(singletonRef_s); singletonRef_s->bIsClient_      = val; singletonRef_s->updateIsMaster(); }
+        static void setIsStandalone (bool val) { assert(singletonRef_s); singletonRef_s->bIsStandalone_  = val; singletonRef_s->updateIsMaster(); }
+        static void updateIsMaster  ()         { assert(singletonRef_s); singletonRef_s->bIsMaster_ = (singletonRef_s->bHasServer_ || singletonRef_s->bIsStandalone_); }
 
         Settings();
@@ -85,4 +90,6 @@
         bool bHasServer_;                                      //!< global variable that tells whether this is a server
         bool bIsClient_;
+        bool bIsStandalone_;
+        bool bIsMaster_;
 
         std::string dataPath_;                                 //!< Path to the game data
Index: code/branches/objecthierarchy/src/orxonox/gamestates/GSClient.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/gamestates/GSClient.cc	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/gamestates/GSClient.cc	(revision 1940)
@@ -51,5 +51,5 @@
     void GSClient::enter()
     {
-        Settings::_getInstance().bIsClient_ = true;
+        Settings::_getInstance().setIsClient(true);
 
         GSLevel::enter();
@@ -81,5 +81,5 @@
         GSLevel::leave();
 
-        Settings::_getInstance().bIsClient_ = false;
+        Settings::_getInstance().setIsClient(false);
     }
 
Index: code/branches/objecthierarchy/src/orxonox/gamestates/GSDedicated.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/gamestates/GSDedicated.cc	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/gamestates/GSDedicated.cc	(revision 1940)
@@ -57,5 +57,5 @@
     void GSDedicated::enter()
     {
-        Settings::_getInstance().bHasServer_ = true;
+        Settings::_getInstance().setHasServer(true);
 
         // create Ogre SceneManager for the level
@@ -97,5 +97,5 @@
         Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
 
-        Settings::_getInstance().bHasServer_ = false;
+        Settings::_getInstance().setHasServer(false);
     }
 
Index: code/branches/objecthierarchy/src/orxonox/gamestates/GSGraphics.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/gamestates/GSGraphics.cc	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/gamestates/GSGraphics.cc	(revision 1940)
@@ -101,5 +101,5 @@
     void GSGraphics::enter()
     {
-        Settings::_getInstance().bShowsGraphics_ = true;
+        Settings::_getInstance().setShowsGraphics(true);
 
         // initialise graphics engine. Doesn't load the render window yet!
@@ -196,5 +196,5 @@
         delete graphicsEngine_;
 
-        Settings::_getInstance().bShowsGraphics_ = false;
+        Settings::_getInstance().setShowsGraphics(false);
     }
 
@@ -221,5 +221,5 @@
         this->console_->tick(dt);
         this->tickChild(time);
-        
+
         unsigned long long timeAfterTick = time.getRealMicroseconds();
 
Index: code/branches/objecthierarchy/src/orxonox/gamestates/GSServer.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/gamestates/GSServer.cc	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/gamestates/GSServer.cc	(revision 1940)
@@ -52,5 +52,5 @@
     void GSServer::enter()
     {
-        Settings::_getInstance().bHasServer_ = true;
+        Settings::_getInstance().setHasServer(true);
 
         GSLevel::enter();
@@ -85,6 +85,6 @@
 
         GSLevel::leave();
-	
-        Settings::_getInstance().bHasServer_ = false;
+
+        Settings::_getInstance().setHasServer(false);
     }
 
Index: code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc	(revision 1916)
+++ code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc	(revision 1940)
@@ -32,4 +32,5 @@
 #include "core/input/InputManager.h"
 #include "core/ConsoleCommand.h"
+#include "Settings.h"
 
 namespace orxonox
@@ -57,4 +58,6 @@
         // level is loaded: we can start capturing the input
         InputManager::getInstance().requestEnterState("game");
+
+        Settings::_getInstance().setIsStandalone(true);
     }
 
@@ -68,4 +71,6 @@
 
         GSLevel::leave();
+
+        Settings::_getInstance().setIsStandalone(false);
     }
 
Index: code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc	(revision 1940)
@@ -0,0 +1,89 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "Gametype.h"
+
+#include "core/CoreIncludes.h"
+#include "objects/infos/PlayerInfo.h"
+
+namespace orxonox
+{
+    CreateUnloadableFactory(Gametype);
+
+    Gametype::Gametype()
+    {
+        RegisterObject(Gametype);
+
+        this->getConnectedClients();
+
+        COUT(0) << "created Gametype" << std::endl;
+    }
+
+    Gametype* Gametype::getCurrentGametype()
+    {
+        for (ObjectList<Gametype>::iterator it = ObjectList<Gametype>::begin(); it != ObjectList<Gametype>::end(); ++it)
+            return (*it);
+
+        return 0;
+    }
+
+    void Gametype::clientConnected(unsigned int clientID)
+    {
+        COUT(0) << "client connected" << std::endl;
+
+        PlayerInfo* player = new PlayerInfo();
+        player->setClientID(clientID);
+    }
+
+    void Gametype::clientDisconnected(unsigned int clientID)
+    {
+        COUT(0) << "client disconnected" << std::endl;
+    }
+
+    void Gametype::addPlayer(PlayerInfo* player)
+    {
+        this->players_.insert(player);
+        this->playerJoined(player);
+    }
+
+    void Gametype::removePlayer(PlayerInfo* player)
+    {
+        this->players_.erase(player);
+        this->playerLeft(player);
+    }
+
+    void Gametype::playerJoined(PlayerInfo* player)
+    {
+        COUT(0) << "player " << player->getName() << " joined" << std::endl;
+    }
+
+    void Gametype::playerLeft(PlayerInfo* player)
+    {
+        COUT(0) << "player " << player->getName() << " left" << std::endl;
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h	(revision 1940)
@@ -0,0 +1,61 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _Gametype_H__
+#define _Gametype_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "core/BaseObject.h"
+#include "network/ClientConnectionListener.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport Gametype : public BaseObject, public network::ClientConnectionListener
+    {
+        public:
+            Gametype();
+            virtual ~Gametype() {}
+
+            static Gametype* getCurrentGametype();
+            void addPlayer(PlayerInfo* player);
+            void removePlayer(PlayerInfo* player);
+
+        protected:
+            virtual void clientConnected(unsigned int clientID);
+            virtual void clientDisconnected(unsigned int clientID);
+
+            virtual void playerJoined(PlayerInfo* player);
+            virtual void playerLeft(PlayerInfo* player);
+
+        private:
+            std::set<PlayerInfo*> players_;
+    };
+}
+
+#endif /* _Gametype_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/Info.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/Info.cc	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/Info.cc	(revision 1940)
@@ -0,0 +1,39 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "Info.h"
+
+#include "core/CoreIncludes.h"
+
+namespace orxonox
+{
+    Info::Info()
+    {
+        RegisterObject(Info);
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/Info.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/Info.h	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/Info.h	(revision 1940)
@@ -0,0 +1,47 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _Info_H__
+#define _Info_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "network/Synchronisable.h"
+#include "core/BaseObject.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport Info : public BaseObject, public network::Synchronisable
+    {
+        public:
+            Info();
+            virtual ~Info() {}
+    };
+}
+
+#endif /* _Info_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/LevelInfo.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/LevelInfo.cc	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/LevelInfo.cc	(revision 1940)
@@ -0,0 +1,100 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "LevelInfo.h"
+
+#include <OgreSceneManager.h>
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "Settings.h"
+#include "GraphicsEngine.h"
+
+namespace orxonox
+{
+    CreateFactory(LevelInfo);
+
+    LevelInfo::LevelInfo()
+    {
+        RegisterObject(LevelInfo);
+
+        this->gametypeInstance_ = 0;
+        this->registerVariables();
+
+        COUT(0) << "created LevelInfo" << std::endl;
+    }
+
+    void LevelInfo::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(LevelInfo, XMLPort, xmlelement, mode);
+
+        XMLPortParam(LevelInfo, "description", setDescription, getDescription, xmlelement, mode);
+        XMLPortParam(LevelInfo, "gametype", setGametype, getGametype, xmlelement, mode).defaultValues("Gametype");
+        XMLPortParam(LevelInfo, "skybox", setSkybox, getSkybox, xmlelement, mode);
+        XMLPortParam(LevelInfo, "ambientlight", setAmbientLight, getAmbientLight, xmlelement, mode).defaultValues(ColourValue(0.2, 0.2, 0.2, 1));
+    }
+
+    void LevelInfo::registerVariables()
+    {
+        REGISTERDATA(name_,         network::direction::toclient, new network::NetworkCallback<LevelInfo>(this, &LevelInfo::changedName));
+        REGISTERDATA(description_,  network::direction::toclient);
+        REGISTERDATA(skybox_,       network::direction::toclient, new network::NetworkCallback<LevelInfo>(this, &LevelInfo::applySkybox));
+        REGISTERDATA(ambientLight_, network::direction::toclient, new network::NetworkCallback<LevelInfo>(this, &LevelInfo::applyAmbientLight));
+    }
+
+    void LevelInfo::setSkybox(const std::string& skybox)
+    {
+        if (Settings::showsGraphics())
+            if (GraphicsEngine::getInstance().getLevelSceneManager())
+                GraphicsEngine::getInstance().getLevelSceneManager()->setSkyBox(true, skybox);
+
+        this->skybox_ = skybox;
+    }
+
+    void LevelInfo::setAmbientLight(const ColourValue& colour)
+    {
+        if (Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->setAmbientLight(colour);
+
+        this->ambientLight_ = colour;
+    }
+
+    void LevelInfo::setGametype(const std::string& gametype)
+    {
+        std::cout << "0: " << gametype << std::endl;
+        Identifier* identifier = ClassByString(gametype);
+        if (identifier)
+        {
+            std::cout << "1: " << identifier->getName() << std::endl;
+            this->gametype_ = gametype;
+            this->gametypeIdentifier_ = identifier;
+            this->gametypeInstance_ = this->gametypeIdentifier_.fabricate();
+        }
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/LevelInfo.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/LevelInfo.h	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/LevelInfo.h	(revision 1940)
@@ -0,0 +1,83 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _LevelInfo_H__
+#define _LevelInfo_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "Info.h"
+#include "util/Math.h"
+#include "core/Identifier.h"
+
+#include "objects/gametypes/Gametype.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport LevelInfo : public Info
+    {
+        public:
+            LevelInfo();
+            virtual ~LevelInfo() {}
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            void registerVariables();
+
+            inline void setDescription(const std::string& description)
+                { this->description_ = description; }
+            inline const std::string& getDescription() const
+                { return this->description_; }
+
+            void setSkybox(const std::string& skybox);
+            inline const std::string& getSkybox() const
+                { return this->skybox_; }
+
+            void setAmbientLight(const ColourValue& colour);
+            inline const ColourValue& getAmbientLight() const
+                { return this->ambientLight_; }
+
+            void setGametype(const std::string& gametype);
+            inline const std::string& getGametype() const
+                { return this->gametype_; }
+
+        private:
+            void applySkybox()
+                { this->setSkybox(this->skybox_); }
+            void applyAmbientLight()
+                { this->setAmbientLight(this->ambientLight_); }
+
+            std::string description_;
+            std::string skybox_;
+            ColourValue ambientLight_;
+            std::string gametype_;
+            SubclassIdentifier<Gametype> gametypeIdentifier_;
+            Gametype* gametypeInstance_;
+    };
+}
+
+#endif /* _LevelInfo_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc	(revision 1940)
@@ -0,0 +1,120 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "PlayerInfo.h"
+
+#include <OgreSceneManager.h>
+
+#include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
+#include "core/XMLPort.h"
+
+#include "network/Host.h"
+
+#include "Settings.h"
+#include "GraphicsEngine.h"
+#include "objects/gametypes/Gametype.h"
+
+namespace orxonox
+{
+    CreateUnloadableFactory(PlayerInfo);
+
+    PlayerInfo::PlayerInfo()
+    {
+        RegisterObject(PlayerInfo);
+
+        this->ping_ = -1;
+        this->bLocalPlayer_ = Settings::isStandalone();
+        this->bLocalPlayer_ = false;
+        this->bHumanPlayer_ = false;
+        this->bFinishedSetup_ = false;
+
+        this->setConfigValues();
+        this->registerVariables();
+
+        COUT(0) << "created PlayerInfo" << std::endl;
+    }
+
+    PlayerInfo::~PlayerInfo()
+    {
+        Gametype* gametype = Gametype::getCurrentGametype();
+        if (gametype)
+            gametype->removePlayer(this);
+    }
+
+    void PlayerInfo::setConfigValues()
+    {
+        SetConfigValue(playerName_, "Player").callback(this, &PlayerInfo::checkName);
+    }
+
+    void PlayerInfo::registerVariables()
+    {
+        this->setObjectMode(network::direction::bidirectional);
+
+        REGISTERDATA(name_,                 network::direction::bidirectional, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::changedName));
+        REGISTERDATA(clientID_,             network::direction::toclient,      new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::checkClientID));
+        REGISTERDATA(ping_,                 network::direction::toclient);
+        REGISTERDATA(bHumanPlayer_,         network::direction::toclient);
+        REGISTERDATA(bFinishedSetup_,       network::direction::bidirectional, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::finishedSetup));
+    }
+
+    void PlayerInfo::checkName()
+    {
+        if (this->bLocalPlayer_)
+            this->setName(this->playerName_);
+    }
+
+    void PlayerInfo::checkClientID()
+    {
+        this->bHumanPlayer_ = true;
+
+        if (this->clientID_ == network::Host::getPlayerID())
+        {
+            this->bLocalPlayer_ = true;
+            this->setName(this->playerName_);
+
+            if (!Settings::isClient())
+            {
+                this->bFinishedSetup_ = true;
+                this->finishedSetup();
+            }
+        }
+    }
+
+    void PlayerInfo::finishedSetup()
+    {
+        if (Settings::isClient())
+            this->bFinishedSetup_ = true;
+        else if (this->bFinishedSetup_)
+        {
+            Gametype* gametype = Gametype::getCurrentGametype();
+            if (gametype)
+                gametype->addPlayer(this);
+        }
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h	(revision 1940)
@@ -0,0 +1,72 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _PlayerInfo_H__
+#define _PlayerInfo_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "Info.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport PlayerInfo : public Info
+    {
+        public:
+            PlayerInfo();
+            virtual ~PlayerInfo();
+
+            void setConfigValues();
+            void registerVariables();
+
+            inline void setClientID(unsigned int clientID)
+                { this->clientID_ = clientID; this->checkClientID(); }
+            inline unsigned int getClientID() const
+                { return this->clientID_; }
+
+            inline void setHumanPlayer(bool bHumanPlayer)
+                { this->bHumanPlayer_ = bHumanPlayer; }
+            inline bool isHumanPlayer() const
+                { return this->bHumanPlayer_; }
+
+        private:
+            void checkClientID();
+            void finishedSetup();
+            void checkName();
+
+            unsigned int clientID_;
+            float ping_;
+            bool bLocalPlayer_;
+            bool bHumanPlayer_;
+            bool bFinishedSetup_;
+
+            std::string playerName_;
+    };
+}
+
+#endif /* _PlayerInfo_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.cc	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.cc	(revision 1940)
@@ -0,0 +1,60 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "PositionableEntity.h"
+#include "core/CoreIncludes.h"
+
+namespace orxonox
+{
+    CreateFactory(PositionableEntity);
+
+    PositionableEntity::PositionableEntity()
+    {
+        RegisterObject(PositionableEntity);
+
+        this->registerVariables();
+
+        std::cout << "##### created pos-entity" << std::endl;
+    }
+
+    PositionableEntity::~PositionableEntity()
+    {
+    }
+
+    void PositionableEntity::registerVariables()
+    {
+        REGISTERDATA(this->getPosition().x, network::direction::toclient);
+        REGISTERDATA(this->getPosition().y, network::direction::toclient);
+        REGISTERDATA(this->getPosition().z, network::direction::toclient);
+
+        REGISTERDATA(this->getOrientation().w, network::direction::toclient);
+        REGISTERDATA(this->getOrientation().x, network::direction::toclient);
+        REGISTERDATA(this->getOrientation().y, network::direction::toclient);
+        REGISTERDATA(this->getOrientation().z, network::direction::toclient);
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h	(revision 1940)
@@ -0,0 +1,66 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _PositionableEntity_H__
+#define _PositionableEntity_H__
+
+#include "OrxonoxPrereqs.h"
+#include "WorldEntity.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport PositionableEntity : public WorldEntity
+    {
+        public:
+            PositionableEntity();
+            virtual ~PositionableEntity();
+
+            void registerVariables();
+
+            inline void setPosition(const Vector3& position)
+                { this->node_->setPosition(position); std::cout << "set position to " << position << std::endl; }
+            inline void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->node_->translate(distance, relativeTo); }
+            inline void setOrientation(const Quaternion& orientation)
+                { this->node_->setOrientation(orientation); }
+            inline void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->node_->rotate(rotation, relativeTo); }
+            inline void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->node_->yaw(angle, relativeTo); }
+            inline void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->node_->pitch(angle, relativeTo); }
+            inline void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->node_->roll(angle, relativeTo); }
+            inline void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
+                { this->node_->lookAt(target, relativeTo, localDirectionVector); }
+            inline void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
+                { this->node_->setDirection(direction, relativeTo, localDirectionVector); }
+    };
+}
+
+#endif /* _PositionableEntity_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 1940)
@@ -0,0 +1,127 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "WorldEntity.h"
+
+#include <OgreSceneManager.h>
+
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
+
+#include "GraphicsEngine.h"
+
+namespace orxonox
+{
+    WorldEntity::WorldEntity()
+    {
+        RegisterObject(WorldEntity);
+
+        this->node_ = GraphicsEngine::getInstance().getLevelSceneManager()->createSceneNode();
+        this->parent_ = 0;
+        this->parentID_ = (unsigned int)-1;
+
+        this->registerVariables();
+    }
+
+    WorldEntity::~WorldEntity()
+    {
+        if (this->isInitialized())
+        {
+            this->node_->detachAllObjects();
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroySceneNode(this->node_->getName());
+        }
+    }
+
+
+    void WorldEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(WorldEntity, XMLPort, xmlelement, mode);
+
+        XMLPortParamTemplate(WorldEntity, "position", setPosition, getPosition, xmlelement, mode, const Vector3&);
+        XMLPortParamTemplate(WorldEntity, "orientation", setOrientation, getOrientation, xmlelement, mode, const Quaternion&);
+        XMLPortParamLoadOnly(WorldEntity, "lookat", lookAt_xmlport, xmlelement, mode);
+        XMLPortParamLoadOnly(WorldEntity, "direction", setDirection_xmlport, xmlelement, mode);
+        XMLPortParamLoadOnly(WorldEntity, "yaw", yaw_xmlport, xmlelement, mode);
+        XMLPortParamLoadOnly(WorldEntity, "pitch", pitch_xmlport, xmlelement, mode);
+        XMLPortParamLoadOnly(WorldEntity, "roll", roll_xmlport, xmlelement, mode);
+        XMLPortParamTemplate(WorldEntity, "scale3D", setScale3D, getScale3D, xmlelement, mode, const Vector3&);
+        XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
+
+        XMLPortObject(WorldEntity, WorldEntity, "attached", attach, getAttachedObject, xmlelement, mode);
+    }
+
+    void WorldEntity::registerVariables()
+    {
+        REGISTERDATA(this->bActive_,  network::direction::toclient, new network::NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));
+        REGISTERDATA(this->bVisible_, network::direction::toclient, new network::NetworkCallback<WorldEntity>(this, &WorldEntity::changedVisibility));
+
+        REGISTERDATA(this->getScale3D().x, network::direction::toclient);
+        REGISTERDATA(this->getScale3D().y, network::direction::toclient);
+        REGISTERDATA(this->getScale3D().z, network::direction::toclient);
+
+        REGISTERDATA(this->parentID_, network::direction::toclient, new network::NetworkCallback<WorldEntity>(this, &WorldEntity::updateParent));
+    }
+
+    void WorldEntity::updateParent()
+    {
+        WorldEntity* parent = dynamic_cast<WorldEntity*>(Synchronisable::getSynchronisable(this->parentID_));
+        if (parent)
+            this->attachToParent(parent);
+    }
+
+    void WorldEntity::attach(WorldEntity* object)
+    {
+        if (object->getParent())
+            object->detachFromParent();
+
+        this->node_->addChild(object->node_);
+        this->children_.insert(object);
+        object->parent_ = this;
+        object->parentID_ = this->getObjectID();
+    }
+
+    void WorldEntity::detach(WorldEntity* object)
+    {
+        this->node_->removeChild(object->node_);
+        this->children_.erase(object);
+        object->parent_ = 0;
+        object->parentID_ = (unsigned int)-1;
+    }
+
+    WorldEntity* WorldEntity::getAttachedObject(unsigned int index) const
+    {
+        unsigned int i;
+        for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
+        {
+            if (i == index)
+                return (*it);
+            ++i;
+        }
+        return 0;
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h	(revision 1940)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h	(revision 1940)
@@ -0,0 +1,146 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _WorldEntity_H__
+#define _WorldEntity_H__
+
+#include "OrxonoxPrereqs.h"
+
+#define OGRE_FORCE_ANGLE_TYPES
+
+#include <OgreSceneNode.h>
+
+#include "network/Synchronisable.h"
+#include "core/BaseObject.h"
+#include "util/Math.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport WorldEntity : public BaseObject, public network::Synchronisable
+    {
+        public:
+            WorldEntity();
+            virtual ~WorldEntity();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            void registerVariables();
+
+            inline Ogre::SceneNode* getNode() const
+                { return this->node_; }
+
+            virtual void setPosition(const Vector3& position) = 0;
+            inline void setPosition(float x, float y, float z)
+                { this->setPosition(Vector3(x, y, z)); }
+            inline const Vector3& getPosition() const
+                { return this->node_->getPosition(); }
+            inline const Vector3& getWorldPosition() const
+                { return this->node_->getWorldPosition(); }
+
+            virtual void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void translate(float x, float y, float z, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->translate(Vector3(x, y, z), relativeTo); }
+
+            virtual void setOrientation(const Quaternion& orientation) = 0;
+            inline void setOrientation(float w, float x, float y, float z)
+                { this->setOrientation(Quaternion(w, x, y, z)); }
+            inline void setOrientation(const Vector3& axis, const Radian& angle)
+                { this->setOrientation(Quaternion(angle, axis)); }
+            inline const Quaternion& getOrientation() const
+                { return this->node_->getOrientation(); }
+            inline const Quaternion& getWorldOrientation() const
+                { return this->node_->getWorldOrientation(); }
+
+            virtual void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void rotate(const Vector3& axis, const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->rotate(Quaternion(angle, axis), relativeTo); }
+
+            virtual void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            virtual void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            virtual void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+
+            virtual void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z) = 0;
+            virtual void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z) = 0;
+            inline void setDirection(float x, float y, float z, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
+                { this->setDirection(Vector3(x, y, z), relativeTo, localDirectionVector); }
+
+            inline void setScale3D(const Vector3& scale)
+                { this->node_->setScale(scale); }
+            inline void setScale3D(float x, float y, float z)
+                { this->node_->setScale(x, y, z); }
+            inline const Vector3& getScale3D(void) const
+                { return this->node_->getScale(); }
+
+            inline void setScale(float scale)
+                { this->node_->setScale(scale, scale, scale); }
+            inline float getScale() const
+                { Vector3 scale = this->getScale3D(); return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1; }
+
+            inline void scale3D(const Vector3& scale)
+                { this->node_->scale(scale); }
+            inline void scale3D(float x, float y, float z)
+                { this->node_->scale(x, y, z); }
+            inline void scale(float scale)
+                { this->node_->scale(scale, scale, scale); }
+
+            void attach(WorldEntity* object);
+            void detach(WorldEntity* object);
+            WorldEntity* getAttachedObject(unsigned int index) const;
+            inline const std::set<WorldEntity*>& getAttachedObjects() const
+                { return this->children_; }
+
+            inline void attachToParent(WorldEntity* parent)
+                { parent->attach(this); }
+            inline void detachFromParent()
+                { this->parent_->detach(this); }
+            inline WorldEntity* getParent() const
+                { return this->parent_; }
+
+        protected:
+            Ogre::SceneNode* node_;
+
+        private:
+            void updateParent();
+
+            inline void lookAt_xmlport(const Vector3& target)
+                { this->lookAt(target); }
+            inline void setDirection_xmlport(const Vector3& direction)
+                { this->setDirection(direction); }
+            inline void yaw_xmlport(const Radian& angle)
+                { this->yaw(angle); }
+            inline void pitch_xmlport(const Radian& angle)
+                { this->pitch(angle); }
+            inline void roll_xmlport(const Radian& angle)
+                { this->roll(angle); }
+
+            WorldEntity* parent_;
+            unsigned int parentID_;
+            std::set<WorldEntity*> children_;
+    };
+}
+
+#endif /* _WorldEntity_H__ */
