Index: /code/branches/core3/bin/levels/sample.oxw
===================================================================
--- /code/branches/core3/bin/levels/sample.oxw	(revision 1573)
+++ /code/branches/core3/bin/levels/sample.oxw	(revision 1574)
@@ -44,5 +44,5 @@
 for i = 1, 226, 1 
 do ?>
-  <Model position="<?lua print(math.random() * 40000 - 20000)?>, <?lua print(math.random() * 40000 - 20000) ?>, <?lua print(math.random() * 40000 - 20000) ?>" scale="<?lua print(math.random() * 100 + 20) ?>" mesh="ast<?lua print( math.mod(i,6) + 1) ?>.mesh" rotationAxis="<?lua print(math.random()) ?>, <?lua print(math.random()) ?>, <?lua print(math.random()) ?>" rotationRate="<?lua print(math.random() * 30 + 15) ?>" />
+  <Model position="<?lua print(math.random() * 40000 - 20000)?>, <?lua print(math.random() * 40000 - 20000) ?>, <?lua print(math.random() * 40000 - 20000) ?>" scale="<?lua print(math.random() * 250 + 20) ?>" mesh="ast<?lua print( math.mod(i,6) + 1) ?>.mesh" rotationAxis="<?lua print(math.random()) ?>, <?lua print(math.random()) ?>, <?lua print(math.random()) ?>" rotationRate="<?lua print(math.random() * 30 + 15) ?>" />
 <?lua 
 end
Index: /code/branches/core3/src/core/CMakeLists.txt
===================================================================
--- /code/branches/core3/src/core/CMakeLists.txt	(revision 1573)
+++ /code/branches/core3/src/core/CMakeLists.txt	(revision 1574)
@@ -5,4 +5,5 @@
   Error.cc
   Language.cc
+  ObjectListBase.cc
   OrxonoxClass.cc
   OutputBuffer.cc
Index: /code/branches/core3/src/core/ClassTreeMask.h
===================================================================
--- /code/branches/core3/src/core/ClassTreeMask.h	(revision 1573)
+++ /code/branches/core3/src/core/ClassTreeMask.h	(revision 1574)
@@ -78,7 +78,7 @@
 namespace orxonox
 {
-    // ###############################
-    // ###    ClassTreeMaskNode    ###
-    // ###############################
+    // ###################################
+    // ###      ClassTreeMaskNode      ###
+    // ###################################
     //! The ClassTreeMaskNode is a node in the internal tree of the ClassTreeMask, containing the rules of the mask.
     /**
@@ -116,7 +116,7 @@
 
 
-    // ###############################
-    // ###  ClassTreeMaskIterator  ###
-    // ###############################
+    // ###################################
+    // ###    ClassTreeMaskIterator    ###
+    // ###################################
     //! The ClassTreeMaskIterator moves through all ClassTreeMaskNodes of the internal tree of a ClassTreeMask, containing the rules.
     /**
@@ -146,7 +146,7 @@
 
 
-    // ###############################
-    // ###      ClassTreeMask      ###
-    // ###############################
+    // ###################################
+    // ###        ClassTreeMask        ###
+    // ###################################
     //! The ClassTreeMask is a set of rules, containing the information for each class whether it's included or not.
     /**
@@ -214,4 +214,16 @@
             ClassTreeMaskNode* root_;   //!< The root-node of the internal rule-tree, usually BaseObject
     };
+
+
+    // ###################################
+    // ### ClassTreeMaskObjectIterator ###
+    // ###################################
+    //! ...
+    /**
+        ...
+    */
+    class _CoreExport ClassTreeMaskObjectIterator
+    {
+    };
 }
 
Index: /code/branches/core3/src/core/CorePrereqs.h
===================================================================
--- /code/branches/core3/src/core/CorePrereqs.h	(revision 1573)
+++ /code/branches/core3/src/core/CorePrereqs.h	(revision 1574)
@@ -125,4 +125,5 @@
   template <class T>
   class Iterator;
+  class IteratorBase;
   class Language;
   class LanguageEntry;
@@ -130,5 +131,4 @@
   class Loader;
   class MetaObjectList;
-  template <class T>
   class MetaObjectListElement;
   class Namespace;
@@ -136,6 +136,6 @@
   template <class T>
   class ObjectList;
-  template <class T>
-  class ObjectListElement;
+  class ObjectListBase;
+  class ObjectListBaseElement;
   class OrxonoxClass;
   class OutputBuffer;
Index: /code/branches/core3/src/core/Identifier.cc
===================================================================
--- /code/branches/core3/src/core/Identifier.cc	(revision 1573)
+++ /code/branches/core3/src/core/Identifier.cc	(revision 1574)
@@ -39,4 +39,7 @@
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
+#include "MetaObjectList.h"
+#include "ObjectList.h"
+#include "OrxonoxClass.h"
 
 namespace orxonox
