Index: code/branches/presentation/src/orxonox/OrxonoxPrereqs.h
===================================================================
--- code/branches/presentation/src/orxonox/OrxonoxPrereqs.h	(revision 2559)
+++ code/branches/presentation/src/orxonox/OrxonoxPrereqs.h	(revision 2562)
@@ -203,4 +203,5 @@
     class CompoundCollisionShape;
     class PlaneCollisionShape;
+    class WorldEntityCollisionShape;
 
     // tools
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/CMakeLists.txt
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/CMakeLists.txt	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/CMakeLists.txt	(revision 2562)
@@ -6,4 +6,5 @@
   PlaneCollisionShape.cc
   SphereCollisionShape.cc
+  WorldEntityCollisionShape.cc
 )
 
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.cc	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.cc	(revision 2562)
@@ -37,6 +37,7 @@
 #include "tools/BulletConversions.h"
 
+#include "objects/worldentities/WorldEntity.h"
 #include "CompoundCollisionShape.h"
-#include "objects/worldentities/WorldEntity.h"
+#include "WorldEntityCollisionShape.h"
 
 namespace orxonox
@@ -85,7 +86,38 @@
     void CollisionShape::parentChanged()
     {
-        CompoundCollisionShape* parent = dynamic_cast<CompoundCollisionShape*>(Synchronisable::getSynchronisable(this->parentID_));
-        if (parent)
-            parent->attach(this);
+        Synchronisable* parent = Synchronisable::getSynchronisable(this->parentID_);
+        // Parent can either be a WorldEntity or a CompoundCollisionShape. The reason is that the
+        // internal collision shape (which is compound) of a WE doesn't get synchronised.
+        CompoundCollisionShape* parentCCS = dynamic_cast<CompoundCollisionShape*>(parent);
+        if (parentCCS)
+            parentCCS->attach(this);
+        else
+        {
+            WorldEntity* parentWE = dynamic_cast<WorldEntity*>(parent);
+            if (parentWE)
+                parentWE->attachCollisionShape(this);
+        }
+    }
+
+    bool CollisionShape::notifyBeingAttached(CompoundCollisionShape* newParent)
+    {
+        if (this->parent_)
+            this->parent_->detach(this);
+
+        this->parent_ = newParent;
+
+        WorldEntityCollisionShape* parentWECCS = dynamic_cast<WorldEntityCollisionShape*>(newParent);
+        if (parentWECCS)
+            this->parentID_ = parentWECCS->getWorldEntityOwner()->getObjectID();
+        else
+            this->parentID_ = newParent->getObjectID();
+
+        return true;
+    }
+
+    void CollisionShape::notifyDetached()
+    {
+        this->parent_ = 0;
+        this->parentID_ = OBJECTID_UNKNOWN;
     }
 
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.h	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.h	(revision 2562)
@@ -75,6 +75,6 @@
             bool hasTransform() const;
 
-            inline void setParent(CompoundCollisionShape* shape, unsigned int ID)
-                { this->parent_ = shape; this->parentID_ = ID; }
+            bool notifyBeingAttached(CompoundCollisionShape* newParent);
+            void notifyDetached();
 
         protected:
@@ -85,4 +85,5 @@
             btCollisionShape*       collisionShape_;
             CompoundCollisionShape* parent_;
+            unsigned int            parentID_;
 
         private:
@@ -90,5 +91,4 @@
             Quaternion              orientation_;
             Vector3                 scale_;
-            unsigned int            parentID_;
     };
 }
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.cc	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.cc	(revision 2562)
@@ -36,5 +36,4 @@
 #include "core/XMLPort.h"
 #include "tools/BulletConversions.h"
-#include "objects/worldentities/WorldEntity.h"
 
 namespace orxonox
@@ -47,5 +46,4 @@
 
         this->compoundShape_  = new btCompoundShape();
-        this->worldEntityParent_ = 0;
     }
 
@@ -59,5 +57,5 @@
             {
                 // make sure that the child doesn't want to detach itself --> speedup because of the missing update
-                it->first->setParent(0, OBJECTID_UNKNOWN);
+                it->first->notifyDetached();
                 delete it->first;
             }
@@ -74,12 +72,4 @@
     }
 
-    void CompoundCollisionShape::setWorldEntityParent(WorldEntity* parent)
-    {
-        // suppress synchronisation
-        this->setObjectMode(0x0);
-
-        this->worldEntityParent_ = parent;
-    }
-
     void CompoundCollisionShape::attach(CollisionShape* shape)
     {
@@ -91,4 +81,8 @@
             return;
         }
+
+        if (!shape->notifyBeingAttached(this))
+            return;
+
         this->attachedShapes_[shape] = shape->getCollisionShape();
 
@@ -101,14 +95,4 @@
             this->updatePublicShape();
         }
-
-        // network synchro
-        if (this->worldEntityParent_)
-        {
-            // This compound collision shape belongs to a WE and doesn't get synchronised
-            // So set our parent to be the WE
-            shape->setParent(this, this->worldEntityParent_->getObjectID());
-        }
-        else
-            shape->setParent(this, this->getObjectID());
     }
 
