Index: /code/branches/physics/src/orxonox/objects/Scene.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/Scene.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/Scene.cc	(revision 2292)
@@ -39,4 +39,8 @@
 #include "core/XMLPort.h"
 
+#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+
 namespace orxonox
 {
@@ -70,25 +74,6 @@
         }
 
-        /////////////
-        // Physics //
-        /////////////
-
-        // create bullet world; bullet solver etc.
-
-        // int maxProxies = 1024;
-
-        btVector3 worldAabbMin(-10000,-10000,-10000);
-        btVector3 worldAabbMax(10000,10000,10000);
-        bt32BitAxisSweep3* broadphase = new bt32BitAxisSweep3(worldAabbMin,worldAabbMax);
-
-        this -> collisionConfiguration_ = new btDefaultCollisionConfiguration();
-        this -> dispatcher_ = new btCollisionDispatcher(collisionConfiguration_);
-
-        this -> solver_ = new btSequentialImpulseConstraintSolver;
-
-        this -> dynamicsWorld_ =  new btDiscreteDynamicsWorld(dispatcher_,broadphase,solver_,collisionConfiguration_);
-
-        dynamicsWorld_->setGravity(btVector3(0,-10,0));
-
+        // No physics for default
+        this->physicalWorld_ = 0;
 
         // test test test
@@ -130,4 +115,11 @@
         XMLPortParam(Scene, "shadow", setShadow, getShadow, xmlelement, mode).defaultValues(true);
 
+        const int defaultMaxWorldSize = 100000;
+        Vector3 worldAabbMin(-defaultMaxWorldSize, -defaultMaxWorldSize, -defaultMaxWorldSize);
+        Vector3 worldAabbMax( defaultMaxWorldSize,  defaultMaxWorldSize,  defaultMaxWorldSize);
+        XMLPortParamVariable(Scene, "negativeWorldRange", worldAabbMin, xmlelement, mode);
+        XMLPortParamVariable(Scene, "positiveWorldRange", worldAabbMax, xmlelement, mode);
+        XMLPortParam(Scene, "hasPhysics", setPhysicalWorld, hasPhysics, xmlelement, mode).defaultValue(0, true).defaultValue(1, worldAabbMin).defaultValue(2, worldAabbMax);
+
         XMLPortObjectExtended(Scene, BaseObject, "", addObject, getObject, xmlelement, mode, true, false);
     }
@@ -137,4 +129,34 @@
         REGISTERSTRING(this->skybox_,     network::direction::toclient, new network::NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
         REGISTERDATA(this->ambientLight_, network::direction::toclient, new network::NetworkCallback<Scene>(this, &Scene::networkcallback_applyAmbientLight));
+    }
+
+    void Scene::setPhysicalWorld(bool wantPhysics, const Vector3& worldAabbMin, const Vector3& worldAabbMax)
+    {
+        if (wantPhysics && !hasPhysics())
+        {
+            btVector3 worldAabbMin(worldAabbMin.x, worldAabbMin.y, worldAabbMin.z);
+            btVector3 worldAabbMax(worldAabbMax.x, worldAabbMax.y, worldAabbMax.z);
+
+            btDefaultCollisionConfiguration*     collisionConfig = new btDefaultCollisionConfiguration();
+            btCollisionDispatcher*               dispatcher      = new btCollisionDispatcher(collisionConfig);
+            bt32BitAxisSweep3*                   broadphase      = new bt32BitAxisSweep3(worldAabbMin,worldAabbMax);
+            btSequentialImpulseConstraintSolver* solver          = new btSequentialImpulseConstraintSolver;
+
+            this->physicalWorld_ =  new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfig);
+
+            // test test test
+            this->physicalWorld_->setGravity(btVector3(0,0,0));
+            // test test test
+        }
+        else
+        {
+            // TODO: Destroy Bullet physics
+        }
+    }
+
+    void Scene::tick(float dt)
+    {
+        if (physicalWorld_)
+            physicalWorld_->stepSimulation(dt,10);
     }
 
Index: /code/branches/physics/src/orxonox/objects/Scene.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/Scene.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/Scene.h	(revision 2292)
@@ -35,10 +35,11 @@
 #include "core/BaseObject.h"
 #include "util/Math.h"
+#include "objects/Tickable.h"
 