@@ -52,4 +55,6 @@
     Identifier::Identifier()
     {
+        this->objects_ = new ObjectListBase(this);
+
         this->bCreatedOneObject_ = false;
         this->factory_ = 0;
@@ -174,4 +179,14 @@
 
     /**
+        @brief Adds an object of the given type to the ObjectList.
+        @param object The object to add
+    */
+    void Identifier::addObject(OrxonoxClass* object)
+    {
+        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
+        object->getMetaList().add(this->objects_, this->objects_->add(object));
+    }
+
+    /**
         @brief Returns true, if the Identifier is at least of the given type.
         @param identifier The identifier to compare with
Index: /code/branches/core3/src/core/Identifier.h
===================================================================
--- /code/branches/core3/src/core/Identifier.h	(revision 1573)
+++ /code/branches/core3/src/core/Identifier.h	(revision 1574)
@@ -60,8 +60,6 @@
 #include <utility>
 
-#include "ObjectList.h"
 #include "Debug.h"
 #include "Iterator.h"
-#include "MetaObjectList.h"
 #include "util/String.h"
 
@@ -108,11 +106,14 @@
             bool isDirectParentOf(const Identifier* identifier) const;
 
-            virtual const ObjectList<BaseObject>* getObjectList() const = 0;
-
-            virtual void updateConfigValues() const = 0;
+            void addObject(OrxonoxClass* object);
+
+            /** @brief Returns the list of all existing objects of this class. @return The list */
+            inline ObjectListBase* getObjects() const
+                { return this->objects_; }
 
             /** @brief Returns the name of the class the Identifier belongs to. @return The name */
             inline const std::string& getName() const { return this->name_; }
 
+            virtual void updateConfigValues() const = 0;
 
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
@@ -263,4 +264,5 @@
             std::string name_;                                             //!< The name of the class the Identifier belongs to
 
+            ObjectListBase* objects_;                                      //!< The list of all objects of this class
             BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
             bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
@@ -297,10 +299,5 @@
         public:
             ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
-            void addObject(T* object);
             void setName(const std::string& name);
-            /** @brief Returns the list of all existing objects of this class. @return The list */
-            inline ObjectList<T>* getObjects() const { return this->objects_; }
-            /** @brief Returns a list of all existing objects of this class. @return The list */
-            inline ObjectList<BaseObject>* getObjectList() const { return (ObjectList<BaseObject>*)this->objects_; }
 
             void updateConfigValues() const;
@@ -319,5 +316,4 @@
             ~ClassIdentifier() {}                                       // don't delete
 
-            ObjectList<T>* objects_;                                                                    //!< The ObjectList, containing all objects of type T
             bool bSetName_;                                                                             //!< True if the name is set
             std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
@@ -336,6 +332,4 @@
     ClassIdentifier<T>::ClassIdentifier()
     {
-//        this->objects_ = ObjectList<T>::getList();
-        this->objects_ = new ObjectList<T>();
         this->bSetName_ = false;
     }
@@ -408,15 +402,4 @@
 
     /**
-        @brief Adds an object of the given type to the ObjectList.
-        @param object The object to add
-    */
-    template <class T>
-    void ClassIdentifier<T>::addObject(T* object)
-    {
-        COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
-        object->getMetaList().add(this->objects_, this->objects_->add(object));
-    }
-
-    /**
         @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
     */
@@ -424,6 +407,6 @@
     void ClassIdentifier<T>::updateConfigValues() const
     {
-        for (Iterator<T> it = this->objects_->start(); it; ++it)
-            ((T*)*it)->setConfigValues();
+        for (Iterator<T> it = this->objects_->begin(); it; ++it)
+            (*it)->setConfigValues();
     }
 
Index: /code/branches/core3/src/core/Iterator.h
===================================================================
--- /code/branches/core3/src/core/Iterator.h	(revision 1573)
+++ /code/branches/core3/src/core/Iterator.h	(revision 1574)
@@ -35,11 +35,9 @@
 
     Usage:
-    for (Iterator<class> it = ObjectList<class>::start(); it != 0; ++it)
+    for (Iterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
     {
         it->someFunction(...);
-        class* myObject = *it;
+        myClass* myObject = *it;
     }
-
-    Warning: Don't delete objects directly through the iterator.
 */
 
@@ -49,11 +47,11 @@
 #include "CorePrereqs.h"
 
-#include "ObjectList.h"
+#include "IteratorBase.h"
 
 namespace orxonox
 {
-    //! The iterator allows to iterate through an ObjectList of a given class.
+    //! The Iterator allows to iterate through the ObjectList of a given class.
     template <class T>
-    class Iterator
+    class Iterator : public IteratorBase
     {
         public:
@@ -61,7 +59,6 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            Iterator()
+            inline Iterator()
             {
-                this->element_ = 0;
                 ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
             }
@@ -71,7 +68,6 @@
                 @param element The element to start with
             */
-            Iterator(ObjectListElement<T>* element)
+            inline Iterator(ObjectListBaseElement* element) : IteratorBase((ObjectListBaseElement*)element)
             {
-                this->element_ = element;
                 ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
             }
@@ -80,16 +76,7 @@
                 @brief Unregisters the Iterator from the ObjectList.
             */
-            ~Iterator()
+            inline ~Iterator()
             {
                 ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterIterator(this);
-            }
-
-            /**
-                @brief Assigns an element to the iterator.
-                @param element The element
-            */
-            Iterator<T> operator=(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
             }
 
@@ -98,8 +85,7 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator++()
+            inline Iterator<T> operator++()
             {
-                if (this->element_)
-                    this->element_ = this->element_->next_;
+                IteratorBase::operator++();
                 return *this;
             }
@@ -109,9 +95,8 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator++(int i)
+            inline Iterator<T> operator++(int i)
             {
                 Iterator<T> copy = *this;
-                if (this->element_)
-                    this->element_ = this->element_->next_;
+                IteratorBase::operator++();
                 return copy;
             }
@@ -121,8 +106,7 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator--()
+            inline Iterator<T> operator--()
             {
-                if (this->element_)
-                    this->element_ = this->element_->prev_;
+                IteratorBase::operator--();
                 return *this;
             }
@@ -132,9 +116,8 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator--(int i)
+            inline Iterator<T> operator--(int i)
             {
                 Iterator<T> copy = *this;
-                if (this->element_)
-                    this->element_ = this->element_->prev_;
+                IteratorBase::operator--();
                 return copy;
             }
@@ -144,10 +127,7 @@
                 @return The object the Iterator points at
             */
-            T* operator*()
+            inline T* operator*()
             {
-                if (this->element_)
-                    return this->element_->object_;
-                else
-                    return 0;
+                return dynamic_cast<T*>(IteratorBase::operator*());
             }
 
@@ -156,36 +136,33 @@
                 @return The object the Iterator points at
             */
-            T* operator->() const
+            inline T* operator->() const
             {
-                if (this->element_)
-                    return this->element_->object_;
-                else
-                    return 0;
-
+                return dynamic_cast<T*>(IteratorBase::operator->());
             }
 
             /**
-                @brief Overloading of the typecast-operator to bool: returns true if the iterator points to an existing object.
-                @return True if the iterator points to an existing object.
+                @brief Overloading of the == operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to the same element
             */
-            operator bool()
+            inline bool operator==(const Iterator<T>& compare)
             {
-                return (this->element_ != 0);
+                return (this->element_ == compare.element_);
             }
 
             /**
-                @brief Overloading of the (it != int) operator: Used for (it != 0) instead of typecast-operator to bool.
-                @param compare The integer (must be zero, everything else makes no sense).
-                @return True if the iterator points to an existing object.
+                @brief Overloading of the != operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to different elements
             */
-            bool operator!=(ObjectListElement<T>* compare)
+            inline bool operator!=(const Iterator<T>& compare)
             {
-                return (this->element_ != compare);
+                return (this->element_ != compare.element_);
             }
-
-        private:
-            ObjectListElement<T>* element_;     //!< The element the Iterator points at
     };
 }
 
+// Include ObjectList.h so the user only has to include one file: Iterator.h
+#include "ObjectList.h"
+
 #endif /* _Iterator_H__ */
Index: /code/branches/core3/src/core/IteratorBase.h
===================================================================
--- /code/branches/core3/src/core/IteratorBase.h	(revision 1574)
+++ /code/branches/core3/src/core/IteratorBase.h	(revision 1574)
@@ -0,0 +1,190 @@
+/*
+ *   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 IteratorBase.h
+    @brief Definition and implementation of the Iterator class.
+
+    The Iterator of a given class allows to iterate through an ObjectListBase, containing all objects of that type.
+    This is the only way to access the objects stored in an ObjectListBase.
+*/
+
+#ifndef _IteratorBase_H__
+#define _IteratorBase_H__
+
+#include "CorePrereqs.h"
+
+#include "ObjectListBase.h"
+
+namespace orxonox
+{
+    //! The IteratorBase allows to iterate through an ObjectListBase
+    class _CoreExport IteratorBase
+    {
+        public:
+            /**
+                @brief Default Constructor: Sets the element to zero.
+            */
+            inline IteratorBase()
+            {
+                this->element_ = 0;
+            }
+
+            /**
+                @brief Constructor: Sets the element, whereon the iterator points, to a given element.
+                @param element The element to start with
+            */
+            inline IteratorBase(ObjectListBaseElement* element)
+            {
+                this->element_ = element;
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element of the other IteratorBase.
+                @param other The other IteratorBase
+            */
+            inline IteratorBase(const IteratorBase& other)
+            {
+                this->element_ = other.element_;
+            }
+
+            /**
+                @brief Assigns the element of another IteratorBase.
+                @param element The other IteratorBase
+            */
+            inline IteratorBase operator=(const IteratorBase& other)
+            {
+                this->element_ = other.element_;
+                return (*this);
+            }
+
+            /**
+                @brief Overloading of the ++it operator: IteratorBase points to the next object in the list.
+                @return The IteratorBase itself
+            */
+            inline IteratorBase operator++()
+            {
+                if (this->element_)
+                    this->element_ = this->element_->next_;
+                return (*this);
+            }
+
+            /**
+                @brief Overloading of the it++ operator: IteratorBase points to the next object in the list.
+                @return The IteratorBase itself
+            */
+            inline IteratorBase operator++(int i)
+            {
+                IteratorBase copy = *this;
+                if (this->element_)
+                    this->element_ = this->element_->next_;
+                return copy;
+            }
+
+            /**
+                @brief Overloading of the --it operator: IteratorBase points to the previous object in the list.
+                @return The IteratorBase itself
+            */
+            inline IteratorBase operator--()
+            {
+                if (this->element_)
+                    this->element_ = this->element_->prev_;
+                return (*this);
+            }
+
+            /**
+                @brief Overloading of the it-- operator: IteratorBase points to the previous object in the list.
+                @return The IteratorBase itself
+            */
+            inline IteratorBase operator--(int i)
+            {
+                IteratorBase copy = *this;
+                if (this->element_)
+                    this->element_ = this->element_->prev_;
+                return copy;
+            }
+
+            /**
+                @brief Overloading of the *it operator: returns the pointer to the object.
+                @return The object the IteratorBase points at
+            */
+            inline OrxonoxClass* operator*()
+            {
+                if (this->element_)
+                    return this->element_->object_;
+                else
+                    return 0;
+            }
+
+            /**
+                @brief Overloading of the it-> operator: returns the pointer to the object.
+                @return The object the IteratorBase points at
+            */
+            inline OrxonoxClass* operator->() const
+            {
+                if (this->element_)
+                    return this->element_->object_;
+                else
+                    return 0;
+            }
+
+            /**
+                @brief Overloading of the typecast-operator to bool: returns true if the iterator points to an existing object.
+                @return True if the IteratorBase points to an existing object.
+            */
+            inline operator bool()
+            {
+                return (this->element_ != 0);
+            }
+
+            /**
+                @brief Overloading of the == operator to compare with another IteratorBase.
+                @param compare The other IteratorBase
+                @return True if the iterators point to the same element
+            */
+            inline bool operator==(const IteratorBase& compare)
+            {
+                return (this->element_ == compare.element_);
+            }
+
+            /**
+                @brief Overloading of the != operator to compare with another IteratorBase.
+                @param compare The other IteratorBase
+                @return True if the iterators point to different elements
+            */
+            inline bool operator!=(const IteratorBase& compare)
+            {
+                return (this->element_ != compare.element_);
+            }
+
+        protected:
+            ObjectListBaseElement* element_;     //!< The element the Iterator points at
+    };
+}
+
+#endif /* _IteratorBase_H__ */
Index: /code/branches/core3/src/core/Loader.cc
===================================================================
--- /code/branches/core3/src/core/Loader.cc	(revision 1573)
+++ /code/branches/core3/src/core/Loader.cc	(revision 1574)
@@ -32,4 +32,5 @@
 #include "Identifier.h"
 #include "Iterator.h"
+#include "ObjectList.h"
 #include "Debug.h"
 #include "CoreIncludes.h"
@@ -91,5 +92,5 @@
     void Loader::unload(const ClassTreeMask& mask)
     {
-        for (Iterator<BaseObject> it = ObjectList<BaseObject>::begin(); it; )
+        for (Iterator<BaseObject> it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); )
         {
             if (mask.isIncluded(it->getIdentifier()))
Index: /code/branches/core3/src/core/MetaObjectList.cc
===================================================================
--- /code/branches/core3/src/core/MetaObjectList.cc	(revision 1573)
+++ /code/branches/core3/src/core/MetaObjectList.cc	(revision 1574)
@@ -33,7 +33,36 @@
 
 #include "MetaObjectList.h"
+#include "Debug.h"
 
 namespace orxonox
 {
+    // ###############################
+    // ###  MetaObjectListElement  ###
+    // ###############################
+    /**
+        @brief Destructor: Removes the ObjectListBaseElement from the ObjectListBase by linking next_ and prev_ of the ObjectListBaseElement.
+    */
+    MetaObjectListElement::~MetaObjectListElement()
+    {
+        COUT(5) << "*** MetaObjectList: Removing Object from " << this->list_->getIdentifier()->getName() << "-list." << std::endl;
+        this->list_->notifyIterators(this->element_);
+
+        if (this->element_->next_)
+            this->element_->next_->prev_ = this->element_->prev_;
+        else
+            this->list_->last_ = this->element_->prev_; // If there is no next_, we deleted the last object and have to update the last_ pointer of the list
+
+        if (this->element_->prev_)
+            this->element_->prev_->next_ = this->element_->next_;
+        else
+            this->list_->first_ = this->element_->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
+
+        delete this->element_;
+    }
+
+
+    // ###############################
+    // ###     MetaObjectList      ###
+    // ###############################
     /**
         @brief Constructor: Sets first_ to zero.
@@ -49,5 +78,5 @@
     MetaObjectList::~MetaObjectList()
     {
-        BaseMetaObjectListElement* temp;
+        MetaObjectListElement* temp;
         while (this->first_)
         {
@@ -57,3 +86,15 @@
         }
     }
+
+    /**
+        @brief Adds an ObjectList and an element of that list to the MetaObjectList.
+        @param list The ObjectList wherein the element is
+        @param element The element wherein the object is
+    */
+    void MetaObjectList::add(ObjectListBase* list, ObjectListBaseElement* element)
+    {
+        MetaObjectListElement* temp = this->first_;
+        this->first_ = new MetaObjectListElement(list, element);
+        this->first_->next_ = temp;
+    }
 }
Index: /code/branches/core3/src/core/MetaObjectList.h
===================================================================
--- /code/branches/core3/src/core/MetaObjectList.h	(revision 1573)
+++ /code/branches/core3/src/core/MetaObjectList.h	(revision 1574)
@@ -41,67 +41,26 @@
 #include "CorePrereqs.h"
 
-#include "ObjectList.h"
+#include "ObjectListBase.h"
 #include "Identifier.h"
-#include "Debug.h"
 
 namespace orxonox
 {
-    //! Base-class of MetaObjectListElement, because those is a template
-    class BaseMetaObjectListElement
-    {
-        public:
-            /** @brief Default destructor */
-            virtual ~BaseMetaObjectListElement() {};
-
-            BaseMetaObjectListElement* next_;       //!< The next Element in the list
-    };
-
     // ###############################
     // ###  MetaObjectListElement  ###
     // ###############################
     //! The list-element of the MetaObjectList
-    template <class T>
-    class MetaObjectListElement : public BaseMetaObjectListElement
+    class _CoreExport MetaObjectListElement
     {
         public:
-            MetaObjectListElement(ObjectList<T>* list, ObjectListElement<T>* element);
-            virtual ~MetaObjectListElement();
+            /**
+                @brief Constructor: Creates the list-element with given list and element.
+            */
+            MetaObjectListElement(ObjectListBase* list, ObjectListBaseElement* element) : next_(0), element_(element), list_(list) {}
+            ~MetaObjectListElement();
 
-            ObjectListElement<T>* element_;         //!< The list element, containing the object
-            ObjectList<T>* list_;                   //!< The list, containing the element
+            MetaObjectListElement* next_;       //!< The next Element in the list
+            ObjectListBaseElement* element_;    //!< The list element, containing the object
+            ObjectListBase* list_;              //!< The list, containing the element
     };
-
-    /**
-        @brief Constructor: Creates the list-element with given list and element.
-    */
-    template <class T>
-    MetaObjectListElement<T>::MetaObjectListElement(ObjectList<T>* list, ObjectListElement<T>* element)
-    {
-        this->element_ = element;
-        this->list_ = list;
-        this->next_ = 0;
-    }
-
-    /**
-        @brief Destructor: Removes the ObjectListElement from the ObjectList by linking next_ and prev_ of the ObjectListElement.
-    */
-    template <class T>
-    MetaObjectListElement<T>::~MetaObjectListElement()
-    {
-        COUT(5) << "*** MetaObjectList: Removing Object from " << ClassIdentifier<T>::getIdentifier()->getName() << "-list." << std::endl;
-        this->list_->notifyIterators(this->element_);
-
-        if (this->element_->next_)
-            this->element_->next_->prev_ = this->element_->prev_;
-        else
-            this->list_->last_ = this->element_->prev_; // If there is no next_, we deleted the last object and have to update the last_ pointer of the list
-
-        if (this->element_->prev_)
-            this->element_->prev_->next_ = this->element_->next_;
-        else
-            this->list_->first_ = this->element_->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
-
-        delete this->element_;
-    }
 
 
@@ -109,5 +68,5 @@
     // ###     MetaObjectList      ###
     // ###############################
-    //!  The MetaObjectList contains ObjectListElements and their ObjectLists.
+    //!  The MetaObjectList contains ObjectListBaseElements and their ObjectListBases.
     /**
         The MetaObjectList is a single-linked list, containing all list-elements and their
@@ -120,22 +79,8 @@
             MetaObjectList();
             ~MetaObjectList();
-            template <class T>
-            void add(ObjectList<T>* list, ObjectListElement<T>* element);
+            void add(ObjectListBase* list, ObjectListBaseElement* element);
 
-            BaseMetaObjectListElement* first_;      //!< The first element in the list
+            MetaObjectListElement* first_;      //!< The first element in the list
     };
-
-    /**
-        @brief Adds an ObjectList and an element of that list to the MetaObjectList.
-        @param list The ObjectList wherein the element is
-        @param element The element wherein the object is
-    */
-    template <class T>
-    void MetaObjectList::add(ObjectList<T>* list, ObjectListElement<T>* element)
-    {
-        BaseMetaObjectListElement* temp = this->first_;
-        this->first_ = new MetaObjectListElement<T>(list, element);
-        this->first_->next_ = temp;
-    }
 }
 
Index: /code/branches/core3/src/core/ObjectList.h
===================================================================
--- /code/branches/core3/src/core/ObjectList.h	(revision 1573)
+++ /code/branches/core3/src/core/ObjectList.h	(revision 1574)
@@ -31,6 +31,5 @@
     @brief Definition and implementation of the ObjectList class.
 
-    The ObjectList is a double-linked list, used by Identifiers to store all objects of a given class.
-    Newly created objects are added through the RegisterObject-macro in its constructor.
+    The ObjectList is a wrapper of an ObjectListBase of a given class.
     Use Iterator<class> to iterate through all objects of the class.
 */
@@ -39,47 +38,17 @@
 #define _ObjectList_H__
 
-#include <set>
-
 #include "CorePrereqs.h"
 
+#include "Identifier.h"
 #include "Iterator.h"
-#include "Identifier.h"
 
 namespace orxonox
 {
     // ###############################
-    // ###    ObjectListElement    ###
-    // ###############################
-    //! The list-element of the ObjectList
-    template <class T>
-    class ObjectListElement
-    {
-        public:
-            ObjectListElement(T* object);
-
-            T* object_;                     //!< The object
-            ObjectListElement* next_;       //!< The next element in the list
-            ObjectListElement* prev_;       //!< The previous element in the list
-    };
-
-    /**
-        @brief Constructor: Creates the list-element with an object.
-        @param object The object to store
-    */
-    template <class T>
-    ObjectListElement<T>::ObjectListElement(T* object)
-    {
-        this->object_ = object;
-        this->next_ = 0;
-        this->prev_ = 0;
-    }
-
-
-    // ###############################
     // ###       ObjectList        ###
     // ###############################
-    //! The ObjectList contains all objects of a given class.
+    //! The ObjectList contains all objects of the given class.
     /**
-        The ObjectList is used by Identifiers to store all objects of a given class.
+        Wraps the ObjectListBase of the corresponding Identifier.
         Use Iterator<class> to iterate through all objects in the list.
     */
@@ -88,96 +57,20 @@
     {
         public:
-            ObjectList();
-            ~ObjectList();
+            /** @brief Returns an Iterator to the first element in the list. @return The Iterator */
+            inline static Iterator<T> begin()
+                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->begin()); }
 
-            ObjectListElement<T>* add(T* object);
+            /** @brief Returns an Iterator to the element after the last element in the list. @return The Iterator */
+            inline static Iterator<T> end()
+                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->end()); }
 
-            /** @brief Returns the first element in the list. @return The first element */
-            inline static Iterator<T> start()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->first_); }
+            /** @brief Returns an Iterator to the last element in the list. @return The Iterator */
+            inline static Iterator<T> rbegin()
+                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->rbegin()); }
 
