Index: code/branches/objecthierarchy/src/orxonox/CMakeLists.txt
===================================================================
--- code/branches/objecthierarchy/src/orxonox/CMakeLists.txt	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/CMakeLists.txt	(revision 1989)
@@ -43,9 +43,8 @@
   tools/WindowEventListener.cc
 
-  objects/Template.cc
-
   objects/worldentities/WorldEntity.cc
   objects/worldentities/PositionableEntity.cc
   objects/worldentities/MovableEntity.cc
+  objects/worldentities/ControllableEntity.cc
 #  objects/Backlight.cc
   objects/Camera.cc
Index: code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h	(revision 1989)
@@ -81,6 +81,4 @@
 
     // objects
-    class Template;
-
     class WorldEntity;
     class PositionableEntity;
Index: code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc	(revision 1989)
@@ -49,4 +49,5 @@
         GSLevel::enter();
 
+        Core::setIsStandalone(true);
         this->loadLevel();
 
@@ -58,6 +59,4 @@
         // level is loaded: we can start capturing the input
         InputManager::getInstance().requestEnterState("game");
-
-        Core::setIsStandalone(true);
     }
 
Index: code/branches/objecthierarchy/src/orxonox/objects/Camera.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/Camera.cc	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/Camera.cc	(revision 1989)
@@ -47,44 +47,32 @@
 namespace orxonox
 {
+  Camera::Camera()
+  {
+    RegisterObject(Camera);
 
-  Camera::Camera(Ogre::SceneNode* node)
-  {
     this->bHasFocus_ = false;
-    this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
-    if( node != NULL )
-      this->setPositionNode(node);
+    this->bDrag_ = false;
+    this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode();
+    this->setObjectMode(0x0);
   }
 
   Camera::~Camera()
   {
-    CameraHandler::getInstance()->releaseFocus(this);
-    GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
-  }
-
-  void Camera::setPositionNode(Ogre::SceneNode* node)
-  {
-    this->positionNode_ = node;
-    // set camera to node values according to camera mode
-  }
-
-  void Camera::setTargetNode(Ogre::SceneNode* obj)
-  {
-    this->targetNode_ = obj;
+    if (this->isInitialized())
+    {
+      CameraHandler::getInstance()->releaseFocus(this);
+      GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(this->cameraNode_->getName());
+    }
   }
 
   void Camera::tick(float dt)
   {
-    if (this->positionNode_ != NULL)
-    {
       // this stuff here may need some adjustments
-      Vector3 offset = this->positionNode_->getWorldPosition() - this->cameraNode_->getWorldPosition();
-      float coeff = 15.0f * dt;
-      if (coeff > 1.0f)
-        coeff = 1.0f;
+      float coeff = (this->bDrag_) ? min(1.0f, 15.0f * dt) : (1.0f);
 
+      Vector3 offset = this->getNode()->getWorldPosition() - this->cameraNode_->getWorldPosition();
       this->cameraNode_->translate(coeff * offset);
 
-      this->cameraNode_->setOrientation(Quaternion::Slerp(1-coeff, this->positionNode_->getWorldOrientation(), this->cameraNode_->getWorldOrientation(), false));
-    }
+      this->cameraNode_->setOrientation(Quaternion::Slerp(coeff, this->cameraNode_->getWorldOrientation(), this->getWorldOrientation(), false));
   }
 
@@ -95,9 +83,6 @@
   void Camera::update()
   {
-    if(this->positionNode_ != NULL)
-    {
-      this->cameraNode_->setPosition(this->positionNode_->getWorldPosition());
-      this->cameraNode_->setOrientation(this->positionNode_->getWorldOrientation());
-    }
+      this->cameraNode_->setPosition(this->getWorldPosition());
+      this->cameraNode_->setOrientation(this->getWorldOrientation());
   }
 
@@ -119,3 +104,8 @@
     this->cameraNode_->attachObject(this->cam_);
   }
+
+  void Camera::requestFocus()
+  {
+    CameraHandler::getInstance()->requestFocus(this);
+  }
 }
