Index: code/branches/core6/src/libraries/core/CorePrereqs.h
===================================================================
--- code/branches/core6/src/libraries/core/CorePrereqs.h	(revision 9564)
+++ code/branches/core6/src/libraries/core/CorePrereqs.h	(revision 9565)
@@ -155,4 +155,5 @@
     class GraphicsManager;
     class GUIManager;
+    class Identifiable;
     class Identifier;
     template <class T>
Index: code/branches/core6/src/libraries/core/class/CMakeLists.txt
===================================================================
--- code/branches/core6/src/libraries/core/class/CMakeLists.txt	(revision 9564)
+++ code/branches/core6/src/libraries/core/class/CMakeLists.txt	(revision 9565)
@@ -1,3 +1,4 @@
 ADD_SOURCE_FILES(CORE_SRC_FILES
+  Identifiable.cc
   Identifier.cc
   IdentifierManager.cc
Index: code/branches/core6/src/libraries/core/class/Identifiable.cc
===================================================================
--- code/branches/core6/src/libraries/core/class/Identifiable.cc	(revision 9565)
+++ code/branches/core6/src/libraries/core/class/Identifiable.cc	(revision 9565)
@@ -0,0 +1,118 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of OrxonoxClass.
+*/
+
+#include "Identifiable.h"
+
+#include <cassert>
+#include "core/object/MetaObjectList.h"
+#include "core/object/Context.h"
+#include "Identifier.h"
+
+namespace orxonox
+{
+    /**
+        @brief Constructor: Sets the default values.
+    */
+    Identifiable::Identifiable()
+    {
+        this->identifier_ = 0;
+        this->parents_ = 0;
+        this->metaList_ = new MetaObjectList();
+        // Optimisation
+        this->objectPointers_.reserve(6);
+    }
+
+    /**
+        @brief Destructor: Removes the object from the object-lists
+    */
+    Identifiable::~Identifiable()
+    {
+//        if (!this->requestedDestruction_)
+//            orxout(internal_warning) << "Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << endl;
+
+        this->unregisterObject();
+
+        // parents_ exists only if isCreatingHierarchy() of the associated Identifier returned true while creating the class
+        if (this->parents_)
+            delete this->parents_;
+    }
+
+    /**
+        @brief Removes this object from the object-lists.
+    */
+    void Identifiable::unregisterObject()
+    {
+        if (this->metaList_)
+            delete this->metaList_;
+        this->metaList_ = 0;
+    }
+
+    /// Returns true if the object's class is of the given type or a derivative.
+    bool Identifiable::isA(const Identifier* identifier)
+        { return this->getIdentifier()->isA(identifier); }
+    /// Returns true if the object's class is exactly of the given type.
+    bool Identifiable::isExactlyA(const Identifier* identifier)
+        { return this->getIdentifier()->isExactlyA(identifier); }
+    /// Returns true if the object's class is a child of the given type.
+    bool Identifiable::isChildOf(const Identifier* identifier)
+        { return this->getIdentifier()->isChildOf(identifier); }
+    /// Returns true if the object's class is a direct child of the given type.
+    bool Identifiable::isDirectChildOf(const Identifier* identifier)
+        { return this->getIdentifier()->isDirectChildOf(identifier); }
+    /// Returns true if the object's class is a parent of the given type.
+    bool Identifiable::isParentOf(const Identifier* identifier)
+        { return this->getIdentifier()->isParentOf(identifier); }
+    /// Returns true if the object's class is a direct parent of the given type.
+    bool Identifiable::isDirectParentOf(const Identifier* identifier)
+        { return this->getIdentifier()->isDirectParentOf(identifier); }
+
+
+    /// Returns true if the object's class is of the given type or a derivative.
+    bool Identifiable::isA(const Identifiable* object)
+        { return this->getIdentifier()->isA(object->getIdentifier()); }
+    /// Returns true if the object's class is exactly of the given type.
+    bool Identifiable::isExactlyA(const Identifiable* object)
+        { return this->getIdentifier()->isExactlyA(object->getIdentifier()); }
+    /// Returns true if the object's class is a child of the given type.
+    bool Identifiable::isChildOf(const Identifiable* object)
+        { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
+    /// Returns true if the object's class is a direct child of the given type.
+    bool Identifiable::isDirectChildOf(const Identifiable* object)
+        { return this->getIdentifier()->isDirectChildOf(object->getIdentifier()); }
+    /// Returns true if the object's class is a parent of the given type.
+    bool Identifiable::isParentOf(const Identifiable* object)
+        { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
+    /// Returns true if the object's class is a direct child of the given type.
+    bool Identifiable::isDirectParentOf(const Identifiable* object)
+        { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
+}
Index: code/branches/core6/src/libraries/core/class/Identifiable.h
===================================================================
--- code/branches/core6/src/libraries/core/class/Identifiable.h	(revision 9565)
+++ code/branches/core6/src/libraries/core/class/Identifiable.h	(revision 9565)
@@ -0,0 +1,132 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @ingroup Class Identifier
+    @brief Declaration of Identifiable, the base of all classes that should own an Identifier.
+
+    It stores the Identifier and the MetaObjectList and has all needed functions to create and use the class-hierarchy.
+*/
+
+#ifndef _Identifiable_H__
+#define _Identifiable_H__
+
+#include "core/CorePrereqs.h"
+
+#include <set>
+#include <vector>
+
+namespace orxonox
+{
+    /**
+        @brief Identifiable is needed to create the class-hierarchy at startup and to store the Identifier and the MetaObjectList.
+    */
+    class _CoreExport Identifiable
+    {
+        template <class T>
+        friend class ClassIdentifier;
+
+        public:
+            Identifiable();
+            virtual ~Identifiable();
+
+            void destroy();
+            void unregisterObject();
+
+            /// Returns the Identifier of the object.
+            inline Identifier* getIdentifier() const { return this->identifier_; }
+
+            bool isA(const Identifier* identifier);
+            bool isExactlyA(const Identifier* identifier);
+            bool isChildOf(const Identifier* identifier);
+            bool isDirectChildOf(const Identifier* identifier);
+            bool isParentOf(const Identifier* identifier);
+            bool isDirectParentOf(const Identifier* identifier);
+
+            /// Returns true if the object's class is of the given type or a derivative.
+            template <class B> inline bool isA(const SubclassIdentifier<B>* identifier)
+                { return this->isA(*identifier); }
+            /// Returns true if the object's class is exactly of the given type.
+            template <class B> inline bool isExactlyA(const SubclassIdentifier<B>* identifier)
+                { return this->isExactlyA(*identifier); }
+            /// Returns true if the object's class is a child of the given type.
+            template <class B> inline bool isChildOf(const SubclassIdentifier<B>* identifier)
+                { return this->isChildOf(*identifier); }
+            /// Returns true if the object's class is a direct child of the given type.
+            template <class B> inline bool isDirectChildOf(const SubclassIdentifier<B>* identifier)
+                { return this->isDirectChildOf(*identifier); }
+            /// Returns true if the object's class is a parent of the given type.
+            template <class B> inline bool isParentOf(const SubclassIdentifier<B>* identifier)
+                { return this->isParentOf(*identifier); }
+            /// Returns true if the object's class is a direct parent of the given type.
+            template <class B> inline bool isDirectParentOf(const SubclassIdentifier<B>* identifier)
+                { return this->isDirectParentOf(*identifier); }
+
+            bool isA(const Identifiable* object);
+            bool isExactlyA(const Identifiable* object);
+            bool isChildOf(const Identifiable* object);
+            bool isDirectChildOf(const Identifiable* object);
+            bool isParentOf(const Identifiable* object);
+            bool isDirectParentOf(const Identifiable* object);
+
+            /**
+            @brief
+                Returns a valid pointer of any derived type that is
+                registered in the class hierarchy.
+            @return
+                Returns NULL if the no pointer was found.
+            */
+            ORX_FORCEINLINE void* getDerivedPointer(unsigned int classID)
+            {
+                for (int i = this->objectPointers_.size() - 1; i >= 0; --i)
+                {
+                    if (this->objectPointers_[i].first == classID)
+                        return this->objectPointers_[i].second;
+                }
+                return NULL;
+            }
+
+            /// Version of getDerivedPointer with template
+            template <class T> ORX_FORCEINLINE T* getDerivedPointer(unsigned int classID)
+            {   return static_cast<T*>(this->getDerivedPointer(classID));   }
+            /// Const version of getDerivedPointer with template
+            template <class T> ORX_FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
+            {   return const_cast<Identifiable*>(this)->getDerivedPointer<T>(classID);   }
+
+        private:
+            Identifier* identifier_;                                //!< The Identifier of the object
+            std::set<const Identifier*>* parents_;                  //!< List of all parents of the object
+            MetaObjectList* metaList_;                              //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
+
+            /// 'Fast map' that holds this-pointers of all derived types
+            std::vector<std::pair<unsigned int, void*> > objectPointers_;
+    };
+}
+
+#endif /* _Identifiable_H__ */
Index: code/branches/core6/src/libraries/core/class/OrxonoxClass.cc
===================================================================
--- code/branches/core6/src/libraries/core/class/OrxonoxClass.cc	(revision 9564)
+++ code/branches/core6/src/libraries/core/class/OrxonoxClass.cc	(revision 9565)
@@ -46,28 +46,14 @@
     OrxonoxClass::OrxonoxClass()
     {
-        this->identifier_ = 0;
-        this->parents_ = 0;
-        this->metaList_ = new MetaObjectList();
         this->referenceCount_ = 0;
         this->requestedDestruction_ = false;
-        // Optimisation
-        this->objectPointers_.reserve(6);
     }
 
     /**
-        @brief Destructor: Removes the object from the object-lists, notifies all DestructionListener (for example @ref WeakPtr "weak pointers") that this object is being deleted.
+        @brief Destructor: Notifies all DestructionListener (for example @ref WeakPtr "weak pointers") that this object is being deleted.
     */
     OrxonoxClass::~OrxonoxClass()
     {
-//        if (!this->requestedDestruction_)
-//            orxout(internal_warning) << "Destroyed object without destroy() (" << this->getIdentifier()->getName() << ')' << endl;
-
         assert(this->referenceCount_ <= 0);
-
-        this->unregisterObject();
-
-        // parents_ exists only if isCreatingHierarchy() of the associated Identifier returned true while creating the class
-        if (this->parents_)
-            delete this->parents_;
 
         // notify all destruction listeners
@@ -90,52 +76,3 @@
         }
     }
-
-    /**
-        @brief Removes this object from the object-lists.
-    */
-    void OrxonoxClass::unregisterObject()
-    {
-        if (this->metaList_)
-            delete this->metaList_;
-        this->metaList_ = 0;
-    }
-
-    /// Returns true if the object's class is of the given type or a derivative.
-    bool OrxonoxClass::isA(const Identifier* identifier)
-        { return this->getIdentifier()->isA(identifier); }
-    /// Returns true if the object's class is exactly of the given type.
-    bool OrxonoxClass::isExactlyA(const Identifier* identifier)
-        { return this->getIdentifier()->isExactlyA(identifier); }
-    /// Returns true if the object's class is a child of the given type.
-    bool OrxonoxClass::isChildOf(const Identifier* identifier)
-        { return this->getIdentifier()->isChildOf(identifier); }
-    /// Returns true if the object's class is a direct child of the given type.
-    bool OrxonoxClass::isDirectChildOf(const Identifier* identifier)
-        { return this->getIdentifier()->isDirectChildOf(identifier); }
-    /// Returns true if the object's class is a parent of the given type.
-    bool OrxonoxClass::isParentOf(const Identifier* identifier)
-        { return this->getIdentifier()->isParentOf(identifier); }
-    /// Returns true if the object's class is a direct parent of the given type.
-    bool OrxonoxClass::isDirectParentOf(const Identifier* identifier)
-        { return this->getIdentifier()->isDirectParentOf(identifier); }
-
-
-    /// Returns true if the object's class is of the given type or a derivative.
-    bool OrxonoxClass::isA(const OrxonoxClass* object)
-        { return this->getIdentifier()->isA(object->getIdentifier()); }
-    /// Returns true if the object's class is exactly of the given type.
-    bool OrxonoxClass::isExactlyA(const OrxonoxClass* object)
-        { return this->getIdentifier()->isExactlyA(object->getIdentifier()); }
-    /// Returns true if the object's class is a child of the given type.
-    bool OrxonoxClass::isChildOf(const OrxonoxClass* object)
-        { return this->getIdentifier()->isChildOf(object->getIdentifier()); }
-    /// Returns true if the object's class is a direct child of the given type.
-    bool OrxonoxClass::isDirectChildOf(const OrxonoxClass* object)
-        { return this->getIdentifier()->isDirectChildOf(object->getIdentifier()); }
-    /// Returns true if the object's class is a parent of the given type.
-    bool OrxonoxClass::isParentOf(const OrxonoxClass* object)
-        { return this->getIdentifier()->isParentOf(object->getIdentifier()); }
-    /// Returns true if the object's class is a direct child of the given type.
-    bool OrxonoxClass::isDirectParentOf(const OrxonoxClass* object)
-        { return this->getIdentifier()->isDirectParentOf(object->getIdentifier()); }
 }
Index: code/branches/core6/src/libraries/core/class/OrxonoxClass.h
===================================================================
--- code/branches/core6/src/libraries/core/class/OrxonoxClass.h	(revision 9564)
+++ code/branches/core6/src/libraries/core/class/OrxonoxClass.h	(revision 9565)
@@ -36,7 +36,4 @@
     @ingroup Class OrxonoxClass
     @brief Declaration of OrxonoxClass, the base class of all objects and interfaces in Orxonox.
-
-    All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.
-    It stores the Identifier and the MetaObjectList and has all needed functions to create and use the class-hierarchy.
 */
 
@@ -47,6 +44,6 @@
 
 #include <set>
-#include <vector>
-#include "Super.h"
+//#include "Super.h"
+#include "Identifiable.h"
 
 namespace orxonox
@@ -56,12 +53,7 @@
 
         The BaseObject and Interfaces are derived with @c virtual @c public @c OrxonoxClass from OrxonoxClass.
-        OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the
-        MetaObjectList, as well as to provide an interface for SmartPtr and WeakPtr.
     */
-    class _CoreExport OrxonoxClass
+    class _CoreExport OrxonoxClass : public Identifiable
     {
-        template <class T>
-        friend class ClassIdentifier;
-
         template <class T>
         friend class SmartPtr;
@@ -74,72 +66,11 @@
 
             void destroy();
-            void unregisterObject();
 
             /// Function to collect the SetConfigValue-macro calls.
             void setConfigValues() {};
 
-            /// Returns the Identifier of the object.
-            inline Identifier* getIdentifier() const { return this->identifier_; }
-
-            bool isA(const Identifier* identifier);
-            bool isExactlyA(const Identifier* identifier);
-            bool isChildOf(const Identifier* identifier);
-            bool isDirectChildOf(const Identifier* identifier);
-            bool isParentOf(const Identifier* identifier);
-            bool isDirectParentOf(const Identifier* identifier);
-
-            /// Returns true if the object's class is of the given type or a derivative.
-            template <class B> inline bool isA(const SubclassIdentifier<B>* identifier)
-                { return this->isA(*identifier); }
-            /// Returns true if the object's class is exactly of the given type.
-            template <class B> inline bool isExactlyA(const SubclassIdentifier<B>* identifier)
-                { return this->isExactlyA(*identifier); }
-            /// Returns true if the object's class is a child of the given type.
-            template <class B> inline bool isChildOf(const SubclassIdentifier<B>* identifier)
-                { return this->isChildOf(*identifier); }
-            /// Returns true if the object's class is a direct child of the given type.
-            template <class B> inline bool isDirectChildOf(const SubclassIdentifier<B>* identifier)
-                { return this->isDirectChildOf(*identifier); }
-            /// Returns true if the object's class is a parent of the given type.
-            template <class B> inline bool isParentOf(const SubclassIdentifier<B>* identifier)
-                { return this->isParentOf(*identifier); }
-            /// Returns true if the object's class is a direct parent of the given type.
-            template <class B> inline bool isDirectParentOf(const SubclassIdentifier<B>* identifier)
-                { return this->isDirectParentOf(*identifier); }
-
-            bool isA(const OrxonoxClass* object);
-            bool isExactlyA(const OrxonoxClass* object);
-            bool isChildOf(const OrxonoxClass* object);
-            bool isDirectChildOf(const OrxonoxClass* object);
-            bool isParentOf(const OrxonoxClass* object);
-            bool isDirectParentOf(const OrxonoxClass* object);
-
             /// Returns the number of @ref orxonox::SmartPtr "smart pointers" that point to this object.
             inline unsigned int getReferenceCount() const
                 { return this->referenceCount_; }
-
-            /**
-            @brief
-                Returns a valid pointer of any derived type that is
-                registered in the class hierarchy.
-            @return
-                Returns NULL if the no pointer was found.
-            */
-            ORX_FORCEINLINE void* getDerivedPointer(unsigned int classID)
-            {
-                for (int i = this->objectPointers_.size() - 1; i >= 0; --i)
-                {
-                    if (this->objectPointers_[i].first == classID)
-                        return this->objectPointers_[i].second;
-                }
-                return NULL;
-            }
-
-            /// Version of getDerivedPointer with template
-            template <class T> ORX_FORCEINLINE T* getDerivedPointer(unsigned int classID)
-            {   return static_cast<T*>(this->getDerivedPointer(classID));   }
-            /// Const version of getDerivedPointer with template
-            template <class T> ORX_FORCEINLINE const T* getDerivedPointer(unsigned int classID) const
-            {   return const_cast<OrxonoxClass*>(this)->getDerivedPointer<T>(classID);   }
 
         protected:
@@ -166,13 +97,7 @@
                 { this->destructionListeners_.erase(pointer); }
 
-            Identifier* identifier_;                                //!< The Identifier of the object
-            std::set<const Identifier*>* parents_;                  //!< List of all parents of the object
-            MetaObjectList* metaList_;                              //!< MetaObjectList, containing all ObjectLists and ObjectListElements the object is registered in
             int referenceCount_;                                    //!< Counts the references from smart pointers to this object
             bool requestedDestruction_;                             //!< Becomes true after someone called delete on this object
             std::set<DestructionListener*> destructionListeners_;   //!< All destruction listeners (for example weak pointers which point to this object and like to get notified if it dies)
-
-            /// 'Fast map' that holds this-pointers of all derived types
-            std::vector<std::pair<unsigned int, void*> > objectPointers_;
     };
 