-            /** @brief Returns the first element in the list. @return The first element */
-            inline static Iterator<T> begin()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->first_); }
-
-            /** @brief Returns the last element in the list. @return The last element */
-            inline static Iterator<T> end()
-                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->last_); }
-
-            inline void registerIterator(Iterator<T>* iterator)
-                { this->iterators_.insert(this->iterators_.end(), (void*)iterator); }
-            inline void unregisterIterator(Iterator<T>* iterator)
-                { this->iterators_.erase((void*)iterator); }
-            void notifyIterators(ObjectListElement<T>* element);
-
-            ObjectListElement<T>* first_;       //!< The first element in the list
-            ObjectListElement<T>* last_;        //!< The last element in the list
-
-        private:
-            std::set<void*> iterators_;  //!< A list of iterators pointing on an element in this list
+            /** @brief Returns an Iterator to the element before the first element in the list. @return The Iterator */
+            inline static Iterator<T> rend()
+                { return Iterator<T>(ClassIdentifier<T>::getIdentifier()->getObjects()->rend()); }
     };
-
-    /**
-        @brief Constructor: Sets default values.
-    */
-    template <class T>
-    ObjectList<T>::ObjectList()
-    {
-        this->first_ = 0;
-        this->last_ = 0;
-    }
-
-    /**
-        @brief Destructor: Deletes all list-elements, but NOT THE OBJECTS.
-    */
-    template <class T>
-    ObjectList<T>::~ObjectList()
-    {
-        ObjectListElement<T>* temp;
-        while (this->first_)
-        {
-            temp = this->first_->next_;
-            delete this->first_;
-            this->first_ = temp;
-        }
-    }
-
-    /**
-        @brief Increases all Iterators that currently point on the given element (because it gets removed).
-        @param element The element that gets removed
-    */
-    template <class T>
-    void ObjectList<T>::notifyIterators(ObjectListElement<T>* element)
-    {
-        for (std::set<void*>::iterator it = this->iterators_.begin(); it != this->iterators_.end(); ++it)
-            if ((*(*((Iterator<T>*)(*it)))) == element->object_)
-                ++(*((Iterator<T>*)(*it)));
-    }
-
-    /**
-        @brief Adds a new object to the end of the list.
-        @param object The object to add
-        @return The pointer to the new ObjectListElement, needed by the MetaObjectList of the added object
-    */
-    template <class T>
-    ObjectListElement<T>* ObjectList<T>::add(T* object)
-    {
-        if (!this->last_)
-        {
-            // If the list is empty
-            this->last_ = new ObjectListElement<T>(object);
-            this->first_ = this->last_; // There's only one object in the list now
-        }
-        else
-        {
-            // If the list isn't empty
-            ObjectListElement<T>* temp = this->last_;
-            this->last_ = new ObjectListElement<T>(object);
-            this->last_->prev_ = temp;
-            temp->next_ = this->last_;
-        }
-
-        return this->last_;
-    }
 }
 