Index: code/branches/objecthierarchy/src/orxonox/objects/Camera.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/Camera.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/Camera.h	(revision 1989)
@@ -35,24 +35,26 @@
 
 #include "OrxonoxPrereqs.h"
+#include "objects/worldentities/PositionableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Camera
+    class _OrxonoxExport Camera : public PositionableEntity
     {
       friend class CameraHandler;
       public:
-        Camera(Ogre::SceneNode* node = NULL);
+        Camera();
         virtual ~Camera();
-
-        void setPositionNode(Ogre::SceneNode* node);
-        inline Ogre::SceneNode* getCameraNode() { return this->positionNode_; }
-        // maybe also BaseObject
-        void setTargetNode(Ogre::SceneNode* obj);
-
-        Ogre::Camera* cam_;
 
         void tick(float dt);
         void update();
-        inline bool hasFocus() { return this->bHasFocus_; }
+
+        void requestFocus();
+        inline bool hasFocus()
+            { return this->bHasFocus_; }
+
+        inline void setDrag(bool bDrag)
+            { this->bDrag_ = bDrag; }
+        inline bool getDrag() const
+            { return this->bDrag_; }
 
       private:
@@ -60,10 +62,9 @@
         void setFocus(Ogre::Camera* ogreCam);
 
-      private:
-        Ogre::SceneNode* targetNode_;
-        Ogre::SceneNode* positionNode_;
+        Ogre::Camera* cam_;
         Ogre::SceneNode* cameraNode_;
         Ogre::Vector3 oldPos;
         bool bHasFocus_;
+        bool bDrag_;
     };
 }