@@ -117,8 +101,8 @@
         if (this->attachedShapes_.find(shape) != this->attachedShapes_.end())
         {
-            shape->setParent(0, OBJECTID_UNKNOWN);
             this->attachedShapes_.erase(shape);
             if (shape->getCollisionShape())
                 this->compoundShape_->removeChildShape(shape->getCollisionShape());
+            shape->notifyDetached();
 
             this->updatePublicShape();
@@ -197,18 +181,4 @@
     }
 
-    void CompoundCollisionShape::updateParent()
-    {
-        if (this->parent_)
-            this->parent_->updateAttachedShape(this);
-        if (this->worldEntityParent_)
-            this->worldEntityParent_->notifyCollisionShapeChanged();
-    }
-
-    void CompoundCollisionShape::parentChanged()
-    {
-        if (!this->worldEntityParent_)
-            CollisionShape::parentChanged();
-    }
-
     CollisionShape* CompoundCollisionShape::getAttachedShape(unsigned int index) const
     {
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.h	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.h	(revision 2562)
@@ -53,12 +53,6 @@
             void updateAttachedShape(CollisionShape* shape);
 
-            void setWorldEntityParent(WorldEntity* parent);
-
-        protected:
-            virtual void updateParent();
-
         private:
             void updatePublicShape();
-            void parentChanged();
             inline virtual btCollisionShape* createNewShape() const
                 { assert(false); return 0; }
@@ -66,5 +60,4 @@
             btCompoundShape* compoundShape_;
             std::map<CollisionShape*, btCollisionShape*> attachedShapes_;
-            WorldEntity* worldEntityParent_;
     };
 }
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/WorldEntityCollisionShape.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/WorldEntityCollisionShape.cc	(revision 2562)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/WorldEntityCollisionShape.cc	(revision 2562)
@@ -0,0 +1,69 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+#include "WorldEntityCollisionShape.h"
+
+#include "BulletCollision/CollisionShapes/btCompoundShape.h"
+
+#include "util/Exception.h"
+#include "core/CoreIncludes.h"
+#include "objects/worldentities/WorldEntity.h"
+
+namespace orxonox
+{
+    WorldEntityCollisionShape::WorldEntityCollisionShape(WorldEntity* creator) : CompoundCollisionShape(creator)
+    {
+        RegisterObject(WorldEntityCollisionShape);
+
+        this->worldEntityOwner_ = creator;
+        // suppress synchronisation
+        this->setObjectMode(0x0);
+    }
+
+    WorldEntityCollisionShape::~WorldEntityCollisionShape()
+    {
+        // Called always by WE destructor
+    }
+
+    void WorldEntityCollisionShape::updateParent()
+    {
+        // Note: This shape may also be attached to a CompoundCollisionShape because it's hosting
+        // WorldEntity has been attached to another one.
+        CollisionShape::updateParent();
+
+        assert(this->worldEntityOwner_ != 0);
+        this->worldEntityOwner_->notifyCollisionShapeChanged();
+    }
+
+    void WorldEntityCollisionShape::parentChanged()
+    {
+        // This object does not get synchronised. This method should never be called then!
+        OrxAssert(false, "parentChanged has been called on a non synchronised WorldEntityCollisionShape!");
+    }
+}
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/WorldEntityCollisionShape.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/WorldEntityCollisionShape.h	(revision 2562)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/WorldEntityCollisionShape.h	(revision 2562)
@@ -0,0 +1,57 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _WorldEntityCollisionShape_H__
+#define _WorldEntityCollisionShape_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "CompoundCollisionShape.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport WorldEntityCollisionShape : public CompoundCollisionShape
+    {
+        public:
+            WorldEntityCollisionShape(WorldEntity* creator);
+            virtual ~WorldEntityCollisionShape();
+
+            inline WorldEntity* getWorldEntityOwner()
+                { return this->worldEntityOwner_; }
+
+        protected:
+            virtual void updateParent();
+
+        private:
+            void parentChanged();
+
+            WorldEntity* worldEntityOwner_;
+    };
+}
+
+#endif /* _WorldEntityCollisionShape_H__ */
Index: code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2562)
@@ -42,4 +42,5 @@
 
 #include "objects/Scene.h"
+#include "objects/collisionshapes/WorldEntityCollisionShape.h"
 
 namespace orxonox
@@ -57,5 +58,5 @@
         All the default values are being set here.
     */
-    WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator), collisionShape_(0)
+    WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     {
         RegisterObject(WorldEntity);
@@ -74,11 +75,9 @@
 
         // Default behaviour does not include physics
-        // Note: CompoundCollisionShape is a Synchronisable, but must not be synchronised.
-        //       All objects will get attached on the client anyway, so we don't need synchronisation.
-        this->collisionShape_.setWorldEntityParent(this);
         this->physicalBody_   = 0;
         this->bPhysicsActive_ = false;
         this->bPhysicsActiveSynchronised_    = false;
         this->bPhysicsActiveBeforeAttaching_ = false;
+        this->collisionShape_ = new WorldEntityCollisionShape(this);
         this->collisionType_             = None;
         this->collisionTypeSynchronised_ = None;
@@ -115,4 +114,5 @@
                 delete this->physicalBody_;
             }