-#include "ogrebullet/Dynamics/OgreBulletDynamics.h"
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Scene : public BaseObject, public network::Synchronisable
+    class _OrxonoxExport Scene : public BaseObject, public network::Synchronisable, public Tickable
     {
         public:
@@ -55,5 +56,5 @@
 
             inline btDiscreteDynamicsWorld* getPhysicalWorld() const
-                { return this->dynamicsWorld_; }
+                { return this->physicalWorld_; }
 
             void setSkybox(const std::string& skybox);
@@ -69,4 +70,15 @@
                 { return this->bShadows_; }
 
+            inline const Vector3& getWorldAabbMax()
+            {
+                this->physicalWorld_->getBroadphase();
+            }
+
+            inline bool hasPhysics()
+                { return this->physicalWorld_ != 0; }
+            void setPhysicalWorld(bool wantsPhysics, const Vector3& worldAabbMin, const Vector3& worldAabbMax);
+
+            void tick(float dt);
+
         private:
             void addObject(BaseObject* object);
@@ -81,9 +93,5 @@
             Ogre::SceneNode*       rootSceneNode_;
 
-	    btDiscreteDynamicsWorld* dynamicsWorld_;
-	    btSequentialImpulseConstraintSolver* solver_;
-	    btDefaultCollisionConfiguration* collisionConfiguration_;
-	    btCollisionDispatcher* dispatcher_; 
-	    // Point auf Bullet btDynamics world && solver
+            btDiscreteDynamicsWorld* physicalWorld_;
 
             std::string            skybox_;
Index: /code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.cc	(revision 2292)
@@ -229,6 +229,9 @@
         if (this->isActive())
         {
-            this->velocity_ += (dt * this->acceleration_);
-            this->node_->translate(dt * this->velocity_, Ogre::Node::TS_LOCAL);
+            if (!this->isDynamic())
+            {
+                this->velocity_ += (dt * this->acceleration_);
+                this->node_->translate(dt * this->velocity_, Ogre::Node::TS_LOCAL);
+            }
 
             if (Core::isMaster())
@@ -325,39 +328,8 @@
     }
 
-
-    // virtual void PositionChanged() { }
-    void ControllableEntity::positionChanged(const Vector3& position)
+    void ControllableEntity::positionChanged()
     {
         if (Core::isMaster())
         {
-            this->server_position_ = this->getPosition();
-            ++this->server_overwrite_;
-        }
-        else if (this->bControlled_)
-        {
-            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;
-        }
-    }
-    // virtual void translateChanged() { }
-    void ControllableEntity::translateChanged(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (Core::isMaster())
-        {
-            this->node_->translate(distance, relativeTo);
             this->server_position_ = this->node_->getPosition();
             ++this->server_overwrite_;
@@ -365,29 +337,12 @@
         else if (this->bControlled_)
         {
-            this->node_->translate(distance, relativeTo);
             this->client_position_ = this->node_->getPosition();
         }
     }
-    // virtual void orientationChanged() { }
-    void ControllableEntity::orientationChanged(const Quaternion& orientation)
+
+    void ControllableEntity::orientationChanged()
     {
         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;
-        }
-    }
-    // virtual void rotateChanged() { }
-    void ControllableEntity::rotateChanged(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (Core::isMaster())
-        {
-            this->node_->rotate(rotation, relativeTo);
             this->server_orientation_ = this->node_->getOrientation();
             ++this->server_overwrite_;
@@ -395,81 +350,35 @@
         else if (this->bControlled_)
         {
-            this->node_->rotate(rotation, relativeTo);
             this->client_orientation_ = this->node_->getOrientation();
         }
     }
-    // virtual void yawChanged() { }
-    void ControllableEntity::yawChanged(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+
+    void ControllableEntity::velocityChanged()
     {
         if (Core::isMaster())
         {
-            this->node_->yaw(angle, relativeTo);
-            this->server_orientation_ = this->node_->getOrientation();
+            this->server_velocity_ = this->velocity_;
             ++this->server_overwrite_;
         }
         else if (this->bControlled_)
         {
-            this->node_->yaw(angle, relativeTo);
-            this->client_orientation_ = this->node_->getOrientation();
-        }
-    }
-    // virtual void pitchChanged() { }
-    void ControllableEntity::pitchChanged(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();
-        }
-    }
-    // virtual void rollChanged() { }
-    void ControllableEntity::rollChanged(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();
-        }
-    }
-    //virtual void lookAtChanged() { }
-    void ControllableEntity::lookAtChanged(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();
-        }
-    }
-    // virtual void directionChanged( ) { }
-    void ControllableEntity::directionChanged(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();
+            this->client_velocity_ = this->velocity_;
+        }
+    }
+
+    void ControllableEntity::setVelocity(const Vector3& velocity)
+    {
+        if (this->bControlled_ || Core::isMaster())
+        {
+            if (!this->isDynamic())
+            {
+                // no physics, we do it ourselves
+                internalSetVelocity(velocity);
+            }
+            else
+            {
+                this->physicalBody_->setLinearVelocity(btVector3(velocity.x, velocity.y, velocity.z));
+            }
+            velocityChanged();
         }
     }