Index: code/branches/objecthierarchy/src/orxonox/objects/Template.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/Template.cc	(revision 1970)
+++ 	(revision )
@@ -1,136 +1,0 @@
-/*
- *   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 "OrxonoxStableHeaders.h"
-#include "Template.h"
-
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
-#include "util/Debug.h"
-
-namespace orxonox
-{
-    CreateFactory(Template);
-
-    Template::Template()
-    {
-        RegisterObject(Template);
-
-        this->bIsLink_ = false;
-        this->bIsReturningXMLElement_ = false;
-        this->baseclassIdentifier_ = 0;
-    }
-
-    Template::~Template()
-    {
-    }
-
-    void Template::XMLPort(Element& xmlelement, XMLPort::Mode mode)
-    {
-        SUPER(Template, XMLPort, xmlelement, mode);
-
-        XMLPortParam(Template, "link", setLink, getLink, xmlelement, mode);
-        XMLPortParam(Template, "baseclass", setBaseclass, getBaseclass, xmlelement, mode);
-
-        this->setXMLElement(*xmlelement.FirstChildElement(false));
-    }
-
-    const Element& Template::getXMLElement() const
-    {
-        if (this->bIsLink_)
-        {
-            Template* temp = Template::getTemplate(this->link_);
-            if (temp)
-            {
-                if (!temp->bIsReturningXMLElement_)
-                {
-                    this->bIsReturningXMLElement_ = true;
-                    const Element& element = temp->getXMLElement();
-                    this->bIsReturningXMLElement_ = false;
-                    return element;
-                }
-                else
-                {
-                    COUT(2) << "Warning: Linking from " << this->getName() << " to " << this->link_ << " leads to an infinite loop. Returning own element." << std::endl;
-                }
-            }
-            else
-            {
-                COUT(2) << "Warning: " << this->link_ << " is not an existing Template name. Returning own element." << std::endl;
-            }
-        }
-
-        return this->xmlelement_;
-    }
-
-    void Template::setBaseclass(const std::string& baseclass)
-    {
-        this->baseclassIdentifier_ = ClassByString(baseclass);
-        if (this->baseclassIdentifier_)
-            this->baseclass_ = baseclass;
-    }
-
-    void Template::applyOn(BaseObject* object)
-    {
-        if (this->baseclassIdentifier_)
-        {
-            if (!object->isA(this->baseclassIdentifier_))
-            {
-                COUT(1) << "Error: Can't apply template (name: " << this->getName() << "), object (name: " << object->getName() << ", class: " << object->getIdentifier()->getName() << ") is not a " << this->baseclassIdentifier_->getName() << std::endl;
-                return;
-            }
-        }
-
-        COUT(4) << object->getLoaderIndentation() << " aplying Template \"" << this->getName() << "\"..." << std::endl;
-
-        Element temp = this->getXMLElement();
-        object->XMLPort(temp, XMLPort::LoadObject);
-    }
-
-    std::map<std::string, Template*>& Template::getTemplateMap()
-    {
-        static std::map<std::string, Template*> templateMap;
-        return templateMap;
-    }
-
-    Template* Template::getTemplate(const std::string& name)
-    {
-        std::map<std::string, Template*>::iterator it = Template::getTemplateMap().find(name);
-        if (it != Template::getTemplateMap().end())
-            return it->second;
-        else
-            return 0;
-    }
-
-    void Template::apply(const std::string& name, BaseObject* object)
-    {
-        std::map<std::string, Template*>::iterator it = Template::getTemplateMap().find(name);
-        if (it != Template::getTemplateMap().end())
-            it->second->applyOn(object);
-    }
-}
Index: code/branches/objecthierarchy/src/orxonox/objects/Template.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/Template.h	(revision 1970)
+++ 	(revision )
@@ -1,79 +1,0 @@
-/*
- *   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 _Template_H__
-#define _Template_H__
-
-#include <map>
-
-#include "OrxonoxPrereqs.h"
-#include "core/BaseObject.h"
-#include "tinyxml/ticpp.h"
-
-namespace orxonox
-{
-    class _OrxonoxExport Template : public BaseObject
-    {
-        public:
-            Template();
-            virtual ~Template();
-
-            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-
-            inline void setLink(const std::string& link)
-                { this->link_ = link; this->bIsLink_ = (link != ""); }
-            inline const std::string& getLink() const
-                { return this->link_; }
-
-            inline void setXMLElement(const Element& xmlelement)
-                { this->xmlelement_ = xmlelement; }
-            const Element& getXMLElement() const;
-
-            void setBaseclass(const std::string& baseclass);
-            inline const std::string& getBaseclass() const
-                { return this->baseclass_; }
-            inline Identifier* getBaseclassIdentifier() const
-                { return this->baseclassIdentifier_; }
-
-            void applyOn(BaseObject* object);
-
-            static std::map<std::string, Template*>& getTemplateMap();
-            static Template* getTemplate(const std::string& name);
-            static void apply(const std::string& name, BaseObject* object);
-
-        private:
-            Element xmlelement_;
-            std::string link_;
-            std::string baseclass_;
-            Identifier* baseclassIdentifier_;
-            bool bIsLink_;
-            mutable bool bIsReturningXMLElement_;
-    };
-}
-
-#endif /* _Template_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc	(revision 1989)
@@ -122,8 +122,12 @@
         this->players_.insert(player);
         this->playerJoined(player);
+
+        ControllableEntity* newpawn = this->defaultPawn_.fabricate();
+        player->startControl(newpawn);
     }
 
     void Gametype::removePlayer(PlayerInfo* player)
     {
+        player->stopControl();
         this->players_.erase(player);
         this->playerLeft(player);
Index: code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h	(revision 1989)
@@ -35,5 +35,7 @@
 
 #include "core/BaseObject.h"
+#include "core/Identifier.h"
 #include "network/ClientConnectionListener.h"
+#include "objects/worldentities/ControllableEntity.h"
 
 namespace orxonox
@@ -71,4 +73,5 @@
             std::set<PlayerInfo*> players_;
             std::map<unsigned int, PlayerInfo*> clients_;
+            SubclassIdentifier<ControllableEntity> defaultPawn_;
     };
 }
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc	(revision 1989)
@@ -41,4 +41,5 @@
 #include "GraphicsEngine.h"
 #include "objects/gametypes/Gametype.h"
+#include "objects/worldentities/ControllableEntity.h"
 
 namespace orxonox
@@ -56,4 +57,7 @@
         this->bHumanPlayer_ = false;
         this->bFinishedSetup_ = false;
+
+        this->pawn_ = 0;
+        this->pawnID_ = network::OBJECTID_UNKNOWN;
 
         this->setConfigValues();
@@ -103,4 +107,5 @@
         REGISTERDATA(ping_,           network::direction::toclient);
         REGISTERDATA(bHumanPlayer_,   network::direction::toclient);
+        REGISTERDATA(pawnID_,         network::direction::toclient, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::updatePawn));
         REGISTERDATA(bFinishedSetup_, network::direction::bidirectional, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::finishedSetup));
     }
@@ -160,3 +165,24 @@
         }
     }
+
+    void PlayerInfo::startControl(ControllableEntity* pawn)
+    {
+        pawn->setPlayer(this);
+        this->pawn_ = pawn;
+        this->pawnID_ = pawn->getObjectID();
+    }
+
+    void PlayerInfo::stopControl()
+    {
+        this->pawn_->removePlayer();
+        this->pawn_ = 0;
+        this->pawnID_ = network::OBJECTID_UNKNOWN;
+    }
+
+    void PlayerInfo::updatePawn()
+    {
+        this->pawn_ = dynamic_cast<ControllableEntity*>(network::Synchronisable::getSynchronisable(this->pawnID_));
+        if (this->pawn_ && (this->pawn_->getPlayer() != this))
+            this->pawn_->setPlayer(this);
+    }
 }
Index: code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h	(revision 1989)
@@ -52,8 +52,15 @@
                 { return this->clientID_; }
 
-            inline void setHumanPlayer(bool bHumanPlayer)
-                { this->bHumanPlayer_ = bHumanPlayer; }
             inline bool isHumanPlayer() const
                 { return this->bHumanPlayer_; }
+
+            inline bool isLocalPlayer() const
+                { return this->bLocalPlayer_; }
+
+            void startControl(ControllableEntity* pawn);
+            void stopControl();
+
+            inline ControllableEntity* getPawn() const
+                { return this->pawn_; }
 
         private:
@@ -62,4 +69,5 @@
             void checkNick();
             void clientChangedName();
+            void updatePawn();
 
             unsigned int clientID_;
@@ -71,4 +79,7 @@
             std::string playerName_;
             std::string nick_;
+
+            ControllableEntity* pawn_;
+            unsigned int pawnID_;
     };
 }
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.cc	(revision 1989)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.cc	(revision 1989)
@@ -0,0 +1,380 @@
+/*
+ *   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 "ControllableEntity.h"
+
+#include "core/CoreIncludes.h"
+#include "core/Core.h"
+#include "core/XMLPort.h"
+#include "core/Template.h"
+
+#include "objects/infos/PlayerInfo.h"
+#include "objects/Camera.h"
+#include "overlays/OverlayGroup.h"
+
+namespace orxonox
+{
+    CreateFactory(ControllableEntity);
+
+    ControllableEntity::ControllableEntity()
+    {
+        RegisterObject(ControllableEntity);
+
+        this->bControlled_ = false;
+        this->server_overwrite_ = 0;
+        this->client_overwrite_ = 0;
+        this->player_ = 0;
+        this->playerID_ = network::OBJECTID_UNKNOWN;
+        this->hud_ = 0;
+        this->camera_ = 0;
+
+
+        this->velocity_ = Vector3::ZERO;
+        this->acceleration_ = Vector3::ZERO;
+
+        this->server_position_ = Vector3::ZERO;
+        this->client_position_ = Vector3::ZERO;
+        this->server_velocity_ = Vector3::ZERO;
+        this->client_velocity_ = Vector3::ZERO;
+        this->server_orientation_ = Quaternion::IDENTITY;
+        this->client_orientation_ = Quaternion::IDENTITY;
+
+        this->registerVariables();
+    }
+
+    ControllableEntity::~ControllableEntity()
+    {
+        if (this->isInitialized() && this->bControlled_)
+            this->stopLocalControl();
+    }
+
+    void ControllableEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SUPER(ControllableEntity, XMLPort, xmlelement, mode);
+
+        XMLPortParam(ControllableEntity, "hudtemplate", setHudTemplate, getHudTemplate, xmlelement, mode);
+    }
+
+    void ControllableEntity::setPlayer(PlayerInfo* player)
+    {
+        if (!player)
+        {
+            this->removePlayer();
+            return;
+        }
+
+        this->player_ = player;
+        this->playerID_ = player->getObjectID();
+        this->bControlled_ = player->isLocalPlayer();
+
+        if (this->bControlled_)
+            this->startLocalControl();
+    }
+
+    void ControllableEntity::removePlayer()
+    {
+        if (this->bControlled_)
+            this->stopLocalControl();
+
+        this->player_ = 0;
+        this->playerID_ = network::OBJECTID_UNKNOWN;
+        this->bControlled_ = false;
+    }
+
+    void ControllableEntity::updatePlayer()
+    {
+        this->player_ = dynamic_cast<PlayerInfo*>(network::Synchronisable::getSynchronisable(this->playerID_));
+        if (this->player_ && (this->player_->getPawn() != this))
+            this->player_->startControl(this);
+    }
+
+    void ControllableEntity::startLocalControl()
+    {
+        this->camera_ = new Camera();
+        this->camera_->requestFocus();
+
+        this->hud_ = new OverlayGroup();
+        this->hud_->addTemplate(this->hudtemplate_);
+    }
+
+    void ControllableEntity::stopLocalControl()
+    {
+        delete this->camera_;
+        this->camera_ = 0;
+
+        delete this->hud_;
+        this->hud_ = 0;
+    }
+
+    void ControllableEntity::tick(float dt)
+    {
+        if (this->isActive())
+        {
+            this->velocity_ += (dt * this->acceleration_);
+            this->node_->translate(dt * this->velocity_);
+
+            if (Core::isMaster())
+            {
+                this->server_velocity_ = this->velocity_;
+                this->server_position_ = this->node_->getPosition();
+            }
+            else if (this->bControlled_)
+            {
+                this->client_velocity_ = this->velocity_;
+                this->client_position_ = this->node_->getPosition();
+            }
+        }
+
+//        std::cout << this->getPosition() << std::endl;
+    }
+
+    void ControllableEntity::registerVariables()
+    {
+        REGISTERDATA(this->server_position_,    network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
+        REGISTERDATA(this->server_velocity_,    network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerVelocity));
+        REGISTERDATA(this->server_orientation_, network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
+
+        REGISTERDATA(this->server_overwrite_,   network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
+
+        REGISTERDATA(this->client_position_,    network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
+        REGISTERDATA(this->client_velocity_,    network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientVelocity));
+        REGISTERDATA(this->client_orientation_, network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
+
+        REGISTERDATA(this->client_overwrite_,   network::direction::toserver);
+
+        REGISTERDATA(this->playerID_, network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::updatePlayer));
+    }
+
+    void ControllableEntity::processServerPosition()
+    {
+        if (!this->bControlled_)
+            this->node_->setPosition(this->server_position_);
+    }
+
+    void ControllableEntity::processServerVelocity()
+    {
+        if (!this->bControlled_)
+            this->velocity_ = this->server_velocity_;
+    }
+
+    void ControllableEntity::processServerOrientation()
+    {
+        if (!this->bControlled_)
+            this->node_->setOrientation(this->server_orientation_);
+    }
+
+    void ControllableEntity::processOverwrite()
+    {
+        if (this->bControlled_)
+        {
+            this->setPosition(this->server_position_);
+            this->setVelocity(this->server_velocity_);
+            this->setOrientation(this->server_orientation_);
+
+            this->client_overwrite_ = this->server_overwrite_;
+        }
+    }
+
+    void ControllableEntity::processClientPosition()
+    {
+        if (this->server_overwrite_ == this->client_overwrite_)
+        {
+            this->node_->setPosition(this->client_position_);
+            this->server_position_ = this->client_position_;
+        }
+    }
+
+    void ControllableEntity::processClientVelocity()
+    {
+        if (this->server_overwrite_ == this->client_overwrite_)
+        {
+            this->velocity_ = this->client_velocity_;
+            this->server_velocity_ = this->client_velocity_;
+        }
+    }
+
+    void ControllableEntity::processClientOrientation()
+    {
+        if (this->server_overwrite_ == this->client_overwrite_)
+        {
+            this->node_->setOrientation(this->client_orientation_);
+            this->server_orientation_ = this->client_orientation_;
+        }
+    }
+
+
+    void ControllableEntity::setPosition(const Vector3& position)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->setPosition(position);
+            this->server_position_ = position;
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->setPosition(position);
+            this->client_position_ = position;
+        }
+    }
+
+    void ControllableEntity::setVelocity(const Vector3& velocity)
+    {
+        if (Core::isMaster())
+        {
+            this->velocity_ = velocity;
+            this->server_velocity_ = velocity;
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->velocity_ = velocity;
+            this->client_velocity_ = velocity;
+        }
+    }
+
+    void ControllableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->translate(distance, relativeTo);
+            this->server_position_ = this->node_->getPosition();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->translate(distance, relativeTo);
+            this->client_position_ = this->node_->getPosition();
+        }
+    }
+
+    void ControllableEntity::setOrientation(const Quaternion& orientation)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->setOrientation(orientation);
+            this->server_orientation_ = orientation;
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->setOrientation(orientation);
+            this->client_orientation_ = orientation;
+        }
+    }
+
+    void ControllableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->rotate(rotation, relativeTo);
+            this->server_orientation_ = this->node_->getOrientation();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->rotate(rotation, relativeTo);
+            this->client_orientation_ = this->node_->getOrientation();
+        }
+    }
+
+    void ControllableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->yaw(angle, relativeTo);
+            this->server_orientation_ = this->node_->getOrientation();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->yaw(angle, relativeTo);
+            this->client_orientation_ = this->node_->getOrientation();
+        }
+    }
+
+    void ControllableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->pitch(angle, relativeTo);
+            this->server_orientation_ = this->node_->getOrientation();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->pitch(angle, relativeTo);
+            this->client_orientation_ = this->node_->getOrientation();
+        }
+    }
+
+    void ControllableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->roll(angle, relativeTo);
+            this->server_orientation_ = this->node_->getOrientation();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->roll(angle, relativeTo);
+            this->client_orientation_ = this->node_->getOrientation();
+        }
+    }
+
+    void ControllableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->lookAt(target, relativeTo, localDirectionVector);
+            this->server_orientation_ = this->node_->getOrientation();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->lookAt(target, relativeTo, localDirectionVector);
+            this->client_orientation_ = this->node_->getOrientation();
+        }
+    }
+
+    void ControllableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    {
+        if (Core::isMaster())
+        {
+            this->node_->setDirection(direction, relativeTo, localDirectionVector);
+            this->server_orientation_ = this->node_->getOrientation();
+            ++this->server_overwrite_;
+        }
+        else if (this->bControlled_)
+        {
+            this->node_->setDirection(direction, relativeTo, localDirectionVector);
+            this->client_orientation_ = this->node_->getOrientation();
+        }
+    }
+}
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.h	(revision 1989)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/ControllableEntity.h	(revision 1989)
@@ -0,0 +1,144 @@
+/*
+ *   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 _ControllableEntity_H__
+#define _ControllableEntity_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "WorldEntity.h"
+#include "objects/Tickable.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport ControllableEntity : public WorldEntity, public Tickable
+    {
+        public:
+            ControllableEntity();
+            virtual ~ControllableEntity();
+
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void tick(float dt);
+            void registerVariables();
+
+            virtual void setPlayer(PlayerInfo* player);
+            virtual void removePlayer();
+            inline PlayerInfo* getPlayer() const
+                { return this->player_; }
+
+            virtual void startLocalControl();
+            virtual void stopLocalControl();
+
+            virtual void moveFrontBack(float value) {}
+            virtual void moveRightLeft(float value) {}
+            virtual void moveUpDown(float value) {}
+
+            virtual void rotateYaw(float value) {}
+            virtual void rotatePitch(float value) {}
+            virtual void rotateRoll(float value) {}
+
+            virtual void fire() {}
+            virtual void altFire() {}
+
+            virtual void greet() {}
+            virtual void use() {}
+            virtual void switchCamera() {}
+
+        protected:
+            using WorldEntity::setPosition;
+            using WorldEntity::translate;
+            using WorldEntity::setOrientation;
+            using WorldEntity::rotate;
+            using WorldEntity::lookAt;
+            using WorldEntity::setDirection;
+
+            void setPosition(const Vector3& position);
+            void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void setOrientation(const Quaternion& orientation);
+            void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+
+            void setVelocity(const Vector3& velocity);
+            inline void setVelocity(float x, float y, float z)
+                { this->velocity_.x = x; this->velocity_.y = y; this->velocity_.z = z; }
+            inline const Vector3& getVelocity() const
+                { return this->velocity_; }
+
+            inline void setAcceleration(const Vector3& acceleration)
+                { this->acceleration_ = acceleration; }
+            inline void setAcceleration(float x, float y, float z)
+                { this->acceleration_.x = x; this->acceleration_.y = y; this->acceleration_.z = z; }
+            inline const Vector3& getAcceleration() const
+                { return this->acceleration_; }
+
+        private:
+            inline void setHudTemplate(const std::string& name)
+                { this->hudtemplate_ = name; }
+            inline const std::string& getHudTemplate() const
+                { return this->hudtemplate_; }
+
+            void overwrite();
+            void processOverwrite();
+
+            void processServerPosition();
+            void processServerVelocity();
+            void processServerOrientation();
+
+            void processClientPosition();
+            void processClientVelocity();
+            void processClientOrientation();
+
+            void updatePlayer();
+
+            unsigned int server_overwrite_;
+            unsigned int client_overwrite_;
+
+            Vector3 velocity_;
+            Vector3 acceleration_;
+
+            bool bControlled_;
+            Vector3 server_position_;
+            Vector3 client_position_;
+            Vector3 server_velocity_;
+            Vector3 client_velocity_;
+            Quaternion server_orientation_;
+            Quaternion client_orientation_;
+
+            PlayerInfo* player_;
+            unsigned int playerID_;
+            std::string hudtemplate_;
+            OverlayGroup* hud_;
+            Camera* camera_;
+    };
+}
+
+#endif /* _ControllableEntity_H__ */
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.cc	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.cc	(revision 1989)
@@ -44,4 +44,13 @@
         RegisterObject(MovableEntity);
 