Index: /code/branches/core3/src/core/ObjectListBase.cc
===================================================================
--- /code/branches/core3/src/core/ObjectListBase.cc	(revision 1574)
+++ /code/branches/core3/src/core/ObjectListBase.cc	(revision 1574)
@@ -0,0 +1,106 @@
+/*
+ *   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 ObjectListBase.cc
+    @brief Implementation of the ObjectListBase class.
+
+    The ObjectListBase is a double-linked list, used by Identifiers to store all objects of a given class.
+    Newly created objects are added through the RegisterObject-macro in its constructor.
+*/
+
+#include <set>
+
+#include "CorePrereqs.h"
+
+#include "ObjectListBase.h"
+#include "Identifier.h"
+#include "IteratorBase.h"
+
+namespace orxonox
+{
+    /**
+        @brief Constructor: Sets default values.
+    */
+    ObjectListBase::ObjectListBase(Identifier* identifier)
+    {
+        this->identifier_ = identifier;
+        this->first_ = 0;
+        this->last_ = 0;
+    }
+
+    /**
+        @brief Destructor: Deletes all list-elements, but NOT THE OBJECTS.
+    */
+    ObjectListBase::~ObjectListBase()
+    {
+        ObjectListBaseElement* temp;
+        while (this->first_)
+        {
+            temp = this->first_->next_;
+            delete this->first_;
+            this->first_ = temp;
+        }
+    }
+
+    /**
+        @brief Increases all Iterators that currently point on the given element (because it gets removed).
+        @param element The element that gets removed
+    */
+    void ObjectListBase::notifyIterators(ObjectListBaseElement* element)
+    {
+        for (std::set<IteratorBase*>::iterator it = this->iterators_.begin(); it != this->iterators_.end(); ++it)
+            if ((*(*(*it))) == element->object_)
+                ++(*(*it));
+    }
+
+    /**
+        @brief Adds a new object to the end of the list.
+        @param object The object to add
+        @return The pointer to the new ObjectListBaseElement, needed by the MetaObjectList of the added object
+    */
+    ObjectListBaseElement* ObjectListBase::add(OrxonoxClass* object)
+    {
+        if (!this->last_)
+        {
+            // If the list is empty
+            this->last_ = new ObjectListBaseElement(object);
+            this->first_ = this->last_; // There's only one object in the list now
+        }
+        else
+        {
+            // If the list isn't empty
+            ObjectListBaseElement* temp = this->last_;
+            this->last_ = new ObjectListBaseElement(object);
+            this->last_->prev_ = temp;
+            temp->next_ = this->last_;
+        }
+
+        return this->last_;
+    }
+}
Index: /code/branches/core3/src/core/ObjectListBase.h
===================================================================
--- /code/branches/core3/src/core/ObjectListBase.h	(revision 1574)
+++ /code/branches/core3/src/core/ObjectListBase.h	(revision 1574)
@@ -0,0 +1,108 @@
+/*
+ *   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 ObjectListBase.h
+    @brief Definition of the ObjectListBase class.
+
+    The ObjectListBase is a double-linked list, used by Identifiers to store all objects of a given class.
+    Newly created objects are added through the RegisterObject-macro in its constructor.
+*/
+
+#ifndef _ObjectListBase_H__
+#define _ObjectListBase_H__
+
+#include <set>
+
+#include "CorePrereqs.h"
+
+namespace orxonox
+{
+    // ###############################
+    // ###  ObjectListBaseElement  ###
+    // ###############################
+    //! The list-element of the ObjectListBase
+    class _CoreExport ObjectListBaseElement
+    {
+        public:
+            /**
+                @brief Constructor: Creates the list-element with an object.
+                @param object The object to store
+            */
+            ObjectListBaseElement(OrxonoxClass* object) : object_(object), next_(0), prev_(0) {}
+
+            OrxonoxClass* object_;              //!< The object
+            ObjectListBaseElement* next_;       //!< The next element in the list
+            ObjectListBaseElement* prev_;       //!< The previous element in the list
+    };
+
+
+    // ###############################
+    // ###     ObjectListBase      ###
+    // ###############################
+    //! The ObjectListBase contains all objects of a given class.
+    /**
+        The ObjectListBase is used by Identifiers to store all objects of their given class.
+        Use ObjectList<T> to get the list of all T's and Iterator<T> to iterate through them.
+    */
+    class _CoreExport ObjectListBase
+    {
+        friend class MetaObjectListElement;
+
+        public:
+            ObjectListBase(Identifier* identifier);
+            ~ObjectListBase();
+
+            ObjectListBaseElement* add(OrxonoxClass* object);
+
+            /** @brief Returns a pointer to the first element in the list. @return The element */
+            inline ObjectListBaseElement* begin() const { return this->first_; }
+            /** @brief Returns a pointer to the element after the last element in the list. @return The element */
+            inline ObjectListBaseElement* end() const { return 0; }
+            /** @brief Returns a pointer to the last element in the list. @return The element */
+            inline ObjectListBaseElement* rbegin() const { return this->last_; }
+            /** @brief Returns a pointer to the element in front of the first element in the list. @return The element */
+            inline ObjectListBaseElement* rend() const { return 0; }
+
+            inline void registerIterator(IteratorBase* iterator)
+                { this->iterators_.insert(this->iterators_.end(), iterator); }
+            inline void unregisterIterator(IteratorBase* iterator)
+                { this->iterators_.erase(iterator); }
+            void notifyIterators(ObjectListBaseElement* element);
+
+            inline Identifier* getIdentifier() const { return this->identifier_; }
+
+        private:
+            Identifier* identifier_;             //!< The Iterator owning this list
+            ObjectListBaseElement* first_;       //!< The first element in the list
+            ObjectListBaseElement* last_;        //!< The last element in the list
+            std::set<IteratorBase*> iterators_;  //!< A list of iterators pointing on an element in this list
+    };
+}
+
+#endif /* _ObjectListBase_H__ */
Index: /code/branches/core3/src/core/OrxonoxClass.cc
===================================================================
--- /code/branches/core3/src/core/OrxonoxClass.cc	(revision 1573)
+++ /code/branches/core3/src/core/OrxonoxClass.cc	(revision 1574)
@@ -39,8 +39,8 @@
 {
     /** @brief Constructor: Sets the default values. */
-    OrxonoxClass::OrxonoxClass() :
-      identifier_(0),
-      parents_(0)
+    OrxonoxClass::OrxonoxClass()
     {
+        this->identifier_ = 0;
+        this->parents_ = 0;
         this->metaList_ = new MetaObjectList();
 
Index: /code/branches/core3/src/network/ConnectionManager.cc
===================================================================
--- /code/branches/core3/src/network/ConnectionManager.cc	(revision 1573)
+++ /code/branches/core3/src/network/ConnectionManager.cc	(revision 1574)
@@ -64,8 +64,8 @@
 {
   //boost::thread_group network_threads;
-  
+
   ConnectionManager::ConnectionManager():receiverThread_(0){}
   boost::recursive_mutex ConnectionManager::enet_mutex_;
-  
+
   ConnectionManager::ConnectionManager(ClientInformation *head) : receiverThread_(0) {
     quit=false;
@@ -74,5 +74,5 @@
     head_ = head;
   }
-  
+
   ConnectionManager::ConnectionManager(ClientInformation *head, int port){
     quit=false;
@@ -115,5 +115,5 @@
     return packet;
   }*/
-  
+
   ENetEvent *ConnectionManager::getEvent(){
     if(!buffer.isEmpty())
@@ -251,5 +251,5 @@
     }
   }
-  
+
   //### added some bugfixes here, but we cannot test them because
   //### the server crashes everytime because of some gamestates
@@ -333,10 +333,10 @@
   }
 
-  
-  
+
+
   bool ConnectionManager::removeShip(ClientInformation *client){
     int id=client->getShipID();
     orxonox::Iterator<orxonox::SpaceShip> it;
-    for(it = orxonox::ObjectList<orxonox::SpaceShip>::start(); it; ++it){
+    for(it = orxonox::ObjectList<orxonox::SpaceShip>::begin(); it; ++it){
       if(it->objectID!=id)
         continue;
@@ -345,5 +345,5 @@
     return true;
   }
-  
+
   bool ConnectionManager::sendWelcome(int clientID, int shipID, bool allowed){
     if(addPacket(packet_gen.generateWelcome(clientID, shipID, allowed),clientID)){
@@ -353,5 +353,5 @@
       return false;
   }
-  
+
   void ConnectionManager::disconnectClient(ClientInformation *client){
     {
@@ -362,5 +362,5 @@
     removeShip(client);
   }
-  
+
   bool ConnectionManager::addFakeConnectRequest(ENetEvent *ev){
     ENetEvent event;
@@ -369,6 +369,6 @@
     return buffer.push(&event);
   }
-  
-  
+
+
 
 }
Index: /code/branches/core3/src/network/GameStateClient.cc
===================================================================
--- /code/branches/core3/src/network/GameStateClient.cc	(revision 1573)
+++ /code/branches/core3/src/network/GameStateClient.cc	(revision 1574)
@@ -151,5 +151,5 @@
     COUT(4) << "loadSnapshot: loading gs: " << state->id << std::endl;
     // get the start of the Synchronisable list
-    orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::start();
+    orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::begin();
     syncData sync;
     // loop as long as we have some data ;)
@@ -236,5 +236,5 @@
     int offset=0, size=0;
     // get total size of gamestate
-    for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+    for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
       if(!it->getBacksync())
         continue;
@@ -253,5 +253,5 @@
     memsize=size;
     // go through all Synchronisables
-    for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+    for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
       if(!it->getBacksync())
         continue;
Index: /code/branches/core3/src/network/GameStateManager.cc
===================================================================
--- /code/branches/core3/src/network/GameStateManager.cc	(revision 1573)
+++ /code/branches/core3/src/network/GameStateManager.cc	(revision 1574)
@@ -70,5 +70,5 @@
     return;
   }
-  
+
   void GameStateManager::addGameState(GameStateCompressed *gs, int clientID){
     if(!gs)
@@ -83,5 +83,5 @@
     return;
   }
-  
+
   void GameStateManager::processGameStates(){
     std::map<int, GameStateCompressed*>::iterator it;
@@ -93,11 +93,11 @@
     gameStateQueue.clear();
   }
-  
-  
+
+
   /**
    * this function is used to keep the memory usage low
    * it tries to delete all the unused gamestates
-   * 
-   * 
+   *
+   *
    */
   void GameStateManager::cleanup(){
@@ -155,5 +155,5 @@
     }
   }
-  
+
   bool GameStateManager::pushGameState( GameStateCompressed *gs, int clientID ){
     GameState *ugs = decompress(gs);
@@ -190,5 +190,5 @@
     int offset=0, size=0;
     // get total size of gamestate
-    for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+    for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
       size+=it->getSize(); // size of the actual data of the synchronisable
       size+=3*sizeof(int); // size of datasize, classID and objectID
@@ -204,5 +204,5 @@
     memsize=size;
     // go through all Synchronisables
-    for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+    for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
       //get size of the synchronisable
       tempsize=it->getSize();
@@ -246,5 +246,5 @@
     COUT(4) << "loadSnapshot: loading gs: " << state->id << std::endl;
     // get the start of the Synchronisable list
-    orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::start();
+    orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::begin();
     syncData sync;
     /*ClientInformation *client = head_->findClient(clientID);
@@ -308,6 +308,6 @@
     return true;
   }
-  
-  
+
+
   //##### ADDED FOR TESTING PURPOSE #####
   GameStateCompressed* GameStateManager::testCompress( GameState* g ) {
@@ -405,5 +405,5 @@
     switch ( retval ) {
       case Z_OK: COUT(5) << "G.St.Man: compress: successfully compressed" << std::endl; break;
-      case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl; 
+      case Z_MEM_ERROR: COUT(1) << "G.St.Man: compress: not enough memory available in gamestate.compress" << std::endl;
       return NULL;
       case Z_BUF_ERROR: COUT(2) << "G.St.Man: compress: not enough memory available in the buffer in gamestate.compress" << std::endl;
@@ -426,5 +426,5 @@
     return compressedGamestate;
   }
-  
+
   GameState *GameStateManager::decompress(GameStateCompressed *a) {
     //COUT(4) << "GameStateClient: uncompressing gamestate. id: " << a->id << ", baseid: " << a->base_id << ", normsize: " << a->normsize << ", compsize: " << a->compsize << std::endl;
@@ -464,5 +464,5 @@
     return gamestate;
   }
-  
+
 
   void GameStateManager::ackGameState(int clientID, int gamestateID) {
@@ -471,5 +471,5 @@
       return;
     int curid = temp->getGamestateID();
-    
+
     if(gamestateID == GAMESTATEID_INITIAL){
       temp->setGameStateID(GAMESTATEID_INITIAL);
@@ -481,5 +481,5 @@
     }
     if(curid > gamestateID)
-      // the network packets got messed up 
+      // the network packets got messed up
       return;
     COUT(4) << "acking gamestate " << gamestateID << " for clientid: " << clientID << " curid: " << curid << std::endl;
@@ -512,5 +512,5 @@
     return true;
   }
-  
+
   bool GameStateManager::checkAccess(int clientID, int objectID){
     // currently we only check, wheter the object is the clients spaceship
@@ -518,5 +518,5 @@
     return true; // TODO: change this
   }
-  
+
   void GameStateManager::removeClient(ClientInformation* client){
     if(!client)
Index: /code/branches/core3/src/network/Server.cc
===================================================================
--- /code/branches/core3/src/network/Server.cc	(revision 1573)
+++ /code/branches/core3/src/network/Server.cc	(revision 1574)
@@ -57,7 +57,7 @@
   #define MAX_FAILURES 20;
   #define NETWORK_FREQUENCY 30
-  
+
   Server *Server::instance_=0;
-  
+
   Server *Server::createSingleton(){
     if(!instance_)
@@ -80,10 +80,10 @@
     return instance_;
   }
-  
+
   Server *Server::getSingleton(){
     return instance_;
   }
-  
-  
+
+
   /**
   * Constructor for default values (bindaddress is set to ENET_HOST_ANY
@@ -97,5 +97,5 @@
     gamestates = new GameStateManager(clients);
   }
-  
+
   Server::Server(int port){
     timeSinceLastUpdate_=0;
@@ -217,5 +217,5 @@
         if(clients->findClient(&event->peer->address)){
           clientID = clients->findClient(&event->peer->address)->getID();
-          if( !elaborate(event->packet, clientID) ) 
+          if( !elaborate(event->packet, clientID) )
             COUT(3) << "Server: could not elaborate" << std::endl;
         }
@@ -276,5 +276,5 @@
 	continue;
       if ( !(connection->addPacket(packet, cid)) ){
-        COUT(3) << "Server: packet with client id (cid): " << cid << " not sended: " << temp->getFailures() << std::endl; 
+        COUT(3) << "Server: packet with client id (cid): " << cid << " not sended: " << temp->getFailures() << std::endl;
         temp->addFailure();
         /*if(temp->getFailures() > 0 )
@@ -302,5 +302,5 @@
     delete data;
   }
-  
+
   bool Server::processConnectRequest( connectRequest *con, int clientID ){
     //(COUT(3) << "processing connectRequest " << std::endl;
@@ -310,5 +310,5 @@
     return true;
   }
-  
+
   void Server::processGamestate( GameStateCompressed *data, int clientID){
     COUT(4) << "processing partial gamestate from client " << clientID << std::endl;
@@ -319,5 +319,5 @@
         clients->findClient(clientID)->resetFailures();*/
   }
-  
+
   void Server::processChat( chat *data, int clientId){
     char *message = new char [strlen(data->message)+10+1];
@@ -329,5 +329,5 @@
     delete data;
   }
-  
+
   bool Server::addClient(ENetEvent *event){
     ClientInformation *temp = clients->insertBack(new ClientInformation);
@@ -346,5 +346,5 @@
     return createClient(temp->getID());
   }
-  
+
   bool Server::createClient(int clientID){
     ClientInformation *temp = clients->findClient(clientID);
@@ -366,5 +366,5 @@
     return true;
   }
-  
+
   bool Server::createShip(ClientInformation *client){
     if(!client)
@@ -390,15 +390,15 @@
     no->classID = id->getNetworkID();
     no->create();
-    
+
     client->setShipID(no->objectID);
     return true;
   }
-  
+
   bool Server::disconnectClient(ENetEvent *event){
     COUT(4) << "removing client from list" << std::endl;
     //return removeClient(head_->findClient(&(peer->address))->getID());
-    
+
     //boost::recursive_mutex::scoped_lock lock(head_->mutex_);
-    orxonox::Iterator<orxonox::SpaceShip> it = orxonox::ObjectList<orxonox::SpaceShip>::start();
+    orxonox::Iterator<orxonox::SpaceShip> it = orxonox::ObjectList<orxonox::SpaceShip>::begin();
     ClientInformation *client = clients->findClient(&event->peer->address);
     if(!client)
@@ -426,4 +426,4 @@
     gamestates->removeClient(client);
   }
-  
+
 }
Index: /code/branches/core3/src/orxonox/Orxonox.cc
===================================================================
--- /code/branches/core3/src/orxonox/Orxonox.cc	(revision 1573)
+++ /code/branches/core3/src/orxonox/Orxonox.cc	(revision 1574)
@@ -462,8 +462,8 @@
       Core::tick((float)evt.timeSinceLastFrame);
       // Call those objects that need the real time
-      for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+      for (Iterator<TickableReal> it = ObjectList<TickableReal>::begin(); it; ++it)
         it->tick((float)evt.timeSinceLastFrame);
       // Call the scene objects
-      for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+      for (Iterator<Tickable> it = ObjectList<Tickable>::begin(); it; ++it)
         it->tick((float)evt.timeSinceLastFrame * this->timefactor_);
       //AudioManager::tick();
Index: /code/branches/core3/src/orxonox/objects/NPC.cc
===================================================================
--- /code/branches/core3/src/orxonox/objects/NPC.cc	(revision 1573)
+++ /code/branches/core3/src/orxonox/objects/NPC.cc	(revision 1574)
@@ -61,10 +61,10 @@
     movable_ = movable;
   }