+            delete this->collisionShape_;
 
             this->node_->detachAllObjects();
@@ -291,5 +291,5 @@
         this->children_.insert(object);
 
-        this->attachCollisionShape(&object->collisionShape_);
+        this->attachCollisionShape(object->collisionShape_);
         // mass
         this->childrenMass_ += object->getMass();
@@ -345,6 +345,6 @@
 
         // apply transform to collision shape
-        this->collisionShape_.setPosition(this->getPosition());
-        this->collisionShape_.setOrientation(this->getOrientation());
+        this->collisionShape_->setPosition(this->getPosition());
+        this->collisionShape_->setOrientation(this->getOrientation());
         // TODO: Scale
         
@@ -365,5 +365,5 @@
 
         // collision shapes
-        this->detachCollisionShape(&object->collisionShape_);
+        this->detachCollisionShape(object->collisionShape_);
 
         // mass
@@ -390,6 +390,6 @@
 
         // reset orientation of the collisionShape (cannot be set within a WE usually)
-        this->collisionShape_.setPosition(Vector3::ZERO);
-        this->collisionShape_.setOrientation(Quaternion::IDENTITY);
+        this->collisionShape_->setPosition(Vector3::ZERO);
+        this->collisionShape_->setOrientation(Quaternion::IDENTITY);
         // TODO: Scale
 
@@ -451,5 +451,5 @@
     void WorldEntity::attachCollisionShape(CollisionShape* shape)
     {
-        this->collisionShape_.attach(shape);
+        this->collisionShape_->attach(shape);
         // Note: this->collisionShape_ already notifies us of any changes.
     }
@@ -458,5 +458,6 @@
     void WorldEntity::detachCollisionShape(CollisionShape* shape)
     {
-        this->collisionShape_.detach(shape);
+        // Note: The collision shapes may not be detached with this function!
+        this->collisionShape_->detach(shape);
         // Note: this->collisionShape_ already notifies us of any changes.
     }
@@ -465,5 +466,5 @@
     CollisionShape* WorldEntity::getAttachedCollisionShape(unsigned int index)
     {
-        return this->collisionShape_.getAttachedShape(index);
+        return this->collisionShape_->getAttachedShape(index);
     }
 
@@ -718,5 +719,5 @@
 */
             // Create new rigid body
-            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, this->collisionShape_.getCollisionShape());
+            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, this->collisionShape_->getCollisionShape());
             this->physicalBody_ = new btRigidBody(bodyConstructionInfo);
             this->physicalBody_->setUserPointer(this);
@@ -851,9 +852,9 @@
             {
                 this->deactivatePhysics();
-                this->physicalBody_->setCollisionShape(this->collisionShape_.getCollisionShape());
+                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
                 this->activatePhysics();
             }
             else
-                this->physicalBody_->setCollisionShape(this->collisionShape_.getCollisionShape());
+                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
         }
         recalculateMassProps();
@@ -865,5 +866,5 @@
         // Store local inertia for faster access. Evaluates to (0,0,0) if there is no collision shape.
         float totalMass = this->mass_ + this->childrenMass_;
-        this->collisionShape_.calculateLocalInertia(totalMass, this->localInertia_);
+        this->collisionShape_->calculateLocalInertia(totalMass, this->localInertia_);
         if (this->hasPhysics())
         {
@@ -878,5 +879,5 @@
                 CCOUT(4) << "Warning: Setting the internal physical mass to 1.0 because mass_ is 0.0" << std::endl;
                 btVector3 inertia(0, 0, 0);
-                this->collisionShape_.calculateLocalInertia(1.0f, inertia);
+                this->collisionShape_->calculateLocalInertia(1.0f, inertia);
                 this->physicalBody_->setMassProps(1.0f, inertia);
             }
Index: code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2559)
+++ code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2562)
@@ -43,5 +43,4 @@
 #include "core/BaseObject.h"
 #include "network/synchronisable/Synchronisable.h"
-#include "objects/collisionshapes/CompoundCollisionShape.h"
 
 namespace orxonox
@@ -69,5 +68,5 @@
         You can get more information at the corresponding set function.
 
-        Collision shapes: These are controlled by the internal CompoundCollisionShape. @see CompoundCollisionShape.
+        Collision shapes: These are controlled by the internal WorldEntityCollisionShape. @see WorldEntityCollisionShape.
     */
     class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState
@@ -399,5 +398,5 @@
             //! When attaching objects hierarchically this variable tells this object (as child) whether physics was activated before attaching (because the deactivate physics while being attached).
             bool                         bPhysicsActiveBeforeAttaching_;
-            CompoundCollisionShape       collisionShape_;                //!< Attached collision shapes go here
+            WorldEntityCollisionShape*   collisionShape_;                //!< Attached collision shapes go here
             btScalar                     mass_;                          //!< @see setMass
             btVector3                    localInertia_;                  //!< @see getLocalInertia