+        this->velocity_ = Vector3::ZERO;
+        this->acceleration_ = Vector3::ZERO;
+        this->rotationAxis_ = Vector3::ZERO;
+        this->rotationRate_ = 0;
+        this->momentum_ = 0;
+
+        this->overwrite_position_ = Vector3::ZERO;
+        this->overwrite_orientation_ = Quaternion::IDENTITY;
+
         this->registerVariables();
     }
@@ -57,5 +66,5 @@
         XMLPortParamTemplate(MovableEntity, "velocity", setVelocity, getVelocity, xmlelement, mode, const Vector3&);
         XMLPortParamTemplate(MovableEntity, "rotationaxis", setRotationAxis, getRotationAxis, xmlelement, mode, const Vector3&);
-        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Radian&);
+        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Degree&);
     }
 
@@ -139,5 +148,5 @@
     }
 
-    void MovableEntity::yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->yaw(angle, relativeTo);
@@ -145,5 +154,5 @@
     }
 
-    void MovableEntity::pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->pitch(angle, relativeTo);
@@ -151,5 +160,5 @@
     }
 
-    void MovableEntity::roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->roll(angle, relativeTo);
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.h	(revision 1989)
@@ -59,7 +59,7 @@
             void setOrientation(const Quaternion& orientation);
             void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
             void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
             void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