-  
+
   void NPC::registerAllVariables(){
     Model::registerAllVariables();
     registerVar(&movable_, sizeof(movable_), network::DATA);
   }
-  
+
 
   /**
@@ -117,5 +117,5 @@
     int numberOfNeighbour = 0;  //number of observed neighbours
     float distance = 0;  // distance to the actual element
-    for(Iterator<WorldEntity> it = ObjectList<WorldEntity>::start(); it; ++it) {  //go through all elements
+    for(Iterator<WorldEntity> it = ObjectList<WorldEntity>::begin(); it; ++it) {  //go through all elements
       distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < SEPERATIONDISTANCE)) {  //do only if actual is inside detectionradius
@@ -144,5 +144,5 @@
     //float distance = 0;
     //go through all elements
-    for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) {  //just working with 3 elements at the moment
+    for(Iterator<NPC> it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
       float distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < ALIGNMENTDISTANCE)) {  //check if actual element is inside detectionradius
@@ -164,5 +164,5 @@
     //float distance = 0;
     //go through all elements
-    for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) {  //just working with 3 elements at the moment
+    for(Iterator<NPC> it = ObjectList<NPC>::begin(); it; ++it) {  //just working with 3 elements at the moment
       float distance = getDistance(*it);  //get distance between this and actual
       if ((distance > 0) && (distance < COHESIONDISTANCE)) {  //check if actual element is inside detectionradius
Index: /code/branches/core3/src/orxonox/objects/Projectile.cc
===================================================================
--- /code/branches/core3/src/orxonox/objects/Projectile.cc	(revision 1573)
+++ /code/branches/core3/src/orxonox/objects/Projectile.cc	(revision 1574)
@@ -86,5 +86,5 @@
 
         float radius;
-        for (Iterator<Model> it = ObjectList<Model>::start(); it; ++it)
+        for (Iterator<Model> it = ObjectList<Model>::begin(); it; ++it)
         {
             if ((*it) != this->owner_)
Index: /code/branches/core3/src/orxonox/objects/SpaceShip.cc
===================================================================
--- /code/branches/core3/src/orxonox/objects/SpaceShip.cc	(revision 1573)
+++ /code/branches/core3/src/orxonox/objects/SpaceShip.cc	(revision 1574)
@@ -72,5 +72,5 @@
     SpaceShip *SpaceShip::getLocalShip(){
       Iterator<SpaceShip> it;
-      for(it = ObjectList<SpaceShip>::start(); it; ++it){
+      for(it = ObjectList<SpaceShip>::begin(); it; ++it){
         if( (it)->myShip_ )
           return *it;