Index: /code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/ControllableEntity.h	(revision 2292)
@@ -79,17 +79,7 @@
                 { return this->hudtemplate_; }
 
-            void setPosition();
-            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; }
+                { setVelocity(Vector3(x,y,z)); }
 
             inline void setAcceleration(const Vector3& acceleration)
@@ -137,4 +127,10 @@
             void processClientOrientation();
 
+            inline void internalSetVelocity(const Vector3& velocity)
+                { this->velocity_ = velocity; }
+            void positionChanged();
+            void orientationChanged();
+            void velocityChanged();
+
             void networkcallback_changedplayerID();
 
Index: /code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.cc	(revision 2292)
@@ -74,9 +74,13 @@
         if (this->isActive())
         {
-            this->velocity_ += (dt * this->acceleration_);
-            this->node_->translate(dt * this->velocity_);
+            if (!this->isDynamic())
+            {
+                // we have to do 'physics' ourselves.
+                this->velocity_ += (dt * this->acceleration_);
+                this->node_->translate(dt * this->velocity_);
 
-            this->rotationRate_ += (dt * this->momentum_);
-            this->node_->rotate(this->rotationAxis_, this->rotationRate_  * dt);
+                this->rotationRate_ += (dt * this->momentum_);
+                this->node_->rotate(this->rotationAxis_, this->rotationRate_  * dt);
+            }
         }
     }
@@ -123,56 +127,25 @@
     }
 
-    void LinearEntity::setPosition(const Vector3& position)
+    void LinearEntity::positionChanged()
     {
-        this->node_->setPosition(position);
-        this->overwrite_position_ = this->node_->getPosition();
+        this->overwrite_position_  = this->node_->getPosition();
     }
 
-    void LinearEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
+    void LinearEntity::orientationChanged()
     {
-        this->node_->translate(distance, relativeTo);
-        this->overwrite_position_ = this->node_->getPosition();
+        this->overwrite_orientation_  = this->node_->getOrientation();
     }
 