@@ -86,16 +86,16 @@
                 { return this->rotationAxis_; }
 
+            inline void setRotationRate(const Degree& angle)
+                { this->rotationRate_ = angle; }
             inline void setRotationRate(const Radian& angle)
                 { this->rotationRate_ = angle; }
-            inline void setRotationRate(const Degree& angle)
-                { this->rotationRate_ = angle; }
-            inline const Radian& getRotationRate() const
+            inline const Degree& getRotationRate() const
                 { return this->rotationRate_; }
 
+            inline void setMomentum(const Degree& angle)
+                { this->momentum_ = angle; }
             inline void setMomentum(const Radian& angle)
                 { this->momentum_ = angle; }
-            inline void setMomentum(const Degree& angle)
-                { this->momentum_ = angle; }
-            inline const Radian& getMomentum() const
+            inline const Degree& getMomentum() const
                 { return this->momentum_; }
 
@@ -111,6 +111,6 @@
             Vector3 acceleration_;
             Vector3 rotationAxis_;
-            Radian rotationRate_;
-            Radian momentum_;
+            Degree rotationRate_;
+            Degree momentum_;
 
             Vector3 overwrite_position_;
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h	(revision 1989)
@@ -58,9 +58,9 @@
             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)
+            inline void yaw(const Degree& 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)
+            inline void pitch(const Degree& 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)
+            inline void roll(const Degree& 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)
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 1989)
@@ -39,4 +39,11 @@
 namespace orxonox
 {
+    const Vector3 WorldEntity::FRONT = Vector3::NEGATIVE_UNIT_Z;
+    const Vector3 WorldEntity::BACK  = Vector3::UNIT_Z;
+    const Vector3 WorldEntity::LEFT  = Vector3::NEGATIVE_UNIT_X;
+    const Vector3 WorldEntity::RIGHT = Vector3::UNIT_X;
+    const Vector3 WorldEntity::DOWN  = Vector3::NEGATIVE_UNIT_Y;
+    const Vector3 WorldEntity::UP    = Vector3::UNIT_Y;
+
     WorldEntity::WorldEntity()
     {
@@ -46,4 +53,7 @@
         this->parent_ = 0;
         this->parentID_ = (unsigned int)-1;
+
+        this->node_->setPosition(Vector3::ZERO);
+        this->node_->setOrientation(Quaternion::IDENTITY);
 
         this->registerVariables();
Index: code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h
===================================================================
--- code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h	(revision 1970)
+++ code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h	(revision 1989)
@@ -54,4 +54,11 @@
                 { return this->node_; }
 
+            static const Vector3 FRONT;
+            static const Vector3 BACK;
+            static const Vector3 LEFT;
+            static const Vector3 RIGHT;
+            static const Vector3 DOWN;
+            static const Vector3 UP;
+
             virtual void setPosition(const Vector3& position) = 0;
             inline void setPosition(float x, float y, float z)
@@ -71,4 +78,6 @@
             inline void setOrientation(const Vector3& axis, const Radian& angle)
                 { this->setOrientation(Quaternion(angle, axis)); }
+            inline void setOrientation(const Vector3& axis, const Degree& angle)
+                { this->setOrientation(Quaternion(angle, axis)); }
             inline const Quaternion& getOrientation() const
                 { return this->node_->getOrientation(); }
@@ -77,10 +86,18 @@
 
             virtual void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void rotate(const Vector3& axis, const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->rotate(Quaternion(angle, axis), relativeTo); }
             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 yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->yaw(Degree(angle), relativeTo); }
+            virtual void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->pitch(Degree(angle), relativeTo); }
+            virtual void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->roll(Degree(angle), relativeTo); }
 
             virtual void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z) = 0;
@@ -131,9 +148,9 @@
             inline void setDirection_xmlport(const Vector3& direction)
                 { this->setDirection(direction); }
-            inline void yaw_xmlport(const Radian& angle)
+            inline void yaw_xmlport(const Degree& angle)
                 { this->yaw(angle); }
-            inline void pitch_xmlport(const Radian& angle)
+            inline void pitch_xmlport(const Degree& angle)
                 { this->pitch(angle); }
-            inline void roll_xmlport(const Radian& angle)
+            inline void roll_xmlport(const Degree& angle)
                 { this->roll(angle); }
 