-    void LinearEntity::setOrientation(const Quaternion& orientation)
+    void LinearEntity::setVelocity(const Vector3& velocity)
     {
-        this->node_->setOrientation(orientation);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void LinearEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->rotate(rotation, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void LinearEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->yaw(angle, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void LinearEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->pitch(angle, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void LinearEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->roll(angle, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void LinearEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        this->node_->lookAt(target, relativeTo, localDirectionVector);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void LinearEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        this->node_->setDirection(direction, relativeTo, localDirectionVector);
-        this->overwrite_orientation_ = this->node_->getOrientation();
+        if (!this->isDynamic())
+        {
+            // no physics, we do it ourselves
+            internalSetVelocity(velocity);
+        }
+        else
+        {
+            this->physicalBody_->setLinearVelocity(btVector3(velocity.x, velocity.y, velocity.z));
+        }
     }
 }
Index: /code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.h	(revision 2292)
@@ -38,5 +38,5 @@
 namespace orxonox
 {
-    class _OrxonoxExport LinearEntity : public MovableEntity, public network::ClientConnectionListener
+    class _OrxonoxExport LinearEntity : public MovableEntity, public network::ClientConnectionListener, public Tickable
     {
         public:
@@ -48,26 +48,5 @@
             void registerVariables();
 
-            using WorldEntity::setPosition;
-            using WorldEntity::translate;
-            using WorldEntity::setOrientation;
-            using WorldEntity::rotate;
-            using WorldEntity::yaw;
-            using WorldEntity::pitch;
-            using WorldEntity::roll;
-            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);
-
-            inline void setVelocity(const Vector3& velocity)
-                { this->velocity_ = velocity; }
+            inline 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; }
@@ -111,4 +90,9 @@
             void overwriteOrientation();
 
+            void positionChanged();
+            void orientationChanged();
+            inline void internalSetVelocity(const Vector3& velocity)
+                { this->velocity_ = velocity; }
+
             Vector3 velocity_;
             Vector3 acceleration_;
Index: /code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.cc	(revision 2292)
@@ -30,8 +30,9 @@
 #include "MovableEntity.h"
 
-#include "objects/Scene.h"
-
+#include "util/Exception.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+
+#include "objects/Scene.h"
 
 namespace orxonox
@@ -57,85 +58,265 @@
     }
 
-    void MovableEntity::setPosition(const Vector3& position){
-	// Here the code
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->setPosition(position);
+    //void MovableEntity::setPosition(const Vector3& position)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->setPosition(position);
+    //    positionChanged();
+    //}
+
+    //void MovableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->translate(distance, relativeTo); 
+    //    positionChanged();
+    //}
+
+    //void MovableEntity::setOrientation(const Quaternion& orientation)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->setOrientation(orientation);
+    //    orientationChanged();
+    //}
+
+    //void MovableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->rotate(rotation, relativeTo);
+    //    orientationChanged();
+    //}
+
+    //void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->yaw(angle, relativeTo);
+    //    orientationChanged();
+    //}
+
+    //void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->pitch(angle, relativeTo);
+    //    orientationChanged();
+    //}
+
+    //void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->roll(angle, relativeTo);
+    //    orientationChanged();
+    //}
+
+    //void MovableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->lookAt(target, relativeTo, localDirectionVector); 
+    //    orientationChanged();
+    //}
+
+    //void MovableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    //{
+    //    //if (isDynamic() && bAddedToPhysicalWorld_)
+    //    //{
+    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+    //    //}
+    //    this->node_->setDirection(direction, relativeTo, localDirectionVector); 
+    //    orientationChanged();
+    //}
+
+    void MovableEntity::setPosition(const Vector3& position)
+    {
+        if (this->isDynamic())
+        {
+            btTransform transf = this->physicalBody_->getWorldTransform();
+            transf.setOrigin(btVector3(position.x, position.y, position.z));
+            this->physicalBody_->setWorldTransform(transf);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->setPosition(position);
+        }
+    }
+
+    void MovableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (this->isDynamic())
+        {
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot translate physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            this->physicalBody_->translate(btVector3(distance.x, distance.y, distance.z));
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->translate(distance, relativeTo);
+        }
+    }
+
+    void MovableEntity::setOrientation(const Quaternion& orientation)
+    {
+        if (this->isDynamic())
+        {
+            btTransform transf = this->physicalBody_->getWorldTransform();
+            transf.setRotation(btQuaternion(orientation.w, orientation.x, orientation.y, orientation.z));
+            this->physicalBody_->setWorldTransform(transf);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->setOrientation(orientation);
+        }
+    }
+
+    void MovableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (this->isDynamic())
+        {
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot rotate physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            btTransform transf = this->physicalBody_->getWorldTransform();
+            this->physicalBody_->setWorldTransform(transf * btTransform(btQuaternion(rotation.w, rotation.x, rotation.y, rotation.z)));
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->rotate(rotation, relativeTo);
+        }
+    }
+
+    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (this->isDynamic())
+        {
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot yaw physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            btTransform transf = this->physicalBody_->getWorldTransform();
+            btTransform rotation(btQuaternion(angle.valueRadians(), 0.0f, 0.0f));
+            this->physicalBody_->setWorldTransform(transf * rotation);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->yaw(angle, relativeTo);
+        }
+    }
+
+    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (this->isDynamic())
+        {
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot pitch physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            btTransform transf = this->physicalBody_->getWorldTransform();
+            btTransform rotation(btQuaternion(0.0f, angle.valueRadians(), 0.0f));
+            this->physicalBody_->setWorldTransform(transf * rotation);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->pitch(angle, relativeTo);
+        }
+    }
+
+    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
+    {
+        if (this->isDynamic())
+        {
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot roll physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            btTransform transf = this->physicalBody_->getWorldTransform();
+            btTransform rotation(btQuaternion(angle.valueRadians(), 0.0f, 0.0f));
+            this->physicalBody_->setWorldTransform(transf * rotation);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->roll(angle, relativeTo);
+        }
+    }
+
+    void MovableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    {
+        if (this->isDynamic())
+        {
+            ThrowException(NotImplemented, "ControllableEntity::lookAt() is not yet supported for physical objects.");
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            //btTransform transf = this->physicalBody_->getWorldTransform();
+            //this->physicalBody_->setWorldTransform(transf);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->lookAt(target, relativeTo, localDirectionVector);
+        }
+    }
+
+    void MovableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
+    {
+        if (this->isDynamic())
+        {
+            ThrowException(NotImplemented, "ControllableEntity::lookAt() is not yet supported for physical objects.");
+            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
+                                                          to any other space than TS_LOCAL.");
+            //btTransform transf = this->physicalBody_->getWorldTransform();
+            //this->physicalBody_->setWorldTransform(transf);
+        }
+        else
+        {
+            // no physics, we do it ourselves
+            this->node_->setDirection(direction, relativeTo, localDirectionVector);
+        }
+    }
+
+    void MovableEntity::setWorldTransform(const btTransform& worldTrans)
+    {
+        // We use a dynamic body. So we translate our node accordingly.
+        this->node_->setPosition(Vector3(worldTrans.getOrigin().x(), worldTrans.getOrigin().y(), worldTrans.getOrigin().z()));
+        this->node_->setOrientation(Quaternion(worldTrans.getRotation().w(), worldTrans.getRotation().x(), worldTrans.getRotation().y(), worldTrans.getRotation().z()));
+        const btVector3& velocity = this->physicalBody_->getLinearVelocity();
+        internalSetVelocity(Vector3(velocity.x(), velocity.y(), velocity.z()));
         positionChanged();
-    }
-
-    void MovableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->translate(distance, relativeTo); 
-        translateChanged();
-    }
-
-    void MovableEntity::setOrientation(const Quaternion& orientation){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->setOrientation(orientation);
         orientationChanged();
     }
 
-    void MovableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->rotate(rotation, relativeTo);
-        rotateChanged();
-    }
-
-    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->yaw(angle, relativeTo);
-        yawChanged();
-    }
-
-    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->pitch(angle, relativeTo);
-        pitchChanged();
-    }
-
-    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->roll(angle, relativeTo);
-        rollChanged();
-    }
-
-    void MovableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->lookAt(target, relativeTo, localDirectionVector); 
-        lookAtChanged();
-    }
-
-    void MovableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector){
-        if(isDynamic() && bAddedToPhysicalWorld_){
-            this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        }
-        this->node_->setDirection(direction, relativeTo, localDirectionVector); 
-        directionChanged();
-    }
-
+    void MovableEntity::getWorldTransform(btTransform& worldTrans) const
+    {
+        // We use a kinematic body 
+        worldTrans.setOrigin(btVector3(node_->getPosition().x, node_->getPosition().y, node_->getPosition().z));
+        worldTrans.setRotation(btQuaternion(node_->getOrientation().w, node_->getOrientation().x, node_->getOrientation().y, node_->getOrientation().z));
+    }
 }
Index: /code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/MovableEntity.h	(revision 2292)
@@ -69,31 +69,13 @@
 
         private:
-
-            virtual void rollChanged() { }
-            virtual void positionChanged() { }
-            virtual void translateChanged() { }
-            virtual void orientationChanged() { }
-            virtual void rotateChanged() { }
-            virtual void yawChanged() { }
-            virtual void pitchChanged() { }
-            virtual void lookAtChanged() { }
-            virtual void directionChanged( ) { }
-
             //void attachPhysicalObject(WorldEntity* object);
 
-            //// Bullet btMotionState related
-            //void setWorldTransform(const btTransform& worldTrans)
-            //{
-            //    this->node_->setPosition(worldTrans.getOrigin().x(), worldTrans.getOrigin().y(), worldTrans.getOrigin().z());
-            //    this->node_->setOrientation(worldTrans.getRotation().w(), worldTrans.getRotation().x(), worldTrans.getRotation().y(), worldTrans.getRotation().z());
-            //    //this->velocity_.x = this->physicalBody_->
-            //}
+            virtual void internalSetVelocity(const Vector3& velocity) { }
+            virtual void positionChanged() { }
+            virtual void orientationChanged() { }
 
-            //// Bullet btMotionState related
-            //void getWorldTransform(btTransform& worldTrans) const
-            //{
-            //    worldTrans.setOrigin(btVector3(node_->getPosition().x, node_->getPosition().y, node_->getPosition().z));
-            //    worldTrans.setRotation(btQuaternion(node_->getOrientation().w, node_->getOrientation().x, node_->getOrientation().y, node_->getOrientation().z));
-            //}
+            // Bullet btMotionState related
+            void setWorldTransform(const btTransform& worldTrans);
+            void getWorldTransform(btTransform& worldTrans) const;
     };
 }
Index: /code/branches/physics/src/orxonox/objects/worldentities/PositionableEntity.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/PositionableEntity.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/PositionableEntity.h	(revision 2292)
@@ -43,33 +43,4 @@
             void registerVariables();
 
-            using WorldEntity::setPosition;
-            using WorldEntity::translate;
-            using WorldEntity::setOrientation;
-            using WorldEntity::rotate;
-            using WorldEntity::yaw;
-            using WorldEntity::pitch;
-            using WorldEntity::roll;
-            using WorldEntity::lookAt;
-            using WorldEntity::setDirection;
-
-            inline void setPosition(const Vector3& position)
-                { this->node_->setPosition(position); }
-            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 Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
-                { this->node_->yaw(angle, relativeTo); }
-            inline void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
-                { this->node_->pitch(angle, relativeTo); }
-            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)
-                { 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); }
-
         private:
             //void attachPhysicalObject(WorldEntity* object);
Index: /code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc	(revision 2292)
@@ -29,4 +29,6 @@
 #include "OrxonoxStableHeaders.h"
 #include "StaticEntity.h"
+
+#include "util/Exception.h"
 #include "core/CoreIncludes.h"
 
@@ -57,3 +59,25 @@
         REGISTERDATA(this->getOrientation().z, network::direction::toclient);
     }
+
+    void StaticEntity::setCollisionType(CollisionType type)
+    {
+        if (!this->physicalBody_)
+            return;
+        if (type != Static)
+            ThrowException(Argument, "Cannot tell a StaticEntity to be kinematic or dynamic");
+
+        this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT | btCollisionObject::CF_STATIC_OBJECT);
+    }
+
+    void StaticEntity::setWorldTransform(const btTransform& worldTrans)
+    {
+        OrxAssert(false, "Setting world transform of a StaticEntity, which is static!");
+        //COUT(0) << "Setting world transform of a StaticEntity, which is static!" << std::endl;
+    }
+
+    void StaticEntity::getWorldTransform(btTransform& worldTrans) const
+    {
+        worldTrans.setOrigin(btVector3(node_->getPosition().x, node_->getPosition().y, node_->getPosition().z));
+        worldTrans.setRotation(btQuaternion(node_->getOrientation().w, node_->getOrientation().x, node_->getOrientation().y, node_->getOrientation().z));
+    }
 }
Index: /code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h	(revision 2292)
@@ -71,4 +71,12 @@
             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); }
+
+        private:
+
+            void setCollisionType(CollisionType type);
+
+            // Bullet btMotionState related
+            void setWorldTransform(const btTransform& worldTrans);
+            void getWorldTransform(btTransform& worldTrans) const;
     };
 }
Index: /code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2292)
@@ -32,11 +32,15 @@
 #include <cassert>
 #include <OgreSceneManager.h>
+
 #include "BulletCollision/CollisionShapes/btSphereShape.h"
 
+#include "util/Exception.h"
+#include "util/Convert.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
-#include "util/Convert.h"
 
 #include "objects/Scene.h"
+
+#include "StaticEntity.h"
 
 namespace orxonox
@@ -65,5 +69,4 @@
 
         // Default behaviour does not include physics
-        this->bAddedToPhysicalWorld_ = false;
         this->physicalBody_ = 0;
 
@@ -82,5 +85,5 @@
             if (this->physicalBody_)
             {
-                if (this->bAddedToPhysicalWorld_)
+                if (this->physicalBody_->isInWorld())
                     this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
                 if (this->physicalBody_->getCollisionShape())
@@ -104,5 +107,11 @@
         XMLPortParamTemplate(WorldEntity, "scale3D", setScale3D, getScale3D, xmlelement, mode, const Vector3&);
         XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
-        XMLPortParam(WorldEntity, "collisionRadius", setcollisionRadius, getcollisionRadius, xmlelement, mode);
+
+        XMLPortParam(WorldEntity, "collisionRadius", setCollisionRadius, getCollisionRadius, xmlelement, mode);
+        XMLPortParam(WorldEntity, "collisionType", setCollisionTypeStr, getCollisionTypeStr, xmlelement, mode);
+        XMLPortParam(WorldEntity, "mass", setMass, getMass, xmlelement, mode);
+
+        if (this->physicalBody_)
+            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
 
         XMLPortObject(WorldEntity, WorldEntity, "attached", attach, getAttachedObject, xmlelement, mode);
@@ -145,24 +154,27 @@
 
         // Do the physical connection if required
-        this->attachPhysicalObject(object);
-    }
-
-    void WorldEntitiy::attachPhysicalObject(WorldEntity* object){
-    //function attachhysicalObject
-        StaticEntity* staticObject = dynamic_cast<WorldEntity*>(object);
-        if (staticObject != 0 && hasPhysics()){
-           btCompountShape* compoundShape = dynamic_cast<btCompoundShape*>(physicalBody_->getCollisionShape());
-           if(compoundShape == 0){
-                //NEW
-                btCompoundShape* newShape = new btCompoundShape();
-                newShape->addChildShape(this->physcialBody_->getCollisionShape());
-                newShape->addChildShape(staticObject->getCollisionShape());
-                this->physicalBody_->setCollisionShape();
-           }
-           else{
-               compoundShape -> addChildShape(staticObject->getCollisionShape());
-           }
-        }
-    }
+        //this->attachPhysicalObject(object);
+    }
+
+    //void WorldEntity::attachPhysicalObject(WorldEntity* object)
+    //{
+    //    StaticEntity* staticObject = dynamic_cast<StaticEntity*>(object);
+    //    if (staticObject != 0 && this->hasPhysics())
+    //    {
+    //       btCompoundShape* compoundShape = dynamic_cast<btCompoundShape*>(this->physicalBody_->getCollisionShape());
+    //       if (compoundShape == 0)
+    //       {
+    //            // create a compound shape and add both
+    //            compoundShape = new btCompoundShape();
+    //            compoundShape->addChildShape(this->physicalBody_->getCollisionShape());
+    //            compoundShape->addChildShape(staticObject->getCollisionShape());
+    //            this->physicalBody_->setCollisionShape();
+    //       }
+    //       else
+    //       {
+    //           compoundShape -> addChildShape(staticObject->getCollisionShape());
+    //       }
+    //    }
+    //}
 
     void WorldEntity::detach(WorldEntity* object)
@@ -193,14 +205,89 @@
         btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, 0, btVector3(0,0,0));
         this->physicalBody_ = new btRigidBody(bodyConstructionInfo);
-        this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-        this->bAddedToPhysicalWorld_ = true;
-    }
-
-    void WorldEntity::setcollisionRadius(float radius)
+    }
+
+    float WorldEntity::getMass()
+    {
+        if (!this->physicalBody_)
+            return 0.0f;
+
+        return 1.0f/this->physicalBody_->getInvMass();
+    }
+
+    void WorldEntity::setMass(float mass)
+    {
+        if (!this->physicalBody_)
+            this->createPhysicalBody();
+
+        this->physicalBody_->setMassProps(mass, btVector3(0,0,0));
+    }
+
+    void WorldEntity::setCollisionType(WorldEntity::CollisionType type)
+    {
+        if (!this->physicalBody_)
+            this->createPhysicalBody();
+
+        switch (type)
+        {
+        case Dynamic:
+            this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !(btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_KINEMATIC_OBJECT));
+            break;
+        case Kinematic:
+            this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_STATIC_OBJECT | btCollisionObject::CF_KINEMATIC_OBJECT);
+            break;
+        case Static:
+            this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT | btCollisionObject::CF_STATIC_OBJECT);
+            break;
+        }
+    }
+
+    WorldEntity::CollisionType WorldEntity::getCollisionType()
+    {
+        if (!this->physicalBody_)
+            ThrowException(Argument, "Cannot retrieve collision type of a non physical object.");
+
+        int flags = this->physicalBody_->getCollisionFlags();
+        if (flags & btCollisionObject::CF_STATIC_OBJECT)
+            return Static;
+        else if (flags & btCollisionObject::CF_KINEMATIC_OBJECT)
+            return Kinematic;
+        else
+            return Dynamic;
+    }
+
+    void WorldEntity::setCollisionTypeStr(const std::string& type)
+    {
+        std::string lower = getLowercase(type);
+        if (lower == "dynamic")
+            setCollisionType(Dynamic);
+        else if (lower == "static")
+            setCollisionType(Static);
+        else if (lower == "kinematic")
+            setCollisionType(Kinematic);
+        else
+            ThrowException(Argument, std::string("Trying to set an unknown collision type: '") + type + "'.");
+    }
+
+    std::string WorldEntity::getCollisionTypeStr()
+    {
+        switch (this->getCollisionType())
+        {
+        case Dynamic:
+            return "dynamic";
+        case Kinematic:
+            return "kinematic";
+        case Static:
+            return "static";
+        default:
+            ThrowException(Argument, "Encountered unknown collision Type.");
+        }
+    }
+
+    void WorldEntity::setCollisionRadius(float radius)
     {
         if (!this->physicalBody_)
             createPhysicalBody();
 
-        // destroy old onw first
+        // destroy old one first
         btCollisionShape* oldShape = this->physicalBody_->getCollisionShape();
         if (oldShape)
@@ -210,5 +297,5 @@
     }
 
-    float WorldEntity::getcollisionRadius()
+    float WorldEntity::getCollisionRadius()
     {
         if (this->physicalBody_)
Index: /code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2292)
@@ -46,4 +46,12 @@
     class _OrxonoxExport WorldEntity : public BaseObject, public network::Synchronisable, public btMotionState
     {
+        public:
+            enum CollisionType
+            {
+                Dynamic,
+                Kinematic,
+                Static
+            };
+
         public:
             WorldEntity(BaseObject* creator);
@@ -127,7 +135,4 @@
                 { this->node_->scale(scale, scale, scale); }
 
-            void setcollisionRadius(float radius);
-            float getcollisionRadius();
-
             bool hasPhysics()  { return this->physicalBody_; }
             bool isKinematic() { return this->physicalBody_ && this->physicalBody_->isKinematicObject(); }
@@ -147,12 +152,23 @@
                 { return this->parent_; }
 
+            void setCollisionRadius(float radius);
+            float getCollisionRadius();
+
+            void setCollisionTypeStr(const std::string& type);
+            std::string getCollisionTypeStr();
+
+            void setMass(float mass);
+            float getMass();
+
+            CollisionType getCollisionType();
+
         protected:
             //virtual btCollisionShape* getCollisionShape() = 0;
 
             void createPhysicalBody();
-            virtual void attachPhysicalObject(WorldEntity* object) { }
+            //virtual void attachPhysicalObject(WorldEntity* object);
+            virtual void setCollisionType(CollisionType type);
 
             Ogre::SceneNode* node_;
-            bool bAddedToPhysicalWorld_;
             btRigidBody* physicalBody_;
 
@@ -171,14 +187,4 @@
                 { this->roll(angle); }
 
-            // Bullet btMotionState related
-            virtual void setWorldTransform(const btTransform& worldTrans)
-            {
-            }
-
-            // Bullet btMotionState related
-            virtual void getWorldTransform(btTransform& worldTrans) const
-            {
-            }
-
             WorldEntity* parent_;
             unsigned int parentID_;
Index: /code/branches/physics/src/orxonox/objects/worldentities/pawns/SpaceShip.cc
===================================================================
--- /code/branches/physics/src/orxonox/objects/worldentities/pawns/SpaceShip.cc	(revision 2291)
+++ /code/branches/physics/src/orxonox/objects/worldentities/pawns/SpaceShip.cc	(revision 2292)
@@ -30,8 +30,9 @@
 #include "SpaceShip.h"
 
+#include "util/Math.h"
+#include "util/Exception.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/XMLPort.h"
-#include "util/Math.h"
 
 namespace orxonox
@@ -59,4 +60,8 @@
 
         this->setDestroyWhenPlayerLeft(true);
+
+        // create a phyisical body
+        OrxAssert(this->physicalBody_ == 0, " Check why there is already a physical body in the space ship.");
+        this->createPhysicalBody();
 
         this->setConfigValues();
@@ -165,15 +170,19 @@
     void SpaceShip::moveFrontBack(const Vector2& value)
     {
-        this->acceleration_.z = -this->translationAcceleration_ * value.x;
+        assert(this->physicalBody_);
+        this->physicalBody_->applyCentralForce(btVector3(0.0f, 0.0f, -1.0f/this->physicalBody_->getInvMass() * value.x));
+//        this->acceleration_.z = -this->translationAcceleration_ * value.x;
     }
 
     void SpaceShip::moveRightLeft(const Vector2& value)
     {
-        this->acceleration_.x = this->translationAcceleration_ * value.x;
+        this->physicalBody_->applyCentralForce(btVector3(1.0f/this->physicalBody_->getInvMass() * value.x, 0.0f, 0.0f));
+//        this->acceleration_.x = this->translationAcceleration_ * value.x;
     }
 
     void SpaceShip::moveUpDown(const Vector2& value)
     {
-        this->acceleration_.y = this->translationAcceleration_ * value.x;
+        this->physicalBody_->applyCentralForce(btVector3(0.0f, 1.0f/this->physicalBody_->getInvMass() * value.x, 0.0f));
+//        this->acceleration_.y = this->translationAcceleration_ * value.x;
     }
 
