Index: code/trunk/src/audio/AudioIncludes.h
===================================================================
--- code/trunk/src/audio/AudioIncludes.h	(revision 1740)
+++ code/trunk/src/audio/AudioIncludes.h	(revision 1747)
@@ -47,3 +47,3 @@
 #include <vorbis/vorbisfile.h>
 
-#include "core/Error.h"
+#include "util/Error.h"
Index: code/trunk/src/audio/AudioManager.cc
===================================================================
--- code/trunk/src/audio/AudioManager.cc	(revision 1740)
+++ code/trunk/src/audio/AudioManager.cc	(revision 1747)
@@ -36,6 +36,6 @@
 #include "AudioSource.h"
 #include "AudioStream.h"
-#include "core/Error.h"
-#include "core/Debug.h"
+#include "util/Error.h"
+#include "util/Debug.h"
 
 namespace audio
Index: code/trunk/src/audio/AudioManager.h
===================================================================
--- code/trunk/src/audio/AudioManager.h	(revision 1740)
+++ code/trunk/src/audio/AudioManager.h	(revision 1747)
@@ -58,7 +58,4 @@
 		void setOri(std::vector<float> at, std::vector<float> up);
 
-		// Parses given xml string
-		void loadParams();
-
 		// Update
 		void tick(float dt);
Index: code/trunk/src/audio/AudioStream.cc
===================================================================
--- code/trunk/src/audio/AudioStream.cc	(revision 1740)
+++ code/trunk/src/audio/AudioStream.cc	(revision 1747)
@@ -28,6 +28,6 @@
 #include "AudioStream.h"
 
-#include "core/Debug.h"
-#include "core/Error.h"
+#include "util/Debug.h"
+#include "util/Error.h"
 
 namespace audio
Index: code/trunk/src/core/BaseObject.h
===================================================================
--- code/trunk/src/core/BaseObject.h	(revision 1740)
+++ code/trunk/src/core/BaseObject.h	(revision 1747)
@@ -39,6 +39,7 @@
 #include "CorePrereqs.h"
 
+#include "Super.h"
+#include "OrxonoxClass.h"
 #include "util/XMLIncludes.h"
-#include "OrxonoxClass.h"
 
 namespace orxonox
@@ -101,4 +102,8 @@
             Namespace* namespace_;
     };
+
+    SUPER_FUNCTION(0, BaseObject, XMLPort, false);
+    SUPER_FUNCTION(2, BaseObject, changedActivity, false);
+    SUPER_FUNCTION(3, BaseObject, changedVisibility, false);
 }
 
Index: code/trunk/src/core/CMakeLists.txt
===================================================================
--- code/trunk/src/core/CMakeLists.txt	(revision 1740)
+++ code/trunk/src/core/CMakeLists.txt	(revision 1747)
@@ -3,11 +3,8 @@
   ConfigValueContainer.cc
   Core.cc
-  Error.cc
   Language.cc
+  ObjectListBase.cc
   OrxonoxClass.cc
-  OutputBuffer.cc
-  OutputHandler.cc
   Script.cc
-  SignalHandler.cc
 
   # command
Index: code/trunk/src/core/ClassFactory.h
===================================================================
--- code/trunk/src/core/ClassFactory.h	(revision 1740)
+++ code/trunk/src/core/ClassFactory.h	(revision 1747)
@@ -43,5 +43,5 @@
 #include "Factory.h"
 #include "Identifier.h"
-#include "Debug.h"
+#include "util/Debug.h"
 
 namespace orxonox
@@ -74,5 +74,5 @@
     {
         COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
-        ClassIdentifier<T>::getIdentifier()->addFactory(new ClassFactory<T>);
+        ClassIdentifier<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
         Factory::add(name, ClassIdentifier<T>::getIdentifier());
 
Index: code/trunk/src/core/ClassTreeMask.h
===================================================================
--- code/trunk/src/core/ClassTreeMask.h	(revision 1740)
+++ code/trunk/src/core/ClassTreeMask.h	(revision 1747)
@@ -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/trunk/src/core/CommandEvaluation.cc
===================================================================
--- code/trunk/src/core/CommandEvaluation.cc	(revision 1740)
+++ code/trunk/src/core/CommandEvaluation.cc	(revision 1747)
@@ -30,5 +30,5 @@
 #include "ConsoleCommand.h"
 #include "Identifier.h"
-#include "Debug.h"
+#include "util/Debug.h"
 #include "util/String.h"
 
@@ -218,5 +218,5 @@
     }
 
-    void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiTypeMath param)
+    void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiType param)
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -224,5 +224,5 @@
     }
 
-    MultiTypeMath CommandEvaluation::getEvaluatedParameter(unsigned int index) const
+    MultiType CommandEvaluation::getEvaluatedParameter(unsigned int index) const
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -240,10 +240,10 @@
     }
 
-    MultiTypeMath CommandEvaluation::getReturnvalue() const
+    MultiType CommandEvaluation::getReturnvalue() const
     {
         if (this->function_)
             return this->function_->getReturnvalue();
 
-        return MultiTypeMath();
+        return MultiType();
     }
 
@@ -304,5 +304,5 @@
 
             if (command->defaultValueSet(i))
-                output += "=" + command->getDefaultValue(i).toString() + "]";
+                output += "=" + command->getDefaultValue(i).getString() + "]";
             else
                 output += "}";
Index: code/trunk/src/core/CommandEvaluation.h
===================================================================
--- code/trunk/src/core/CommandEvaluation.h	(revision 1740)
+++ code/trunk/src/core/CommandEvaluation.h	(revision 1747)
@@ -37,5 +37,5 @@
 #include "ArgumentCompletionListElement.h"
 #include "util/SubString.h"
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 
 namespace orxonox
@@ -81,9 +81,9 @@
                 { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
 
-            void setEvaluatedParameter(unsigned int index, MultiTypeMath param);
-            MultiTypeMath getEvaluatedParameter(unsigned int index) const;
+            void setEvaluatedParameter(unsigned int index, MultiType param);
+            MultiType getEvaluatedParameter(unsigned int index) const;
 
             bool hasReturnvalue() const;
-            MultiTypeMath getReturnvalue() const;
+            MultiType getReturnvalue() const;
 
         private:
@@ -115,5 +115,5 @@
 
             bool bEvaluatedParams_;
-            MultiTypeMath param_[5];
+            MultiType param_[5];
     };
 }
Index: code/trunk/src/core/CommandExecutor.cc
===================================================================
--- code/trunk/src/core/CommandExecutor.cc	(revision 1740)
+++ code/trunk/src/core/CommandExecutor.cc	(revision 1747)
@@ -31,7 +31,7 @@
 #include "util/String.h"
 #include "util/Convert.h"
+#include "util/Debug.h"
 #include "Identifier.h"
 #include "Language.h"
-#include "Debug.h"
 #include "TclBind.h"
 
Index: code/trunk/src/core/ConfigFileManager.cc
===================================================================
--- code/trunk/src/core/ConfigFileManager.cc	(revision 1740)
+++ code/trunk/src/core/ConfigFileManager.cc	(revision 1747)
@@ -38,10 +38,10 @@
 namespace orxonox
 {
-    SetConsoleCommandShortcutExtern(config).setArgumentCompleter(0, autocompletion::configvalueclasses()).setArgumentCompleter(1, autocompletion::configvalues()).setArgumentCompleter(2, autocompletion::configvalue());
-    SetConsoleCommandShortcutExtern(tconfig).setArgumentCompleter(0, autocompletion::configvalueclasses()).setArgumentCompleter(1, autocompletion::configvalues()).setArgumentCompleter(2, autocompletion::configvalue());
+    SetConsoleCommandShortcutExtern(config).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
+    SetConsoleCommandShortcutExtern(tconfig).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
     SetConsoleCommandShortcutExtern(reloadConfig);
     SetConsoleCommandShortcutExtern(cleanConfig);
-    SetConsoleCommandShortcutExtern(loadSettings).setArgumentCompleter(0, autocompletion::files());
-    SetConsoleCommandShortcutExtern(loadKeybindings).setArgumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(loadSettings).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(loadKeybindings).argumentCompleter(0, autocompletion::files());
 
     bool config(const std::string& classname, const std::string& varname, const std::string& value)
@@ -71,20 +71,20 @@
     void reloadConfig()
     {
-        ConfigFileManager::getSingleton()->load();
+        ConfigFileManager::getInstance()->load();
     }
 
     void cleanConfig()
     {
-        ConfigFileManager::getSingleton()->clean(false);
+        ConfigFileManager::getInstance()->clean(false);
     }
 
     void loadSettings(const std::string& filename)
     {
-        ConfigFileManager::getSingleton()->setFile(CFT_Settings, filename, false);
+        ConfigFileManager::getInstance()->setFile(CFT_Settings, filename, false);
     }
 
     void loadKeybindings(const std::string& filename)
     {
-        ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, filename);
+        ConfigFileManager::getInstance()->setFile(CFT_Keybindings, filename);
     }
 
@@ -327,5 +327,5 @@
         file.close();
 
-        COUT(3) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
+        COUT(0) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
 
         // Save the file in case something changed (like stripped whitespaces)
@@ -459,5 +459,5 @@
     }
 
-    ConfigFileManager* ConfigFileManager::getSingleton()
+    ConfigFileManager* ConfigFileManager::getInstance()
     {
         static ConfigFileManager instance;
Index: code/trunk/src/core/ConfigFileManager.h
===================================================================
--- code/trunk/src/core/ConfigFileManager.h	(revision 1740)
+++ code/trunk/src/core/ConfigFileManager.h	(revision 1747)
@@ -258,5 +258,5 @@
     {
         public:
-            static ConfigFileManager* getSingleton();
+            static ConfigFileManager* getInstance();
 
             void setFile(ConfigFileType type, const std::string& filename, bool bCreateIfNotExisting = true);
Index: code/trunk/src/core/ConfigValueContainer.cc
===================================================================
--- code/trunk/src/core/ConfigValueContainer.cc	(revision 1740)
+++ code/trunk/src/core/ConfigValueContainer.cc	(revision 1747)
@@ -47,11 +47,7 @@
 {
     /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param type The type of the corresponding config-file
-        @param identifier The identifier of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue)
+        @brief Initializes the ConfigValueContainer with defaultvalues.
+    */
+    void ConfigValueContainer::init(ConfigFileType type, Identifier* identifier, const std::string& varname)
     {
         this->type_ = type;
@@ -59,43 +55,45 @@
         this->sectionname_ = identifier->getName();
         this->varname_ = varname;
-
+        this->callback_ = 0;
+        this->bContainerIsNew_ = true;
+        this->bDoInitialCallback_ = false;
+        this->bAddedDescription_ = false;
+    }
+
+    /**
+        @brief Does some special initialization for single config-values.
+    */
+    void ConfigValueContainer::initValue(const MultiType& defvalue)
+    {
         this->value_ = defvalue;
-        this->bAddedDescription_ = false;
         this->bIsVector_ = false;
 
-        this->defvalueString_ = defvalue.toString();
+        this->defvalueString_ = this->value_.getString();
         this->update();
     }
 
     /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param type The type of the corresponding config-file
-        @param identifier The identifier of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<MultiTypeMath>& defvalue)
-    {
-        this->type_ = type;
-        this->identifier_ = identifier;
-        this->sectionname_ = identifier->getName();
-        this->varname_ = varname;
-
-        this->valueVector_ = defvalue;
-        this->bAddedDescription_ = false;
+        @brief Does some special initialization for vector config-values.
+    */
+    void ConfigValueContainer::initVector()
+    {
         this->bIsVector_ = true;
 
-        if (defvalue.size() > 0)
-        {
-                this->value_ = defvalue[0];
-
-            for (unsigned int i = 0; i < defvalue.size(); i++)
-            {
-                ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, defvalue[i].toString(), this->value_.isA(MT_string));
-                this->defvalueStringVector_.push_back(defvalue[i].toString());
-            }
-
-            this->update();
-        }
+        for (unsigned int i = 0; i < this->valueVector_.size(); i++)
+        {
+            ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
+            this->defvalueStringVector_.push_back(this->valueVector_[i]);
+        }
+
+        this->update();
+    }
+
+    /**
+        @brief Destructor: Deletes the callback object if necessary.
+    */
+    ConfigValueContainer::~ConfigValueContainer()
+    {
+        if (this->callback_)
+            delete this->callback_;
     }
 
@@ -105,9 +103,9 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::set(const MultiTypeMath& input)
-    {
-        if (this->bIsVector_)
-        {
-            return this->callFunctionWithIndex(&ConfigValueContainer::set, input.toString());
+    bool ConfigValueContainer::set(const MultiType& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::set, input);
         }
         else
@@ -115,5 +113,5 @@
             if (this->tset(input))
             {
-                ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, input.toString(), this->value_.isA(MT_string));
+                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, input, this->value_.isType(MT_string));
                 return true;
             }
@@ -128,5 +126,5 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::set(unsigned int index, const MultiTypeMath& input)
+    bool ConfigValueContainer::set(unsigned int index, const MultiType& input)
     {
         if (this->bIsVector_)
@@ -134,5 +132,5 @@
             if (this->tset(index, input))
             {
-                ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, index, input.toString(), this->value_.isA(MT_string));
+                ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, index, input, this->value_.isType(MT_string));
                 return true;
             }
@@ -150,23 +148,20 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::tset(const MultiTypeMath& input)
-    {
-        if (this->bIsVector_)
-        {
-            return this->callFunctionWithIndex(&ConfigValueContainer::tset, input.toString());
-        }
-        else
-        {
-            MultiTypeMath temp = this->value_;
-            if (temp.assimilate(input))
-            {
-                this->value_ = temp;
-                if (this->identifier_)
-                    this->identifier_->updateConfigValues();
-
-                return true;
-            }
-        }
-        return false;
+    bool ConfigValueContainer::tset(const MultiType& input)
+    {
+        if (this->bIsVector_)
+        {
+            return this->callFunctionWithIndex(&ConfigValueContainer::tset, input);
+            return false;
+        }
+        else
+        {
+            this->value_ = input;
+
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+
+            return true;
+        }
     }
 
@@ -177,5 +172,5 @@
         @return True if the new value was successfully assigned
     */
-    bool ConfigValueContainer::tset(unsigned int index, const MultiTypeMath& input)
+    bool ConfigValueContainer::tset(unsigned int index, const MultiType& input)
     {
         if (this->bIsVector_)
@@ -191,24 +186,20 @@
                 for (unsigned int i = this->valueVector_.size(); i <= index; i++)
                 {
-                    this->valueVector_.push_back(MultiTypeMath());
+                    this->valueVector_.push_back(MultiType());
                 }
             }
 
-            MultiTypeMath temp = this->value_;
-            if (temp.assimilate(input))
-            {
-                this->valueVector_[index] = temp;
-
-                if (this->identifier_)
-                    this->identifier_->updateConfigValues();
-
-                return true;
-            }
+            this->valueVector_[index] = input;
+
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+
+            return true;
         }
         else
         {
             COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
-        }
-        return false;
+            return false;
+        }
     }
 
@@ -218,5 +209,5 @@
         @return True if the new entry was successfully added
     */
-    bool ConfigValueContainer::add(const MultiTypeMath& input)
+    bool ConfigValueContainer::add(const MultiType& input)
     {
         if (this->bIsVector_)
@@ -241,6 +232,6 @@
                 this->valueVector_.erase(this->valueVector_.begin() + index);
                 for (unsigned int i = index; i < this->valueVector_.size(); i++)
-                    ConfigFileManager::getSingleton()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isA(MT_string));
-                ConfigFileManager::getSingleton()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
+                    ConfigFileManager::getInstance()->setValue(this->type_, this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_string));
+                ConfigFileManager::getInstance()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->valueVector_.size());
 
                 return true;
@@ -266,5 +257,5 @@
                 if (!this->set(i, this->defvalueStringVector_[i]))
                     success = false;
-            ConfigFileManager::getSingleton()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->defvalueStringVector_.size());
+            ConfigFileManager::getInstance()->deleteVectorEntries(this->type_, this->sectionname_, this->varname_, this->defvalueStringVector_.size());
             return success;
         }
@@ -277,17 +268,17 @@
     {
         if (!this->bIsVector_)
-            this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isA(MT_string)));
+            this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_string));
         else
         {
             this->valueVector_.clear();
-            for (unsigned int i = 0; i < ConfigFileManager::getSingleton()->getVectorSize(this->type_, this->sectionname_, this->varname_); i++)
+            for (unsigned int i = 0; i < ConfigFileManager::getInstance()->getVectorSize(this->type_, this->sectionname_, this->varname_); i++)
             {
                 if (i < this->defvalueStringVector_.size())
                 {
-                    this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isA(MT_string)));
+                    this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_string));
                 }
                 else
                 {
-                    this->value_.fromString(ConfigFileManager::getSingleton()->getValue(this->type_, this->sectionname_, this->varname_, i, MultiTypeMath(), this->value_.isA(MT_string)));
+                    this->value_ = ConfigFileManager::getInstance()->getValue(this->type_, this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_string));
                 }
 
@@ -303,5 +294,5 @@
         @return The returnvalue of the functioncall
     */
-    bool ConfigValueContainer::callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiTypeMath&), const std::string& input)
+    bool ConfigValueContainer::callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiType&), const std::string& input)
     {
         SubString token(input, " ", SubString::WhiteSpaces, true, '\\', false, '"', false, '(', ')', false, '\0');
@@ -335,5 +326,5 @@
         @param description The description
     */
-    void ConfigValueContainer::description(const std::string& description)
+    ConfigValueContainer& ConfigValueContainer::description(const std::string& description)
     {
         if (!this->bAddedDescription_)
@@ -343,4 +334,5 @@
             this->bAddedDescription_ = true;
         }
+        return (*this);
     }
 
Index: code/trunk/src/core/ConfigValueContainer.h
===================================================================
--- code/trunk/src/core/ConfigValueContainer.h	(revision 1740)
+++ code/trunk/src/core/ConfigValueContainer.h	(revision 1747)
@@ -50,9 +50,30 @@
 
 #include "util/Math.h"
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "ConfigFileManager.h"
 
 namespace orxonox
 {
+    class ConfigValueCallbackBase
+    {
+        public:
+            virtual void call(void* object) = 0;
+            inline virtual ~ConfigValueCallbackBase() {}
+    };
+
+    template <class T>
+    class ConfigValueCallback: public ConfigValueCallbackBase
+    {
+        public:
+            inline ConfigValueCallback(void (T::*function) (void)) : function_(function) {}
+            inline virtual ~ConfigValueCallback() {}
+            inline virtual void call(void* object)
+                { (((T*)object)->*this->function_)(); }
+
+        private:
+            void (T::*function_) (void);
+    };
+
+
     //! The ConfigValuecontainer contains all needed informations about a configurable variable.
     /**
@@ -74,43 +95,162 @@
     {
         public:
-            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const MultiTypeMath& defvalue);
-            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<MultiTypeMath>& defvalue);
-
-            /** @brief Returns the configured value. @param value This is only needed to determine the right type. @return The value */
-            template <typename T>
-            inline ConfigValueContainer& getValue(T* value)
-                { this->value_.getValue(value); return *this; }
-            template <typename T>
-            inline ConfigValueContainer& getValue(std::vector<T>* value)
-            {
-                value->clear();
-                for (unsigned int i = 0; i < this->valueVector_.size(); i++)
-                    value->push_back(this->valueVector_[i]);
+            /**
+                @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+                @param type The type of the corresponding config-file
+                @param identifier The identifier of the class the variable belongs to
+                @param varname The name of the variable
+                @param defvalue The default-value
+                @param value Only needed do determine the right type.
+            */
+            template <class D, class V>
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const D& defvalue, const V& value)
+            {
+                this->init(type, identifier, varname);
+                this->initValue((V)defvalue);
+            }
+
+            /**
+                @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
+                @param type The type of the corresponding config-file
+                @param identifier The identifier of the class the variable belongs to
+                @param varname The name of the variable
+                @param defvalue The default-value
+            */
+            template <class V>
+            ConfigValueContainer(ConfigFileType type, Identifier* identifier, const std::string& varname, const std::vector<V>& defvalue)
+            {
+                this->init(type, identifier, varname);
+
+                this->value_ = V();
+                for (unsigned int i = 0; i < defvalue.size(); i++)
+                    this->valueVector_.push_back(MultiType(defvalue[i]));
+
+                this->initVector();
+            }
+
+            ~ConfigValueContainer();
+
+            /**
+                @brief Returns the configured value.
+                @param value A pointer to the variable to store the value.
+                @param object The object calling this function
+                @return The ConfigValueContainer
+            */
+            template <typename T, class C>
+            ConfigValueContainer& getValue(T* value, C* object)
+            {
+                if ((this->callback_ && object) || this->bContainerIsNew_)
+                {
+                    if (this->bContainerIsNew_)
+                        this->bContainerIsNew_ = false;
+
+                    T temp = *value;
+                    this->value_.getValue(value);
+                    if ((*value) != temp)
+                    {
+                        if (this->callback_ && object)
+                            this->callback_->call(object);
+                        else
+                            this->bDoInitialCallback_ = true;
+                    }
+                }
+                else
+                {
+                    this->value_.getValue(value);
+                }
                 return *this;
             }
 
-            template <typename T>
-            inline void setVectorType(const std::vector<T>& value)
-            {
-                this->value_ = T();
-                this->update();
-            }
-
+            /**
+                @brief Returns the configured vector.
+                @param value A pointer to the vector to store the values.
+                @param object The object calling this function
+                @return The ConfigValueContainer
+            */
+            template <typename T, class C>
+            ConfigValueContainer& getValue(std::vector<T>* value, C* object)
+            {
+                if ((this->callback_ && object) || this->bContainerIsNew_)
+                {
+                    if (this->bContainerIsNew_)
+                        this->bContainerIsNew_ = false;
+
+                    std::vector<T> temp = *value;
+                    value->clear();
+                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
+                        value->push_back(this->valueVector_[i]);
+
+                    if (value->size() != temp.size())
+                    {
+                        if (this->callback_ && object)
+                            this->callback_->call(object);
+                        else
+                            this->bDoInitialCallback_ = true;
+                    }
+                    else
+                    {
+                        for (unsigned int i = 0; i < value->size(); ++i)
+                        {
+                            if ((*value)[i] != temp[i])
+                            {
+                                if (this->callback_ && object)
+                                    this->callback_->call(object);
+                                else
+                                    this->bDoInitialCallback_ = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    value->clear();
+                    for (unsigned int i = 0; i < this->valueVector_.size(); ++i)
+                        value->push_back(this->valueVector_[i]);
+                }
+                return *this;
+            }
+
+            /** @brief Returns the name of this container. */
             inline const std::string& getName() const
                 { return this->varname_; }
+            /** @brief Returns true if this config-value is a vector */
             inline bool isVector() const
                 { return this->bIsVector_; }
+            /** @brief Returns the vectors size (or zero if it's not a vector). */
             inline unsigned int getVectorSize() const
                 { return this->valueVector_.size(); }
 
-            void description(const std::string& description);
+            ConfigValueContainer& description(const std::string& description);
             const std::string& getDescription() const;
 
-            bool set(const MultiTypeMath& input);
-            bool tset(const MultiTypeMath& input);
-
-            bool set(unsigned int index, const MultiTypeMath& input);
-            bool tset(unsigned int index, const MultiTypeMath& input);
-            bool add(const MultiTypeMath& input);
+            /**
+                @brief Adds a callback function, that gets called after getValue() if the newly assigned value differs from the old value of the variable.
+                @param object The object to call the function
+                @param function The callback function
+            */
+            template <class T>
+            inline ConfigValueContainer& callback(T* object, void (T::*function) (void))
+            {
+                if (!this->callback_)
+                {
+                    this->callback_ = new ConfigValueCallback<T>(function);
+
+                    if (this->bDoInitialCallback_)
+                    {
+                        this->bDoInitialCallback_ = false;
+                        this->callback_->call(object);
+                    }
+                }
+
+                return (*this);
+            }
+
+            bool set(const MultiType& input);
+            bool tset(const MultiType& input);
+
+            bool set(unsigned int index, const MultiType& input);
+            bool tset(unsigned int index, const MultiType& input);
+            bool add(const MultiType& input);
             bool remove(unsigned int index);
 
@@ -120,5 +260,5 @@
             /** @brief Converts the config-value to a string. @return The string */
             inline std::string toString() const
-                { return this->value_.toString(); }
+                { return this->value_; }
             /** @brief Returns the typename of the assigned config-value. @return The typename */
             inline std::string getTypename() const
@@ -126,5 +266,8 @@
 
         private:
-            bool callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiTypeMath&), const std::string& input);
+            void init(ConfigFileType type, Identifier* identifier, const std::string& varname);
+            void initValue(const MultiType& defvalue);
+            void initVector();
+            bool callFunctionWithIndex(bool (ConfigValueContainer::* function) (unsigned int, const MultiType&), const std::string& input);
 
             bool                       bIsVector_;                  //!< True if the container contains a std::vector
@@ -137,9 +280,13 @@
             std::vector<std::string>   defvalueStringVector_;       //!< A vector, containg the strings of the default-values in case we're storing a vector
 
-            MultiTypeMath              value_;                      //!< The value
-            std::vector<MultiTypeMath> valueVector_;                //!< A vector, containg the values in case we're storing a vector
+            MultiType                  value_;                      //!< The value
+            std::vector<MultiType>     valueVector_;                //!< A vector, containg the values in case we're storing a vector
 
             bool                       bAddedDescription_;          //!< True if a description was added
             LanguageEntryLabel         description_;                //!< The description
+            ConfigValueCallbackBase*   callback_;                   //!< A callback function to call after getValue if the value changed
+
+            bool                       bContainerIsNew_;            //!< True if it's the first time getValue() gets called
+            bool                       bDoInitialCallback_;         //!< True if the callback should be called as soon as it gets created
     };
 }
Index: code/trunk/src/core/ConfigValueIncludes.h
===================================================================
--- code/trunk/src/core/ConfigValueIncludes.h	(revision 1740)
+++ code/trunk/src/core/ConfigValueIncludes.h	(revision 1747)
@@ -47,27 +47,17 @@
     @param defvalue The default-value of the variable
 */
-#define SetConfigValue(varname, defvalue) \
-    orxonox::ConfigValueContainer* container##varname = this->getIdentifier()->getConfigValueContainer(#varname); \
+#define SetConfigValueGeneric(type, varname, defvalue) \
+    static orxonox::Identifier* identifier##varname = this->getIdentifier(); \
+    orxonox::ConfigValueContainer* container##varname = identifier##varname->getConfigValueContainer(#varname); \
     if (!container##varname) \
     { \
-        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, this->getIdentifier(), #varname, varname = defvalue); \
-        this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
+        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, identifier##varname, #varname, defvalue, varname); \
+        identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
-    container##varname->getValue(&varname)
+    container##varname->getValue(&varname, this)
 
-/**
-    @brief Assigns the value, defined in the config-file, to the variable (or the default-value, if there is no entry in the file).
-    @param classname name in which the config value should be stored
-    @param varname The name of the variable
-    @param defvalue The default-value of the variable
-*/
-#define SetConfigValueGeneric(classname, varname, defvalue) \
-    orxonox::ConfigValueContainer* container##varname = ClassIdentifier<classname>::getIdentifier()->getConfigValueContainer(#varname); \
-    if (!container##varname) \
-    { \
-        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, ClassIdentifier<classname>::getIdentifier(), #varname, varname = defvalue); \
-        ClassIdentifier<classname>::getIdentifier()->addConfigValueContainer(#varname, container##varname); \
-    } \
-    container##varname->getValue(&varname)
+#define SetConfigValue(varname, defvalue) SetConfigValueGeneric(CFT_Settings, varname, defvalue)
+#define SetKeybindingValue(varname, defvalue) SetConfigValueGeneric(CFT_Keybindings, varname, defvalue)
+
 
 /**
@@ -76,16 +66,17 @@
     @param defvalue The default-value
 */
-#define SetConfigValueVector(varname, defvalue) \
-    orxonox::ConfigValueContainer* container##varname = this->getIdentifier()->getConfigValueContainer(#varname); \
+#define SetConfigValueVectorGeneric(type, varname, defvalue) \
+    static orxonox::Identifier* identifier##varname = this->getIdentifier(); \
+    orxonox::ConfigValueContainer* container##varname = identifier##varname->getConfigValueContainer(#varname); \
     if (!container##varname) \
     { \
-        std::vector<MultiTypeMath> temp; \
-        for (unsigned int i = 0; i < defvalue.size(); i++) \
-            temp.push_back(MultiTypeMath(defvalue[i])); \
-        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, this->getIdentifier(), #varname, temp); \
-        container##varname->setVectorType(varname); \
-        this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
+        container##varname = new orxonox::ConfigValueContainer(CFT_Settings, identifier##varname, #varname, defvalue); \
+        identifier##varname->addConfigValueContainer(#varname, container##varname); \
     } \
-    container##varname->getValue(&varname)
+    container##varname->getValue(&varname, this)
+
+#define SetConfigValueVector(varname, defvalue) SetConfigValueVectorGeneric(CFT_Settings, varname, defvalue)
+#define SetKeybindingValueVector(varname, defvalue) SetConfigValueVectorGeneric(CFT_Keybindings, varname, defvalue)
+
 
 /**
@@ -98,5 +89,5 @@
     { \
         container##varname##reset->reset(); \
-        container##varname##reset->getValue(&varname); \
+        container##varname##reset->getValue(&varname, this); \
     } \
     else \
@@ -104,4 +95,5 @@
         COUT(2) << "Warning: Couldn't reset config-value '" << #varname << "', corresponding container doesn't exist." << std::endl; \
     }
+
 
 /**
@@ -115,5 +107,5 @@
     { \
         container##varname##modify##modifier->modifier(__VA_ARGS__); \
-        container##varname##modify##modifier->getValue(&varname); \
+        container##varname##modify##modifier->getValue(&varname, this); \
     } \
     else \
Index: code/trunk/src/core/ConsoleCommand.cc
===================================================================
--- code/trunk/src/core/ConsoleCommand.cc	(revision 1740)
+++ code/trunk/src/core/ConsoleCommand.cc	(revision 1747)
@@ -45,5 +45,5 @@
     }
 
-    ConsoleCommand& ConsoleCommand::setArgumentCompleter(unsigned int param, ArgumentCompleter* completer)
+    ConsoleCommand& ConsoleCommand::argumentCompleter(unsigned int param, ArgumentCompleter* completer)
     {
         if (param < 5)
Index: code/trunk/src/core/ConsoleCommand.h
===================================================================
--- code/trunk/src/core/ConsoleCommand.h	(revision 1740)
+++ code/trunk/src/core/ConsoleCommand.h	(revision 1747)
@@ -38,16 +38,28 @@
 
 
-#define SetConsoleCommand(classname, function,  bCreateShortcut) \
-    SetConsoleCommandGeneric(classname##function##consolecommand__, classname, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function), bCreateShortcut)
+#define SetConsoleCommand(classname, function, bCreateShortcut) \
+    SetConsoleCommandAliasMulti(classname, function, #function, 0, bCreateShortcut)
+#define SetConsoleCommandAlias(classname, function, name, bCreateShortcut) \
+    SetConsoleCommandAliasMulti(classname, function, name, 0, bCreateShortcut)
+#define SetConsoleCommandAliasMulti(classname, function, name, number, bCreateShortcut) \
+    SetConsoleCommandGeneric(classname##function##consolecommand__##number, classname, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), name), bCreateShortcut)
 
 #define SetConsoleCommandGeneric(fakevariable, classname, command, bCreateShortcut) \
-    orxonox::ConsoleCommand& fakevariable = orxonox::ClassIdentifier<classname>::getIdentifier()->addConsoleCommand(command, bCreateShortcut)
+    orxonox::ConsoleCommand& fakevariable = orxonox::ClassIdentifier<classname>::getIdentifier(#classname)->addConsoleCommand(command, bCreateShortcut)
 
 
 #define SetConsoleCommandShortcut(classname, function) \
-    SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function))
+    SetConsoleCommandShortcutAliasMulti(classname, function, #function, 0)
+#define SetConsoleCommandShortcutAlias(classname, function, name) \
+    SetConsoleCommandShortcutAliasMulti(classname, function, name, 0)
+#define SetConsoleCommandShortcutAliasMulti(classname, function, name, number) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__##number, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), name))
 
 #define SetConsoleCommandShortcutExtern(function) \
-    SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&function), #function))
+    SetConsoleCommandShortcutExternAliasMulti(function, #function, 0)
+#define SetConsoleCommandShortcutExternAlias(function, name) \
+    SetConsoleCommandShortcutExternAliasMulti(function, name, 0)
+#define SetConsoleCommandShortcutExternAliasMulti(function, name, number) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__##number, orxonox::createConsoleCommand(orxonox::createFunctor(&function), name))
 
 #define SetConsoleCommandShortcutGeneric(fakevariable, command) \
@@ -75,29 +87,29 @@
             ConsoleCommand(FunctorStatic* functor, const std::string& name = "");
 
-            inline ConsoleCommand& setDescription(const std::string& description)
+            inline ConsoleCommand& description(const std::string& description)
                 { this->ExecutorStatic::setDescription(description); return (*this); }
-            inline ConsoleCommand& setDescriptionParam(int param, const std::string& description)
+            inline ConsoleCommand& descriptionParam(int param, const std::string& description)
                 { this->ExecutorStatic::setDescriptionParam(param, description); return (*this); }
-            inline ConsoleCommand& setDescriptionReturnvalue(const std::string& description)
+            inline ConsoleCommand& descriptionReturnvalue(const std::string& description)
                 { this->ExecutorStatic::setDescriptionReturnvalue(description); return (*this); }
-            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1)
+            inline ConsoleCommand& defaultValues(const MultiType& param1)
                 { this->ExecutorStatic::setDefaultValues(param1); return (*this); }
-            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2)
                 { this->ExecutorStatic::setDefaultValues(param1, param2); return (*this); }
-            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3); return (*this); }
-            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4); return (*this); }
-            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+            inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
-            inline ConsoleCommand& setDefaultValue(unsigned int index, const MultiTypeMath& param)
+            inline ConsoleCommand& defaultValue(unsigned int index, const MultiType& param)
                 { this->ExecutorStatic::setDefaultValue(index, param); return (*this); }
 
-            inline ConsoleCommand& setAccessLevel(AccessLevel::Level level)
+            inline ConsoleCommand& accessLevel(AccessLevel::Level level)
                 { this->accessLevel_ = level; return (*this); }
             inline AccessLevel::Level getAccessLevel() const
                 { return this->accessLevel_; }
 
-            ConsoleCommand& setArgumentCompleter(unsigned int param, ArgumentCompleter* completer);
+            ConsoleCommand& argumentCompleter(unsigned int param, ArgumentCompleter* completer);
             ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
 
@@ -110,15 +122,15 @@
                 { return this->argumentList_.end(); }
 
-            inline ConsoleCommand& setKeybindMode(KeybindMode::Enum mode)
+            inline ConsoleCommand& keybindMode(KeybindMode::Enum mode)
                 { this->keybindMode_ = mode; return *this; }
             inline KeybindMode::Enum getKeybindMode() const
                 { return this->keybindMode_; }
 
-            inline ConsoleCommand& setAxisParamIndex(int index)
+            inline ConsoleCommand& axisParamIndex(int index)
                 { this->axisParamIndex_ = index; return *this; }
             inline int getAxisParamIndex() const
                 { return this->axisParamIndex_; }
 
-            inline ConsoleCommand& setIsAxisRelative(bool val)
+            inline ConsoleCommand& isAxisRelative(bool val)
                 { this->bAxisRelative_ = val; return *this; }
             inline int getIsAxisRelative() const
Index: code/trunk/src/core/ConsoleCommandCompilation.cc
===================================================================
--- code/trunk/src/core/ConsoleCommandCompilation.cc	(revision 1740)
+++ code/trunk/src/core/ConsoleCommandCompilation.cc	(revision 1747)
@@ -29,16 +29,16 @@
 #include "ConsoleCommandCompilation.h"
 #include "ConsoleCommand.h"
-#include "Debug.h"
+#include "util/Debug.h"
 #include "util/ExprParser.h"
 
 namespace orxonox
 {
-    SetConsoleCommandShortcutExtern(source).setArgumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(source).argumentCompleter(0, autocompletion::files());
     SetConsoleCommandShortcutExtern(echo);
     SetConsoleCommandShortcutExtern(puts);
 
-    SetConsoleCommandShortcutExtern(read).setArgumentCompleter(0, autocompletion::files());
-    SetConsoleCommandShortcutExtern(append).setArgumentCompleter(0, autocompletion::files());
-    SetConsoleCommandShortcutExtern(write).setArgumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(read).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(append).argumentCompleter(0, autocompletion::files());
+    SetConsoleCommandShortcutExtern(write).argumentCompleter(0, autocompletion::files());
 
     SetConsoleCommandShortcutExtern(calculate);
Index: code/trunk/src/core/Core.cc
===================================================================
--- code/trunk/src/core/Core.cc	(revision 1740)
+++ code/trunk/src/core/Core.cc	(revision 1747)
@@ -96,8 +96,15 @@
     void Core::setConfigValues()
     {
-        SetConfigValue(softDebugLevelConsole_, 3).description("The maximal level of debug output shown in the console");
-        SetConfigValue(softDebugLevelLogfile_, 3).description("The maximal level of debug output shown in the logfile");
-        SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell");
-
+        SetConfigValue(softDebugLevelConsole_, 3).description("The maximal level of debug output shown in the console").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(softDebugLevelLogfile_, 3).description("The maximal level of debug output shown in the logfile").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell").callback(this, &Core::debugLevelChanged);
+        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text").callback(this, &Core::languageChanged);
+    }
+
+    /**
+        @brief Callback function if the debug level has changed.
+    */
+    void Core::debugLevelChanged()
+    {
         // softDebugLevel_ is the maximum of the 3 variables
         this->softDebugLevel_ = this->softDebugLevelConsole_;
@@ -107,13 +114,17 @@
             this->softDebugLevel_ = this->softDebugLevelShell_;
 
-
-        std::string temp = this->language_;
-        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text");
-
-        if (this->language_ != temp)
-        {
-            // Read the translation file after the language was configured
-            Language::getLanguage().readTranslatedLanguageFile();
-        }
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_All,     this->softDebugLevel_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Console, this->softDebugLevelConsole_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Logfile, this->softDebugLevelLogfile_);
+        OutputHandler::setSoftDebugLevel(OutputHandler::LD_Shell,   this->softDebugLevelShell_);
+    }
+
+    /**
+        @brief Callback function if the language has changed.
+    */
+    void Core::languageChanged()
+    {
+        // Read the translation file after the language was configured
+        Language::getLanguage().readTranslatedLanguageFile();
     }
 
@@ -158,4 +169,6 @@
             else if (device == OutputHandler::LD_Shell)
                 Core::getInstance().softDebugLevelShell_ = level;
+
+            OutputHandler::setSoftDebugLevel(device, level);
         }
      }
@@ -199,11 +212,2 @@
     }
 }
-
-/**
-    @brief Returns the soft debug level, stored in the only existing instance of the DebugLevel class, configured in the config-file.
-    @return The soft debug level
-*/
-int getSoftDebugLevel()
-{
-    return orxonox::Core::getSoftDebugLevel();
-}
Index: code/trunk/src/core/Core.h
===================================================================
--- code/trunk/src/core/Core.h	(revision 1740)
+++ code/trunk/src/core/Core.h	(revision 1747)
@@ -41,5 +41,5 @@
 
 #include "OrxonoxClass.h"
-#include "OutputHandler.h"
+#include "util/OutputHandler.h"
 
 namespace orxonox
@@ -52,4 +52,6 @@
             static bool& isCreatingCoreSettings();
             void setConfigValues();
+            void debugLevelChanged();
+            void languageChanged();
 
             static int getSoftDebugLevel(OutputHandler::OutputDevice device = OutputHandler::LD_All);
Index: code/trunk/src/core/CoreIncludes.h
===================================================================
--- code/trunk/src/core/CoreIncludes.h	(revision 1740)
+++ code/trunk/src/core/CoreIncludes.h	(revision 1747)
@@ -46,5 +46,5 @@
 #include "Factory.h"
 #include "ClassFactory.h"
-#include "Debug.h"
+#include "util/Debug.h"
 
 
@@ -55,10 +55,16 @@
 */
 #define InternRegisterObject(ClassName, bRootClass) \
-    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::getIdentifier()->registerClass(this->getParents(), #ClassName, bRootClass)); \
-    if (orxonox::Identifier::isCreatingHierarchy() && this->getParents()) \
-        this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
-    orxonox::ClassIdentifier<ClassName>::getIdentifier()->addObject(this); \
+    this->setIdentifier(orxonox::ClassIdentifier<ClassName>::getIdentifier(#ClassName)); \
     if (orxonox::Identifier::isCreatingHierarchy()) \
-      return
+    { \
+        if (this->getParents()) \
+        { \
+            orxonox::ClassIdentifier<ClassName>::getIdentifier(#ClassName)->initializeClassHierarchy(this->getParents(), bRootClass); \
+            this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
+        } \
+        this->setConfigValues(); \
+        return; \
+    } \
+    orxonox::ClassIdentifier<ClassName>::getIdentifier()->addObject(this)
 
 /**
Index: code/trunk/src/core/CorePrereqs.h
===================================================================
--- code/trunk/src/core/CorePrereqs.h	(revision 1740)
+++ code/trunk/src/core/CorePrereqs.h	(revision 1747)
@@ -62,6 +62,4 @@
 // Forward declarations
 //-----------------------------------------------------------------------
-class SignalHandler;
-
 namespace orxonox
 {
@@ -111,5 +109,4 @@
   class ConsoleCommand;
   class Core;
-  class Error;
   class Executor;
   template <class T>
@@ -125,4 +122,5 @@
   template <class T>
   class Iterator;
+  class IteratorBase;
   class Language;
   class LanguageEntry;
@@ -130,5 +128,4 @@
   class Loader;
   class MetaObjectList;
-  template <class T>
   class MetaObjectListElement;
   class Namespace;
@@ -136,10 +133,11 @@
   template <class T>
   class ObjectList;
+  class ObjectListBase;
+  class ObjectListBaseElement;
   template <class T>
   class ObjectListElement;
+  template <class T>
+  class ObjectListIterator;
   class OrxonoxClass;
-  class OutputBuffer;
-  class OutputBufferListener;
-  class OutputHandler;
   class Shell;
   class ShellListener;
Index: code/trunk/src/core/Debug.h
===================================================================
--- code/trunk/src/core/Debug.h	(revision 1740)
+++ 	(revision )
@@ -1,350 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Benjamin Grauer
- *   Co-authors:
- *      Fabian 'x3n' Landau
- *
- */
-
-/**
- * @file Debug.h
- * @brief Handles the output for different verbose-modes.
- *
- * There are two modes: HARD and SOFT. HARD is precessed during compiletime, while SOFT is for runtime.
- */
-
-#ifndef _Debug_H__
-#define _Debug_H__
-
-#include "CorePrereqs.h"
-
-#include <stdio.h>
-
-#include "OutputHandler.h"
-
-extern "C" _CoreExport int getSoftDebugLevel();
-
-// DEFINE ERROR MODES
-#define ORX_NONE            0
-#define ORX_ERROR           1
-#define ORX_WARNING         2
-#define ORX_INFO            3
-#define ORX_DEBUG           4
-#define ORX_vDEBUG          5
-
-//definitions
-#define ORX_PRINT_DEBUG_OUTPUT 1 // <-- fix that! should be a configurable setting
-
-#define ORX_HARD_DEBUG_LEVEL ORX_vDEBUG
-//#define ORX_SOFT_DEBUG_LEVEL ORX_WARNING // <-- fix that! should be a configurable setting
-
-///////////////////////////////////////////////////
-/// PRINTF: prints with filename and linenumber ///
-///////////////////////////////////////////////////
-#define PRINTFORX_NONE    PRINTF0
-#define PRINTFORX_ERROR   PRINTF1
-#define PRINTFORX_WARNING PRINTF2
-#define PRINTFORX_INFO    PRINTF3
-#define PRINTFORX_DEBUG   PRINTF4
-#define PRINTFORX_vDEBUG  PRINTF5
-
-#define PRINT_EXEC  printf
-#define COUT_EXEC(x) \
-  orxonox::OutputHandler::getOutStream().setOutputLevel(x)
-
-#ifndef PRINTF
- #if ORX_PRINT_DEBUG_OUTPUT
-
-  #define PRINTF(x) \
-   PRINTF ## x
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
-   #define PRINTF1 \
-    if (getSoftDebugLevel() >= ORX_ERROR) \
-     printf("Error (in %s, line %d): ", __FILE__, __LINE__), PRINT_EXEC
-  #else
-   #define PRINTF1 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
-   #define PRINTF2 \
-    if (getSoftDebugLevel() >= ORX_WARNING) \
-     printf("Warning (in %s, line %d): ", __FILE__, __LINE__), PRINT_EXEC
-  #else
-   #define PRINTF2 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
-   #define PRINTF3 \
-    if (getSoftDebugLevel() >= ORX_INFO) \
-     printf("Info (in %s, line %d): ", __FILE__, __LINE__), PRINT_EXEC
-  #else
-   #define PRINTF3 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
-   #define PRINTF4 \
-    if (getSoftDebugLevel() >= ORX_DEBUG) \
-     printf("Debug (in %s, line %d): ", __FILE__, __LINE__), PRINT_EXEC
-  #else
-   #define PRINTF4 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_vDEBUG
-   #define PRINTF5 \
-    if (getSoftDebugLevel() >= ORX_vDEBUG) \
-     printf("vDebug (in %s, line %d): ", __FILE__, __LINE__), PRINT_EXEC
-  #else
-   #define PRINTF5 if (ORX_NONE) PRINT_EXEC
-  #endif
-
- #else /* if ORX_PRINT_DEBUG_OUTPUT */
-  #define PRINTF(x) if (ORX_NONE) PRINT_EXEC
- #endif /* if ORX_PRINT_DEBUG_OUTPUT */
-
- #define PRINTF0 \
-  PRINT_EXEC
-#endif /* ifndef PRINTF */
-
-///////////////////////////////////////////////////
-///  PRINT: just prints output as is            ///
-///////////////////////////////////////////////////
-#define PRINTORX_NONE    PRINT0
-#define PRINTORX_ERROR   PRINT1
-#define PRINTORX_WARNING PRINT2
-#define PRINTORX_INFO    PRINT3
-#define PRINTORX_DEBUG   PRINT4
-#define PRINTORX_vDEBUG  PRINT5
-
-#ifndef PRINT
- #if ORX_PRINT_DEBUG_OUTPUT
-  #define PRINT(x) \
-   PRINT ## x
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
-   #define PRINT1  \
-    if (getSoftDebugLevel() >= ORX_ERROR)  \
-     PRINT_EXEC
-  #else
-   #define PRINT1 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
-   #define PRINT2 \
-    if (getSoftDebugLevel() >= ORX_WARNING) \
-     PRINT_EXEC
-  #else
-   #define PRINT2 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
-   #define PRINT3 \
-    if (getSoftDebugLevel() >= ORX_INFO) \
-     PRINT_EXEC
-  #else
-   #define PRINT3 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
-   #define PRINT4 \
-    if (getSoftDebugLevel() >= ORX_DEBUG) \
-     PRINT_EXEC
-  #else
-   #define PRINT4 if (ORX_NONE) PRINT_EXEC
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_vDEBUG
-   #define PRINT5 \
-    if (getSoftDebugLevel() >= ORX_vDEBUG) \
-     PRINT_EXEC
-  #else
-   #define PRINT5 if (ORX_NONE) PRINT_EXEC
-  #endif
-
- #else /* if ORX_PRINT_DEBUG_OUTPUT */
-  #define PRINT(x) if (ORX_NONE) PRINT_EXEC
- #endif /* if ORX_PRINT_DEBUG_OUTPUT */
-
- #define PRINT0 \
-  PRINT_EXEC
-#endif /* ifndef PRINT */
-
-
-////////////////////////////////////////////////////////
-///  COUT: just prints output as is with std::cout   ///
-////////////////////////////////////////////////////////
-#define COUTORX_NONE    COUT0
-#define COUTORX_ERROR   COUT1
-#define COUTORX_WARNING COUT2
-#define COUTORX_INFO    COUT3
-#define COUTORX_DEBUG   COUT4
-#define COUTORX_vDEBUG  COUT5
-
-#ifndef COUT
- #if ORX_PRINT_DEBUG_OUTPUT
-  #define COUT(x) \
-   COUT ## x
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
-   #define COUT0  \
-    if (getSoftDebugLevel() >= ORX_NONE)  \
-     COUT_EXEC(0)
-  #else
-   #define COUT0 if (ORX_NONE)\
-    COUT_EXEC(0)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
-   #define COUT1  \
-    if (getSoftDebugLevel() >= ORX_ERROR)  \
-     COUT_EXEC(1)
-  #else
-   #define COUT1 if (ORX_NONE)\
-    COUT_EXEC(1)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
-   #define COUT2 \
-    if (getSoftDebugLevel() >= ORX_WARNING) \
-     COUT_EXEC(2)
-  #else
-   #define COUT2 if (ORX_NONE) \
-    COUT_EXEC(2)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
-   #define COUT3 \
-    if (getSoftDebugLevel() >= ORX_INFO) \
-     COUT_EXEC(3)
-  #else
-   #define COUT3 if (ORX_NONE) \
-    COUT_EXEC(3)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
-   #define COUT4 \
-    if (getSoftDebugLevel() >= ORX_DEBUG) \
-     COUT_EXEC(4)
-  #else
-   #define COUT4 if (ORX_NONE) \
-    COUT_EXEC(4)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_vDEBUG
-   #define COUT5 \
-    if (getSoftDebugLevel() >= ORX_vDEBUG) \
-     COUT_EXEC(5)
-  #else
-   #define COUT5 if (ORX_NONE) \
-    COUT_EXEC(5)
-  #endif
-
- #else /* if ORX_PRINT_DEBUG_OUTPUT */
-  #define COUT(x) if (ORX_NONE) \
-   COUT_EXEC(5)
- #endif /* if ORX_PRINT_DEBUG_OUTPUT */
-
-#endif /* ifndef COUT */
-
-
-/////////////////////////////////////////////////////////////////////
-///  CCOUT: Prints output with std::cout and adds the classname   ///
-/////////////////////////////////////////////////////////////////////
-#define CCOUTORX_NONE    CCOUT0
-#define CCOUTORX_ERROR   CCOUT1
-#define CCOUTORX_WARNING CCOUT2
-#define CCOUTORX_INFO    CCOUT3
-#define CCOUTORX_DEBUG   CCOUT4
-#define CCOUTORX_vDEBUG  CCOUT5
-
-#define CCOUT_EXEC(x) \
-  orxonox::OutputHandler::getOutStream().setOutputLevel(x) \
-  << this->getIdentifier()->getName() << ": "
-
-#ifndef CCOUT
- #if ORX_PRINT_DEBUG_OUTPUT
-  #define CCOUT(x) \
-   CCOUT ## x
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
-   #define CCOUT0  \
-    if (getSoftDebugLevel() >= ORX_NONE)  \
-     CCOUT_EXEC(0)
-  #else
-   #define CCOUT0 if (ORX_NONE)\
-    CCOUT_EXEC(0)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
-   #define CCOUT1  \
-    if (getSoftDebugLevel() >= ORX_ERROR)  \
-     CCOUT_EXEC(1)
-  #else
-   #define CCOUT1 if (ORX_NONE)\
-    CCOUT_EXEC(1)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
-   #define CCOUT2 \
-    if (getSoftDebugLevel() >= ORX_WARNING) \
-     CCOUT_EXEC(2)
-  #else
-   #define CCOUT2 if (ORX_NONE) \
-    CCOUT_EXEC(2)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
-   #define CCOUT3 \
-    if (getSoftDebugLevel() >= ORX_INFO) \
-     CCOUT_EXEC(3)
-  #else
-   #define CCOUT3 if (ORX_NONE) \
-    CCOUT_EXEC(3)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
-   #define CCOUT4 \
-    if (getSoftDebugLevel() >= ORX_DEBUG) \
-     CCOUT_EXEC(4)
-  #else
-   #define CCOUT4 if (ORX_NONE) \
-    CCOUT_EXEC(4)
-  #endif
-
-  #if ORX_HARD_DEBUG_LEVEL >= ORX_vDEBUG
-   #define CCOUT5 \
-    if (getSoftDebugLevel() >= ORX_vDEBUG) \
-     CCOUT_EXEC(5)
-  #else
-   #define CCOUT5 if (ORX_NONE) \
-    CCOUT_EXEC(5)
-  #endif
-
- #else /* if ORX_PRINT_DEBUG_OUTPUT */
-  #define CCOUT(x) if (ORX_NONE) \
-   CCOUT_EXEC(5)
- #endif /* if ORX_PRINT_DEBUG_OUTPUT */
-
-#endif /* ifndef CCOUT */
-
-#endif /* _Debug_H__ */
Index: code/trunk/src/core/Error.cc
===================================================================
--- code/trunk/src/core/Error.cc	(revision 1740)
+++ 	(revision )
@@ -1,59 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Nicolas Perrenoud
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file Error.cc
-    @brief Implementation of the Error class.
-*/
-
-#include "Error.h"
-#include "Debug.h"
-
-namespace orxonox
-{
-	Error::Error(std::string errorMsg, int errorCode)
-	{
-		COUT(1) << "############################ "<< std::endl
-							<< "#         Error "<<errorCode<< "          #"<< std::endl
-							<< "############################ "<< std::endl
-							<< "An error occured in Orxonox: "<< std::endl;
-
-		if (errorMsg=="")
-		{
-			switch (errorCode)
-			{
-				case 1:
-					errorMsg = "Some error!";
-					break;
-				default:
-					errorMsg = "Unknown error!";
-			}
-		}
-		COUT(1) << errorMsg << std::endl<< std::endl;
-	}
-}
Index: code/trunk/src/core/Error.h
===================================================================
--- code/trunk/src/core/Error.h	(revision 1740)
+++ 	(revision )
@@ -1,52 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Nicolas Perrenoud
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file Error.h
-    @brief Definition of the Error class.
-*/
-
-#ifndef _Error_H__
-#define _Error_H__
-
-#include "CorePrereqs.h"
-
-#include <string>
-
-namespace orxonox
-{
-	class _CoreExport Error
-	{
-	public:
-		Error(std::string errorMsg = "", int errorCode = 0);
-	private:
-
-	};
-}
-
-#endif /* _Error_H__ */
Index: code/trunk/src/core/Executor.cc
===================================================================
--- code/trunk/src/core/Executor.cc	(revision 1740)
+++ code/trunk/src/core/Executor.cc	(revision 1747)
@@ -66,5 +66,5 @@
     }
 
-    bool Executor::evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter) const
+    bool Executor::evaluate(const std::string& params, MultiType param[5], const std::string& delimiter) const
     {
         unsigned int paramCount = this->functor_->getParamCount();
@@ -172,23 +172,23 @@
     }
 
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1)
-    {
-        this->defaultValue_[0] = param1;
-        this->bAddedDefaultValue_[0] = true;
-
-        return (*this);
-    }
-
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
-    {
-        this->defaultValue_[0] = param1;
-        this->bAddedDefaultValue_[0] = true;
-        this->defaultValue_[1] = param2;
-        this->bAddedDefaultValue_[1] = true;
-
-        return (*this);
-    }
-
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+    Executor& Executor::setDefaultValues(const MultiType& param1)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
     {
         this->defaultValue_[0] = param1;
@@ -202,5 +202,5 @@
     }
 
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
     {
         this->defaultValue_[0] = param1;
@@ -216,5 +216,5 @@
     }
 
-    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+    Executor& Executor::setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
     {
         this->defaultValue_[0] = param1;
@@ -232,5 +232,5 @@
     }
 
-    Executor& Executor::setDefaultValue(unsigned int index, const MultiTypeMath& param)
+    Executor& Executor::setDefaultValue(unsigned int index, const MultiType& param)
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
Index: code/trunk/src/core/Executor.h
===================================================================
--- code/trunk/src/core/Executor.h	(revision 1740)
+++ code/trunk/src/core/Executor.h	(revision 1747)
@@ -37,5 +37,5 @@
 #include "util/Math.h"
 #include "Functor.h"
-#include "Debug.h"
+#include "util/Debug.h"
 
 
@@ -64,5 +64,5 @@
         { \
             COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using whole string: " << params << std::endl; \
-            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiTypeMath(params)); \
+            EXECUTOR_PARSE_FUNCTORCALL(mode)(EXECUTOR_PARSE_OBJECT(mode, 1) MultiType(params)); \
         } \
         else if (this->bAddedDefaultValue_[0]) \
@@ -90,5 +90,5 @@
         } \
         \
-        MultiTypeMath param[MAX_FUNCTOR_ARGUMENTS]; \
+        MultiType param[MAX_FUNCTOR_ARGUMENTS]; \
         COUT(5) << "Calling Executor " << this->name_ << " through parser with " << paramCount << " parameters, using " << tokens.size() << " tokens ("; \
         for (unsigned int i = 0; i < tokens.size() && i < MAX_FUNCTOR_ARGUMENTS; i++) \
@@ -145,18 +145,18 @@
             inline void operator()() const
                 { (*this->functor_)(this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1) const
+            inline void operator()(const MultiType& param1) const
                 { (*this->functor_)(param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(const MultiType& param1, const MultiType& param2) const
                 { (*this->functor_)(param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*this->functor_)(param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*this->functor_)(param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline void operator()(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*this->functor_)(param1, param2, param3, param4, param5); }
 
             bool parse(const std::string& params, const std::string& delimiter = " ") const;
 
-            bool evaluate(const std::string& params, MultiTypeMath param[5], const std::string& delimiter = " ") const;
+            bool evaluate(const std::string& params, MultiType param[5], const std::string& delimiter = " ") const;
 
             Executor& setDescription(const std::string& description);
@@ -177,5 +177,5 @@
             inline FunctionType getType() const
                 { return this->functor_->getType(); }
-            inline MultiTypeMath getReturnvalue() const
+            inline MultiType getReturnvalue() const
                 { return this->functor_->getReturnvalue(); }
             inline std::string getTypenameParam(unsigned int param) const
@@ -189,12 +189,12 @@
                 { return this->name_; }
 
-            Executor& setDefaultValues(const MultiTypeMath& param1);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4);
-            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5);
-            Executor& setDefaultValue(unsigned int index, const MultiTypeMath& param);
-
-            inline MultiTypeMath getDefaultValue(unsigned int index) const
+            Executor& setDefaultValues(const MultiType& param1);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4);
+            Executor& setDefaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5);
+            Executor& setDefaultValue(unsigned int index, const MultiType& param);
+
+            inline MultiType getDefaultValue(unsigned int index) const
             {
                 if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -216,5 +216,5 @@
             Functor* functor_;
             std::string name_;
-            MultiTypeMath defaultValue_[MAX_FUNCTOR_ARGUMENTS];
+            MultiType defaultValue_[MAX_FUNCTOR_ARGUMENTS];
             bool bAddedDefaultValue_[MAX_FUNCTOR_ARGUMENTS];
 
@@ -245,13 +245,13 @@
             inline void operator()(T* object) const
                 { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1) const
+            inline void operator()(T* object, const MultiType& param1) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline void operator()(T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
 
@@ -259,13 +259,13 @@
             inline void operator()(const T* object) const
                 { (*((FunctorMember<T>*)this->functor_))(object, this->defaultValue_[0], this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1) const
+            inline void operator()(const T* object, const MultiType& param1) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, this->defaultValue_[1], this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, this->defaultValue_[2], this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, this->defaultValue_[3], this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, this->defaultValue_[4]); }
-            inline void operator()(const T* object, const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) const
+            inline void operator()(const T* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) const
                 { (*((FunctorMember<T>*)this->functor_))(object, param1, param2, param3, param4, param5); }
 
Index: code/trunk/src/core/Factory.cc
===================================================================
--- code/trunk/src/core/Factory.cc	(revision 1740)
+++ code/trunk/src/core/Factory.cc	(revision 1747)
@@ -34,6 +34,6 @@
 #include "Factory.h"
 #include "Identifier.h"
-#include "Debug.h"
 #include "BaseObject.h"
+#include "util/Debug.h"
 
 namespace orxonox
Index: code/trunk/src/core/Functor.h
===================================================================
--- code/trunk/src/core/Functor.h	(revision 1740)
+++ code/trunk/src/core/Functor.h	(revision 1747)
@@ -33,6 +33,6 @@
 #include "CorePrereqs.h"
 
-#include "util/MultiTypeMath.h"
-#include "Debug.h"
+#include "util/MultiType.h"
+#include "util/Debug.h"
 
 #define MAX_FUNCTOR_ARGUMENTS 5
@@ -69,4 +69,6 @@
     CreateTypeToStringTemplate(long);
     CreateTypeToStringTemplate(unsigned long);
+    CreateTypeToStringTemplate(long long);
+    CreateTypeToStringTemplate(unsigned long long);
     CreateTypeToStringTemplate(float);
     CreateTypeToStringTemplate(double);
@@ -80,11 +82,11 @@
     CreateTypeToStringTemplate(Degree);
 
-    template <> \
-    inline std::string typeToString<std::string>() { return "string"; } \
-    template <> \
-    inline std::string typeToString<std::string&>() { return "string"; } \
-    template <> \
-    inline std::string typeToString<const std::string>() { return "string"; } \
-    template <> \
+    template <>
+    inline std::string typeToString<std::string>() { return "string"; }
+    template <>
+    inline std::string typeToString<std::string&>() { return "string"; }
+    template <>
+    inline std::string typeToString<const std::string>() { return "string"; }
+    template <>
     inline std::string typeToString<const std::string&>() { return "string"; }
 
@@ -95,15 +97,15 @@
             virtual ~Functor() {}
 
-            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
 
             inline unsigned int getParamCount() const { return this->numParams_; }
             inline bool hasReturnvalue() const { return this->hasReturnValue_; }
             inline FunctionType getType() const { return this->type_; }
-            inline MultiTypeMath getReturnvalue() const { return this->returnedValue_; }
+            inline MultiType getReturnvalue() const { return this->returnedValue_; }
 
             std::string getTypenameParam(unsigned int param) const { return (param >= 0 && param < 5) ? this->typeParam_[param] : ""; }
             std::string getTypenameReturnvalue() const { return this->typeReturnvalue_; }
 
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const = 0;
+            virtual void evaluateParam(unsigned int index, MultiType& param) const = 0;
 
         protected:
@@ -111,5 +113,5 @@
             bool hasReturnValue_;
             FunctionType type_;
-            MultiTypeMath returnedValue_;
+            MultiType returnedValue_;
 
             std::string typeReturnvalue_;
@@ -121,5 +123,5 @@
         public:
             virtual ~FunctorStatic() {}
-            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
     };
 
@@ -136,8 +138,8 @@
             virtual ~FunctorMember() {}
 
-            virtual void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-            virtual void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) = 0;
-
-            virtual void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null)
+            virtual void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+            virtual void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) = 0;
+
+            virtual void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null)
             {
                 if (this->bConstObject_)
@@ -284,23 +286,23 @@
 #define FUNCTOR_EVALUATE_PARAM0
 #define FUNCTOR_EVALUATE_PARAM1 \
-    if (index == 0) { P1 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); }
 #define FUNCTOR_EVALUATE_PARAM2 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); }
 #define FUNCTOR_EVALUATE_PARAM3 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; } \
-    else if (index == 2) { P3 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); }
 #define FUNCTOR_EVALUATE_PARAM4 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; } \
-    else if (index == 2) { P3 temp = param; param = temp; } \
-    else if (index == 3) { P4 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); } \
+    else if (index == 3) { param.convert<P4>(); }
 #define FUNCTOR_EVALUATE_PARAM5 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; } \
-    else if (index == 2) { P3 temp = param; param = temp; } \
-    else if (index == 3) { P4 temp = param; param = temp; } \
-    else if (index == 4) { P5 temp = param; param = temp; }
+    if (index == 0) { param.convert<P1>(); } \
+    else if (index == 1) { param.convert<P2>(); } \
+    else if (index == 2) { param.convert<P3>(); } \
+    else if (index == 3) { param.convert<P4>(); } \
+    else if (index == 4) { param.convert<P5>(); }
 
 
@@ -324,10 +326,10 @@
             } \
     \
-            void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
@@ -362,10 +364,10 @@
             } \
     \
-            void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 COUT(1) << "An error occurred in Functor.h:" << std::endl; \
@@ -373,5 +375,5 @@
             } \
     \
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
@@ -395,15 +397,15 @@
             } \
     \
-            void operator()(T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            void operator()(const T* object, const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
+            void operator()(const T* object, const MultiType& param1 = MT_null, const MultiType& param2 = MT_null, const MultiType& param3 = MT_null, const MultiType& param4 = MT_null, const MultiType& param5 = MT_null) \
             { \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*object.*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
             } \
     \
-            virtual void evaluateParam(unsigned int index, MultiTypeMath& param) const \
+            virtual void evaluateParam(unsigned int index, MultiType& param) const \
             { \
                 FUNCTOR_EVALUATE_PARAM(numparams); \
Index: code/trunk/src/core/IRC.cc
===================================================================
--- code/trunk/src/core/IRC.cc	(revision 1740)
+++ code/trunk/src/core/IRC.cc	(revision 1747)
@@ -39,9 +39,7 @@
 namespace orxonox
 {
-    SetConsoleCommand(IRC, say,  true).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(IRC, msg,  false).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(IRC, nick, false).setAccessLevel(AccessLevel::User);
-
-    IRC* instance_irc = &IRC::getInstance();
+    SetConsoleCommand(IRC, say,  true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, msg,  false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, nick, false).accessLevel(AccessLevel::User);
 
     IRC::IRC()
Index: code/trunk/src/core/Identifier.cc
===================================================================
--- code/trunk/src/core/Identifier.cc	(revision 1740)
+++ code/trunk/src/core/Identifier.cc	(revision 1747)
@@ -37,6 +37,8 @@
 
 #include "Factory.h"
+#include "ConfigValueContainer.h"
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
+#include "XMLPort.h"
 
 namespace orxonox
@@ -52,5 +54,8 @@
     Identifier::Identifier()
     {
+        this->objects_ = new ObjectListBase(this);
+
         this->bCreatedOneObject_ = false;
+        this->bSetName_ = false;
         this->factory_ = 0;
 
@@ -73,4 +78,17 @@
         delete this->children_;
         delete this->directChildren_;
+        delete this->objects_;
+
+        if (this->factory_)
+            delete this->factory_;
+
+        for (std::map<std::string, ConsoleCommand*>::iterator it = this->consoleCommands_.begin(); it != this->consoleCommands_.end(); ++it)
+            delete (it->second);
+        for (std::map<std::string, ConfigValueContainer*>::iterator it = this->configValues_.begin(); it != this->configValues_.end(); ++it)
+            delete (it->second);
+        for (std::map<std::string, XMLPortParamContainer*>::iterator it = this->xmlportParamContainers_.begin(); it != this->xmlportParamContainers_.end(); ++it)
+            delete (it->second);
+        for (std::map<std::string, XMLPortObjectContainer*>::iterator it = this->xmlportObjectContainers_.begin(); it != this->xmlportObjectContainers_.end(); ++it)
+            delete (it->second);
     }
 
@@ -81,19 +99,21 @@
         @return The identifier (unique instance)
     */
-    Identifier *Identifier::getIdentifier(std::string &name, Identifier *proposal)
+    Identifier* Identifier::getIdentifierSingleton(const std::string& name, Identifier* proposal)
     {
         static std::map<std::string, Identifier*> identifiers;    //!< The map to store all Identifiers.
         std::map<std::string, Identifier*>::const_iterator it = identifiers.find(name);
-        if (it == identifiers.end())
-        {
-            // there isn't an entry yet, put the proposal in it
+
+        if (it != identifiers.end())
+        {
+            // There is already an entry: return it and delete the proposal
+            delete proposal;
+            return (*it).second;
+        }
+        else
+        {
+            // There is no entry: put the proposal into the map and return it
             identifiers[name] = proposal;
-        }
-        else
-        {
-            // this happens when a template exists twice --> delete the proposal
-            delete proposal;
-        }
-        return identifiers[name];
+            return proposal;
+        }
     }
 
@@ -139,5 +159,32 @@
                 // Tell the parent we're one of it's direct children
                 (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
+
+                // Create the super-function dependencies
+                (*it)->createSuperFunctionCaller();
             }
+        }
+    }
+
+    /**
+        @brief Destroys all Identifiers. Called when exiting the program.
+    */
+    void Identifier::destroyAllIdentifiers()
+    {
+        for (std::map<std::string, Identifier*>::iterator it = Identifier::getIdentifierMapIntern().begin(); it != Identifier::getIdentifierMapIntern().end(); ++it)
+            delete (it->second);
+    }
+
+    /**
+        @brief Sets the name of the class.
+        @param name The name
+    */
+    void Identifier::setName(const std::string& name)
+    {
+        if (!this->bSetName_)
+        {
+            this->name_ = name;
+            this->bSetName_ = true;
+            Identifier::getIdentifierMapIntern()[name] = this;
+            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
         }
     }
@@ -258,4 +305,5 @@
         {
             COUT(2) << "Warning: Overwriting config-value with name " << varname << " in class " << this->getName() << "." << std::endl;
+            delete (it->second);
         }
 
@@ -305,4 +353,5 @@
         {
             COUT(2) << "Warning: Overwriting console-command with name " << command->getName() << " in class " << this->getName() << "." << std::endl;
+            delete (it->second);
         }
 
@@ -343,4 +392,52 @@
         else
             return 0;
+    }
+
+    /**
+        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @return The container
+    */
+    XMLPortParamContainer* Identifier::getXMLPortParamContainer(const std::string& paramname)
+    {
+        std::map<std::string, XMLPortParamContainer*>::const_iterator it = xmlportParamContainers_.find(paramname);
+        if (it != xmlportParamContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
+        @param paramname The name of the parameter
+        @param container The container
+    */
+    void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        this->xmlportParamContainers_[paramname] = container;
+    }
+
+    /**
+        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @return The container
+    */
+    XMLPortObjectContainer* Identifier::getXMLPortObjectContainer(const std::string& sectionname)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
+        if (it != xmlportObjectContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+
+    /**
+        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
+        @param sectionname The name of the section that contains the attachable objects
+        @param container The container
+    */
+    void Identifier::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
+    {
+        this->xmlportObjectContainers_[sectionname] = container;
     }
 
Index: code/trunk/src/core/Identifier.h
===================================================================
--- code/trunk/src/core/Identifier.h	(revision 1740)
+++ code/trunk/src/core/Identifier.h	(revision 1747)
@@ -62,8 +62,8 @@
 #include <stdlib.h>
 
-#include "ObjectList.h"
-#include "Debug.h"
+#include "MetaObjectList.h"
 #include "Iterator.h"
-#include "MetaObjectList.h"
+#include "Super.h"
+#include "util/Debug.h"
 #include "util/String.h"
 
@@ -91,7 +91,4 @@
     {
         template <class T>
-        friend class ClassIdentifier;
-
-        template <class T>
         friend class SubclassIdentifier;
 
@@ -110,11 +107,13 @@
             bool isDirectParentOf(const Identifier* identifier) const;
 
-            virtual const ObjectList<BaseObject>* getObjectList() const = 0;
-
-            virtual void updateConfigValues() const = 0;
+            /** @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_; }
-
+            void setName(const std::string& name);
+
+            virtual void updateConfigValues(bool updateChildren = true) const = 0;
 
             /** @brief Returns the parents of the class the Identifier belongs to. @return The list of all parents */
@@ -210,9 +209,9 @@
             ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
 
-            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
-            virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
-
-            virtual void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container) = 0;
-            virtual XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname) = 0;
+            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
+            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
+
+            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
+            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
 
             ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
@@ -221,4 +220,13 @@
 
         protected:
+            Identifier();
+            Identifier(const Identifier& identifier); // don't copy
+            virtual ~Identifier();
+
+            void initialize(std::set<const Identifier*>* parents);
+            static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
+
+            virtual void createSuperFunctionCaller() const = 0;
+
             /** @brief Returns the map that stores all Identifiers. @return The map */
             static std::map<std::string, Identifier*>& getIdentifierMapIntern();
@@ -226,10 +234,4 @@
             static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
 
-        private:
-            Identifier();
-            Identifier(const Identifier& identifier); // don't copy
-            virtual ~Identifier();
-            void initialize(std::set<const Identifier*>* parents);
-
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
@@ -237,4 +239,8 @@
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
 
+            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
+            ObjectListBase* objects_;                                      //!< The list of all objects of this class
+
+        private:
             /**
                 @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
@@ -255,5 +261,5 @@
             }
 
-            static Identifier* getIdentifier(std::string &name, Identifier *proposal);
+            static void destroyAllIdentifiers();
 
             std::set<const Identifier*> parents_;                          //!< The parents of the class the Identifier belongs to
@@ -263,8 +269,7 @@
             std::set<const Identifier*>* directChildren_;                  //!< The direct children of the class the Identifier belongs to
 
+            bool bSetName_;                                                //!< True if the name is set
             std::string name_;                                             //!< The name of the class the Identifier belongs to
-
             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)
             static int hierarchyCreatingCounter_s;                         //!< Bigger than zero if at least one Identifier stores its parents (its an int instead of a bool to avoid conflicts with multithreading)
             unsigned int classID_;                                         //!< The network ID to identify a class through the network
@@ -277,4 +282,7 @@
             std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
             std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
+
+            std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
+            std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
     };
 
@@ -297,32 +305,26 @@
     class ClassIdentifier : public Identifier
     {
+        #define SUPER_INTRUSIVE_DECLARATION_INCLUDE
+        #include "Super.h"
+
         public:
-            ClassIdentifier<T>* registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass);
+            static ClassIdentifier<T> *getIdentifier();
+            static ClassIdentifier<T> *getIdentifier(const std::string& name);
+            void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
+            static bool isFirstCall();
             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;
-
-            XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
-            void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
-
-            XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
-            void addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container);
-
-            static ClassIdentifier<T> *getIdentifier();
+
+            void updateConfigValues(bool updateChildren = true) const;
 
         private:
-            ClassIdentifier();
             ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
-            ~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
-            std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
+            ClassIdentifier()
+            {
+                SuperFunctionInitialization<0, T>::initialize(this);
+            }
+            ~ClassIdentifier()
+            {
+                SuperFunctionDestruction<0, T>::destroy(this);
+            }
 
             static ClassIdentifier<T> *classIdentifier_s;
@@ -333,42 +335,45 @@
 
     /**
-        @brief Constructor: Creates the ObjectList.
-    */
-    template <class T>
-    ClassIdentifier<T>::ClassIdentifier()
-    {
-//        this->objects_ = ObjectList<T>::getList();
-        this->objects_ = new ObjectList<T>();
-        this->bSetName_ = false;
-    }
-
-    /**
         @brief Registers a class, which means that the name and the parents get stored.
         @param parents A list, containing the Identifiers of all parents of the class
-        @param name A string, containing exactly the name of the class
         @param bRootClass True if the class is either an Interface or the BaseObject itself
-        @return The ClassIdentifier itself
-    */
-    template <class T>
-    ClassIdentifier<T>* ClassIdentifier<T>::registerClass(std::set<const Identifier*>* parents, const std::string& name, bool bRootClass)
-    {
-        this->setName(name);
-
+    */
+    template <class T>
+    void ClassIdentifier<T>::initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass)
+    {
         // Check if at least one object of the given type was created
         if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
         {
             // If no: We have to store the informations and initialize the Identifier
-            COUT(4) << "*** ClassIdentifier: Register Class in " << name << "-Singleton -> Initialize Singleton." << std::endl;
+            COUT(4) << "*** ClassIdentifier: Register Class in " << this->getName() << "-Singleton -> Initialize Singleton." << std::endl;
             if (bRootClass)
-                this->initialize(NULL); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
+                this->initialize(0); // If a class is derived from two interfaces, the second interface might think it's derived from the first because of the order of constructor-calls. Thats why we set parents to zero in that case.
             else
                 this->initialize(parents);
         }
-
-        return this;
     }
 
     /**
-        @brief Creates the only instance of this class for the template class T and retrieves a unique Identifier for the given name.
+        @brief Returns true if the function gets called the first time, false otherwise.
+        @return True if this function got called the first time.
+    */
+    template <class T>
+    bool ClassIdentifier<T>::isFirstCall()
+    {
+        static bool bFirstCall = true;
+
+        if (bFirstCall)
+        {
+            bFirstCall = false;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    /**
+        @brief Returns the only instance of this class.
         @return The unique Identifier
     */
@@ -377,5 +382,5 @@
     {
         // check if the static field has already been filled
-        if (ClassIdentifier<T>::classIdentifier_s == 0)
+        if (ClassIdentifier<T>::isFirstCall())
         {
             // Get the name of the class
@@ -383,8 +388,17 @@
 
             // create a new identifier anyway. Will be deleted in Identifier::getIdentifier if not used.
-            ClassIdentifier<T> *proposal = new ClassIdentifier<T>();
+            ClassIdentifier<T>* proposal = new ClassIdentifier<T>();
 
             // Get the entry from the map
-            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifier(name, proposal);
+            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*)Identifier::getIdentifierSingleton(name, proposal);
+
+            if (ClassIdentifier<T>::classIdentifier_s == proposal)
+            {
+                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was not yet existing and got created." << std::endl;
+            }
+            else
+            {
+                COUT(4) << "*** Identifier: Requested Identifier for " << name << " was already existing and got assigned." << std::endl;
+            }
         }
 
@@ -394,17 +408,14 @@
 
     /**
-        @brief Sets the name of the class.
-        @param name The name
-    */
-    template <class T>
-    void ClassIdentifier<T>::setName(const std::string& name)
-    {
-        if (!this->bSetName_)
-        {
-            this->name_ = name;
-            this->bSetName_ = true;
-            Identifier::getIdentifierMapIntern()[name] = this;
-            Identifier::getLowercaseIdentifierMapIntern()[getLowercase(name)] = this;
-        }
+        @brief Does the same as getIdentifier() but sets the name if this wasn't done yet.
+        @param name The name of this Identifier
+        @return The Identifier
+    */
+    template <class T>
+    ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier(const std::string& name)
+    {
+        ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
+        identifier->setName(name);
+        return identifier;
     }
 
@@ -417,5 +428,5 @@
     {
         COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
-        object->getMetaList().add(this->objects_, this->objects_->add(object));
+        object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
     }
 
@@ -424,60 +435,15 @@
     */
     template <class T>
-    void ClassIdentifier<T>::updateConfigValues() const
-    {
-        for (Iterator<T> it = this->objects_->start(); it; ++it)
-            ((T*)*it)->setConfigValues();
-    }
-
-    /**
-        @brief Returns a XMLPortParamContainer that loads a parameter of this class.
-        @param paramname The name of the parameter
-        @return The container
-    */
-    template <class T>
-    XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
-    {
-        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
-        if (it != xmlportParamContainers_.end())
-            return (XMLPortParamContainer*)((*it).second);
-        else
-            return 0;
-    }
-
-    /**
-        @brief Adds a new XMLPortParamContainer that loads a parameter of this class.
-        @param paramname The name of the parameter
-        @param container The container
-    */
-    template <class T>
-    void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
-    {
-        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
-    }
-
-    /**
-        @brief Returns a XMLPortObjectContainer that attaches an object to this class.
-        @param sectionname The name of the section that contains the attachable objects
-        @return The container
-    */
-    template <class T>
-    XMLPortObjectContainer* ClassIdentifier<T>::getXMLPortObjectContainer(const std::string& sectionname)
-    {
-        typename std::map<std::string, XMLPortClassObjectContainer<T, class O>*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
-        if (it != xmlportObjectContainers_.end())
-            return (XMLPortObjectContainer*)((*it).second);
-        else
-            return 0;
-    }
-
-    /**
-        @brief Adds a new XMLPortObjectContainer that attaches an object to this class.
-        @param sectionname The name of the section that contains the attachable objects
-        @param container The container
-    */
-    template <class T>
-    void ClassIdentifier<T>::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
-    {
-        this->xmlportObjectContainers_[sectionname] = (XMLPortClassObjectContainer<T, class O>*)container;
+    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
+    {
+        if (!this->hasConfigValues())
+            return;
+
+        for (ObjectListIterator<T> it = ObjectList<T>::begin(); it; ++it)
+            it->setConfigValues();
+
+        if (updateChildren)
+            for (std::set<const Identifier*>::const_iterator it = this->getChildrenBegin(); it != this->getChildrenEnd(); ++it)
+                (*it)->updateConfigValues(false);
     }
 
Index: code/trunk/src/core/Iterator.h
===================================================================
--- code/trunk/src/core/Iterator.h	(revision 1740)
+++ code/trunk/src/core/Iterator.h	(revision 1747)
@@ -31,15 +31,13 @@
     @brief Definition and implementation of the Iterator class.
 
-    The Iterator of a given class allows to iterate through an ObjectList, containing all objects of that type.
-    This is the only way to access the objects stored in an ObjectList.
+    The Iterator of a given class allows to iterate through an ObjectList. Objects in
+    this list are casted to the template argument of the Iterator.
 
     Usage:
-    for (Iterator<class> it = ObjectList<class>::start(); it != 0; ++it)
+    for (Iterator<myClass> it = anyidentifier->getObjects().begin(); it != anyidentifier->getObjects().end(); ++it)
     {
         it->someFunction(...);
-        class* myObject = *it;
+        myClass* myObject = *it;
     }
-
-    Warning: Don't delete objects directly through the iterator.
 */
 
@@ -49,10 +47,12 @@
 #include "CorePrereqs.h"
 
-#include "ObjectList.h"
+#include "ObjectListBase.h"
+#include "ObjectListIterator.h"
+#include "OrxonoxClass.h"
 
 namespace orxonox
 {
-    //! The iterator allows to iterate through an ObjectList of a given class.
-    template <class T>
+    //! The Iterator allows to iterate through a given ObjectList
+    template <class T = OrxonoxClass>
     class Iterator
     {
@@ -61,18 +61,54 @@
                 @brief Constructor: Sets the element, whereon the iterator points, to zero.
             */
-            Iterator()
+            inline Iterator()
             {
                 this->element_ = 0;
-                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
-            }
-
-            /**
-                @brief Constructor: Sets the element, whereon the iterator points, to a given element.
-                @param element The element to start with
-            */
-            Iterator(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
-                ClassIdentifier<T>::getIdentifier()->getObjects()->registerIterator(this);
+                this->list_ = 0;
+            }
+
+            /**
+                @brief Constructor: Sets this element to the exported element.
+                @param exp The exported element
+            */
+            inline Iterator(const ObjectListBase::Export& exp)
+            {
+                this->element_ = exp.element_;
+                this->list_ = exp.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element of another Iterator.
+                @param other The other Iterator
+            */
+            inline Iterator(const Iterator<T>& other)
+            {
+                this->element_ = other.element_;
+                this->list_ = other.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to a given element
+                @param element The element
+            */
+            template <class O>
+            inline Iterator(ObjectListElement<O>* element)
+            {
+                this->element_ = (element) ? (ObjectListBaseElement*)element : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element an ObjectListIterator.
+                @param other The ObjectListIterator
+            */
+            template <class O>
+            inline Iterator(const ObjectListIterator<O>& other)
+            {
+                this->element_ = (other.element_) ? (ObjectListBaseElement*)other.element_ : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
             }
 
@@ -80,17 +116,74 @@
                 @brief Unregisters the Iterator from the ObjectList.
             */
-            ~Iterator()
-            {
-                ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterIterator(this);
-            }
-
-            /**
-                @brief Assigns an element to the iterator.
+            inline ~Iterator()
+            {
+                this->list_->unregisterIterator(this->iterator_);
+            }
+
+            /**
+                @brief Assigns an exported element.
+                @param exp The exported element
+            */
+            inline const Iterator<T>& operator=(const ObjectListBase::Export& exp)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = exp.element_;
+                this->list_ = exp.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
+            }
+
+            /**
+                @brief Assigns the element of another Iterator.
+                @param other The other Iterator
+            */
+            inline const Iterator<T>& operator=(const Iterator<T>& other)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = other.element_;
+                this->list_ = other.list_;
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
+            }
+
+            /**
+                @brief Assigns a given element.
                 @param element The element
             */
-            Iterator<T> operator=(ObjectListElement<T>* element)
-            {
-                this->element_ = element;
+            template <class O>
+            inline const Iterator<T>& operator=(ObjectListElement<O>* element)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = (element) ? (ObjectListBaseElement*)element : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
                 return *this;
+            }
+
+            /**
+                @brief Assigns the element of an ObjectListIterator.
+                @param other The ObjectListIterator
+            */
+            template <class O>
+            inline const Iterator<T>& operator=(const ObjectListIterator<O>& other)
+            {
+                if (this->list_)
+                    this->list_->unregisterIterator(this->iterator_);
+
+                this->element_ = (other.element_) ? (ObjectListBaseElement*)other.element_ : 0;
+                this->list_ = ClassIdentifier<O>::getIdentifier()->getObjects();
+                this->iterator_ = this->list_->registerIterator(this);
+
+                return (*this);
             }
 
@@ -99,5 +192,5 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator++()
+            inline const Iterator<T>& operator++()
             {
                 if (this->element_)
@@ -110,5 +203,5 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator++(int i)
+            inline Iterator<T> operator++(int i)
             {
                 Iterator<T> copy = *this;
@@ -122,5 +215,5 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator--()
+            inline const Iterator<T>& operator--()
             {
                 if (this->element_)
@@ -133,5 +226,5 @@
                 @return The Iterator itself
             */
-            Iterator<T> operator--(int i)
+            inline Iterator<T> operator--(int i)
             {
                 Iterator<T> copy = *this;
@@ -145,8 +238,8 @@
                 @return The object the Iterator points at
             */
-            T* operator*()
-            {
-                if (this->element_)
-                    return this->element_->object_;
+            inline T* operator*() const
+            {
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
                 else
                     return 0;
@@ -157,18 +250,17 @@
                 @return The object the Iterator points at
             */
-            T* operator->() const
-            {
-                if (this->element_)
-                    return this->element_->object_;
+            inline T* operator->() const
+            {
+                if (this->element_)
+                    return dynamic_cast<T*>(this->element_->objectBase_);
                 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 iterator points to an existing object.
-            */
-            operator bool()
+                @return True if the Iterator points to an existing object.
+            */
+            inline operator bool() const
             {
                 return (this->element_ != 0);
@@ -176,17 +268,44 @@
 
             /**
-                @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.
-            */
-            bool operator!=(ObjectListElement<T>* compare)
-            {
-                return (this->element_ != compare);
-            }
-
-        private:
-            ObjectListElement<T>* element_;     //!< The element the Iterator points at
+                @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
+            */
+            inline bool operator==(const Iterator<T>& compare) const
+            {
+                return (this->element_ == compare.element_);
+            }
+
+            /**
+                @brief Overloading of the != operator to compare with another Iterator.
+                @param compare The other Iterator
+                @return True if the iterators point to different elements
+            */
+            inline bool operator!=(const Iterator<T>& compare) const
+            {
+                return (this->element_ != compare.element_);
+            }
+
+            /**
+                @brief Increments the Iterator if it points at the given object.
+                @param object The object to compare with
+            */
+            inline void incrementIfEqual(OrxonoxClass* object)
+            {
+                if (this->element_ && this->element_->objectBase_ == object)
+                    this->operator++();
+            }
+
+        protected:
+            ObjectListBaseElement* element_;       //!< The element the Iterator points at
+            ObjectListBase* list_;                 //!< The list wherein the element is
+            std::list<void*>::iterator iterator_;  //!< The iterator in the notifying list of the ObjectList
     };
+
+    typedef Iterator<OrxonoxClass> BaseIterator;
 }
 
+// Include ObjectList.h so the user only has to include one file: Iterator.h
+#include "ObjectList.h"
+
 #endif /* _Iterator_H__ */
Index: code/trunk/src/core/Language.cc
===================================================================
--- code/trunk/src/core/Language.cc	(revision 1740)
+++ code/trunk/src/core/Language.cc	(revision 1747)
@@ -37,6 +37,5 @@
 
 #include "Core.h"
-
-#include "Debug.h"
+#include "util/Debug.h"
 
 namespace orxonox
@@ -98,4 +97,13 @@
         // Read the default language file to create all known LanguageEntry objects
         this->readDefaultLanguageFile();
+    }
+
+    /**
+        @brief Destructor: Deletes all language entries.
+    */
+    Language::~Language()
+    {
+        for (std::map<std::string, LanguageEntry*>::iterator it = this->languageEntries_.begin(); it != this->languageEntries_.end(); ++it)
+            delete (it->second);
     }
 
Index: code/trunk/src/core/Language.h
===================================================================
--- code/trunk/src/core/Language.h	(revision 1740)
+++ code/trunk/src/core/Language.h	(revision 1747)
@@ -123,5 +123,5 @@
             Language();
             Language(const Language& language);     // don't copy
-            virtual ~Language() {};                 // don't delete
+            virtual ~Language();
 
             void readDefaultLanguageFile();
Index: code/trunk/src/core/Loader.cc
===================================================================
--- code/trunk/src/core/Loader.cc	(revision 1740)
+++ code/trunk/src/core/Loader.cc	(revision 1747)
@@ -32,8 +32,9 @@
 #include "Identifier.h"
 #include "Iterator.h"
-#include "Debug.h"
+#include "ObjectList.h"
 #include "CoreIncludes.h"
 #include "Script.h"
 #include "Namespace.h"
+#include "util/Debug.h"
 
 #include "tinyxml/ticpp.h"
@@ -91,5 +92,5 @@
     void Loader::unload(const ClassTreeMask& mask)
     {
-        for (Iterator<BaseObject> it = ObjectList<BaseObject>::begin(); it; )
+        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it != ObjectList<BaseObject>::end(); )
         {
             if (mask.isIncluded(it->getIdentifier()))
@@ -165,5 +166,5 @@
     void Loader::unload(const Level* level, const ClassTreeMask& mask)
     {
-        for (Iterator<BaseObject> it = ObjectList<BaseObject>::begin(); it; )
+        for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; )
         {
             if ((it->getLevel() == level) && mask.isIncluded(it->getIdentifier()))
Index: code/trunk/src/core/MetaObjectList.cc
===================================================================
--- code/trunk/src/core/MetaObjectList.cc	(revision 1740)
+++ code/trunk/src/core/MetaObjectList.cc	(revision 1747)
@@ -33,7 +33,38 @@
 
 #include "MetaObjectList.h"
+#include "ObjectListBase.h"
+#include "Identifier.h"
+#include "util/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_->objectBase_);
+
+        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 +80,5 @@
     MetaObjectList::~MetaObjectList()
     {
-        BaseMetaObjectListElement* temp;
+        MetaObjectListElement* temp;
         while (this->first_)
         {
@@ -57,3 +88,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/trunk/src/core/MetaObjectList.h
===================================================================
--- code/trunk/src/core/MetaObjectList.h	(revision 1740)
+++ code/trunk/src/core/MetaObjectList.h	(revision 1747)
@@ -41,67 +41,23 @@
 #include "CorePrereqs.h"
 
-#include "ObjectList.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 +65,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 +76,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/trunk/src/core/Namespace.cc
===================================================================
--- code/trunk/src/core/Namespace.cc	(revision 1740)
+++ code/trunk/src/core/Namespace.cc	(revision 1747)
@@ -60,5 +60,5 @@
     void Namespace::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlelement, mode);
+        SUPER(Namespace, XMLPort, xmlelement, mode);
 
         std::string name = this->getName();
Index: code/trunk/src/core/NamespaceNode.cc
===================================================================
--- code/trunk/src/core/NamespaceNode.cc	(revision 1740)
+++ code/trunk/src/core/NamespaceNode.cc	(revision 1747)
@@ -28,5 +28,5 @@
 
 #include "NamespaceNode.h"
-#include "Debug.h"
+#include "util/Debug.h"
 
 namespace orxonox
Index: code/trunk/src/core/ObjectList.h
===================================================================
--- code/trunk/src/core/ObjectList.h	(revision 1740)
+++ code/trunk/src/core/ObjectList.h	(revision 1747)
@@ -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,48 +38,18 @@
 #define _ObjectList_H__
 
-#include <set>
-
 #include "CorePrereqs.h"
 
-#include "Iterator.h"
 #include "Identifier.h"
+#include "ObjectListIterator.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.
-        Use Iterator<class> to iterate through all objects in the list.
+        Wraps the ObjectListBase of the corresponding Identifier.
+        Use ObjectListIterator<class> to iterate through all objects in the list.
     */
     template <class T>
@@ -88,96 +57,22 @@
     {
         public:
-            ObjectList();
-            ~ObjectList();
+            typedef ObjectListIterator<T> iterator;
 
-            ObjectListElement<T>* add(T* object);
+            /** @brief Returns an Iterator to the first element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* begin()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->begin().element_); }
 
-            /** @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 element after the last element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* end()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->end().element_); }
 
-            /** @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 an Iterator to the last element in the list. @return The Iterator */
+            inline static ObjectListElement<T>* rbegin()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->rbegin().element_); }
 
-            /** @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 ObjectListElement<T>* rend()
+                { return ((ObjectListElement<T>*)ClassIdentifier<T>::getIdentifier()->getObjects()->rend().element_); }
     };
-
-    /**
-        @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/trunk/src/core/ObjectListBase.cc
===================================================================
--- code/trunk/src/core/ObjectListBase.cc	(revision 1747)
+++ code/trunk/src/core/ObjectListBase.cc	(revision 1747)
@@ -0,0 +1,107 @@
+/*
+ *   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 "Iterator.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(OrxonoxClass* object) const
+    {
+        for (std::list<void*>::const_iterator it = this->iterators_.begin(); it != this->iterators_.end(); ++it)
+            ((Iterator<OrxonoxClass>*)(*it))->incrementIfEqual(object);
+        for (std::list<void*>::const_iterator it = this->objectListIterators_.begin(); it != this->objectListIterators_.end(); ++it)
+            ((ObjectListIterator<OrxonoxClass>*)(*it))->incrementIfEqual(object);
+    }
+
+    /**
+        @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(ObjectListBaseElement* element)
+    {
+        if (!this->last_)
+        {
+            // If the list is empty
+            this->last_ = element;
+            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_ = element;
+            this->last_->prev_ = temp;
+            temp->next_ = this->last_;
+        }
+
+        return this->last_;
+    }
+}
Index: code/trunk/src/core/ObjectListBase.h
===================================================================
--- code/trunk/src/core/ObjectListBase.h	(revision 1747)
+++ code/trunk/src/core/ObjectListBase.h	(revision 1747)
@@ -0,0 +1,129 @@
+/*
+ *   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 <list>
+
+#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* objectBase) : next_(0), prev_(0), objectBase_(objectBase) {}
+
+            ObjectListBaseElement* next_;       //!< The next element in the list
+            ObjectListBaseElement* prev_;       //!< The previous element in the list
+            OrxonoxClass* objectBase_;
+    };
+
+
+    // ###############################
+    // ###    ObjectListElement    ###
+    // ###############################
+    //! The list-element that actually contains the object
+    template <class T>
+    class ObjectListElement : public ObjectListBaseElement
+    {
+        public:
+            ObjectListElement(T* object) : ObjectListBaseElement(object), object_(object) {}
+            T* object_;              //!< The object
+    };
+
+
+    // ###############################
+    // ###     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(ObjectListBaseElement* element);
+
+            struct Export
+            {
+                Export(ObjectListBase* list, ObjectListBaseElement* element) : list_(list), element_(element) {}
+                ObjectListBase* list_;
+                ObjectListBaseElement* element_;
+            };
+
+            /** @brief Returns a pointer to the first element in the list. @return The element */
+            inline Export begin() { return ObjectListBase::Export(this, this->first_); }
+            /** @brief Returns a pointer to the element after the last element in the list. @return The element */
+            inline Export end() { return ObjectListBase::Export(this, 0); }
+            /** @brief Returns a pointer to the last element in the list. @return The element */
+            inline Export rbegin() { return ObjectListBase::Export(this, this->last_); }
+            /** @brief Returns a pointer to the element in front of the first element in the list. @return The element */
+            inline Export rend() { return ObjectListBase::Export(this, 0); }
+
+            inline std::list<void*>::iterator registerIterator(void* iterator) { return this->iterators_.insert(this->iterators_.begin(), iterator); }
+            inline void unregisterIterator(const std::list<void*>::iterator& iterator) { this->iterators_.erase(iterator); }
+            inline std::list<void*>::iterator registerObjectListIterator(void* iterator) { return this->objectListIterators_.insert(this->objectListIterators_.begin(), iterator); }
+            inline void unregisterObjectListIterator(const std::list<void*>::iterator& iterator) { this->objectListIterators_.erase(iterator); }
+            void notifyIterators(OrxonoxClass* object) const;
+
+            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::list<void*> iterators_;           //!< A list of Iterators pointing on an element in this list
+            std::list<void*> objectListIterators_; //!< A list of ObjectListIterators pointing on an element in this list
+    };
+}
+
+#endif /* _ObjectListBase_H__ */
Index: code/trunk/src/core/ObjectListIterator.h
===================================================================
--- code/trunk/src/core/ObjectListIterator.h	(revision 1747)
+++ code/trunk/src/core/ObjectListIterator.h	(revision 1747)
@@ -0,0 +1,236 @@
+/*
+ *   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 Iterator.h
+    @brief Definition and implementation of the Iterator class.
+
+    The ObjectListIterator of a given class allows to iterate through the
+    ObjectList of this class, containing all objects of that type.
+    This is the only way to access the objects stored in an ObjectList.
+
+    Usage:
+    for (ObjectListIterator<myClass> it = ObjectList<myClass>::begin(); it != ObjectList<myClass>::end(); ++it)
+    {
+        it->someFunction(...);
+        myClass* myObject = *it;
+    }
+*/
+
+#ifndef _ObjectListIterator_H__
+#define _ObjectListIterator_H__
+
+#include "CorePrereqs.h"
+#include "ObjectListBase.h"
+
+namespace orxonox
+{
+    //! The Iterator allows to iterate through the ObjectList of a given class.
+    template <class T>
+    class ObjectListIterator
+    {
+        template <class I>
+        friend class Iterator;
+
+        public:
+            /**
+                @brief Constructor: Sets the element, whereon the ObjectListIterator points, to zero.
+            */
+            inline ObjectListIterator()
+            {
+                this->element_ = 0;
+                this->iterator_ = ClassIdentifier<T>::getIdentifier()->getObjects()->registerObjectListIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to a given element.
+                @param element The element to start with
+            */
+            inline ObjectListIterator(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                this->iterator_ = ClassIdentifier<T>::getIdentifier()->getObjects()->registerObjectListIterator(this);
+            }
+
+            /**
+                @brief Constructor: Sets this element to the element of another ObjectListIterator.
+                @param other The other ObjectListIterator
+            */
+            inline ObjectListIterator(const ObjectListIterator<T>& other)
+            {
+                this->element_ = other.element_;
+                this->iterator_ = ClassIdentifier<T>::getIdentifier()->getObjects()->registerObjectListIterator(this);
+            }
+
+            /**
+                @brief Unregisters the ObjectListIterator from the ObjectList.
+            */
+            inline ~ObjectListIterator()
+            {
+                ClassIdentifier<T>::getIdentifier()->getObjects()->unregisterObjectListIterator(this->iterator_);
+            }
+
+            /**
+                @brief Assigns an ObjectListElement.
+                @param element The ObjectListElement
+            */
+            inline const ObjectListIterator<T>& operator=(ObjectListElement<T>* element)
+            {
+                this->element_ = element;
+                return (*this);
+            }
+
+            /**
+                @brief Assigns the element of another ObjectListIterator.
+                @param element The other ObjectListIterator
+            */
+            inline const ObjectListIterator<T>& operator=(const ObjectListIterator<T>& other)
+            {
+                this->element_ = other.element_;
+                return (*this);
+            }
+
+            /**
+                @brief Overloading of the ++it operator: ObjectListIterator points to the next object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline const ObjectListIterator<T>& operator++()
+            {
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->next_;
+                return *this;
+            }
+
+            /**
+                @brief Overloading of the it++ operator: ObjectListIterator points to the next object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline ObjectListIterator<T> operator++(int i)
+            {
+                ObjectListIterator<T> copy = *this;
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->next_;
+                return copy;
+            }
+
+            /**
+                @brief Overloading of the --it operator: ObjectListIterator points to the previous object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline const ObjectListIterator<T>& operator--()
+            {
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->prev_;
+                return *this;
+            }
+
+            /**
+                @brief Overloading of the it-- operator: ObjectListIterator points to the previous object in the list.
+                @return The ObjectListIterator itself
+            */
+            inline ObjectListIterator<T> operator--(int i)
+            {
+                ObjectListIterator<T> copy = *this;
+                if (this->element_)
+                    this->element_ = (ObjectListElement<T>*)this->element_->prev_;
+                return copy;
+            }
+
+            /**
+                @brief Overloading of the *it operator: returns the pointer to the object.
+                @return The object the ObjectListIterator points at
+            */
+            inline T* operator*() const
+            {
+                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 ObjectListIterator points at
+            */
+            inline T* operator->() const
+            {
+                if (this->element_)
+                    return this->element_->object_;
+                else
+                    return 0;
+            }
+
+            /**
+                @brief Overloading of the typecast-operator to bool: returns true if the ObjectListIterator points to an existing object.
+                @return True if the ObjectListIterator points to an existing object.
+            */
+            inline operator bool() const
+            {
+                return (this->element_ != 0);
+            }
+
+            /**
+                @brief Overloading of the == operator to compare with another ObjectListIterator.
+                @param compare The other ObjectListIterator
+                @return True if the ObjectListIterator point to the same element
+            */
+            inline bool operator==(const ObjectListIterator<T>& compare) const
+            {
+                return (this->element_ == compare.element_);
+            }
+
+            /**
+                @brief Overloading of the != operator to compare with another ObjectListIterator.
+                @param compare The other ObjectListIterator
+                @return True if the ObjectListIterator point to different elements
+            */
+            inline bool operator!=(const ObjectListIterator<T>& compare) const
+            {
+                return (this->element_ != compare.element_);
+            }
+
+            /**
+                @brief Increments the ObjectListIterator if it points at the given object.
+                @param object The object to compare with
+            */
+            inline void incrementIfEqual(OrxonoxClass* object)
+            {
+                if (this->element_ && this->element_->objectBase_ == object)
+                    this->operator++();
+            }
+
+        private:
+            ObjectListElement<T>* element_;        //!< The element the Iterator points at
+            std::list<void*>::iterator iterator_;  //!< The iterator in the notifying list of the ObjectList
+    };
+}
+
+// Include ObjectList.h so the user only has to include one file: Iterator.h
+#include "ObjectList.h"
+
+#endif /* _ObjectListIterator_H__ */
Index: code/trunk/src/core/OrxonoxClass.cc
===================================================================
--- code/trunk/src/core/OrxonoxClass.cc	(revision 1740)
+++ code/trunk/src/core/OrxonoxClass.cc	(revision 1747)
@@ -39,11 +39,9 @@
 {
     /** @brief Constructor: Sets the default values. */
-    OrxonoxClass::OrxonoxClass() :
-      identifier_(0),
-      parents_(0)
+    OrxonoxClass::OrxonoxClass()
     {
+        this->identifier_ = 0;
+        this->parents_ = 0;
         this->metaList_ = new MetaObjectList();
-
-        this->setConfigValues();
     }
 
Index: code/trunk/src/core/OutputBuffer.cc
===================================================================
--- code/trunk/src/core/OutputBuffer.cc	(revision 1740)
+++ 	(revision )
@@ -1,96 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-#include "OutputBuffer.h"
-
-#define OUTPUTBUFFER_MAX_LINE_LENGTH 16384
-
-namespace orxonox
-{
-    void OutputBuffer::registerListener(OutputBufferListener* listener)
-    {
-        this->listeners_.insert(this->listeners_.end(), listener);
-    }
-
-    void OutputBuffer::unregisterListener(OutputBufferListener* listener)
-    {
-        for (std::list<OutputBufferListener*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); )
-        {
-            if ((*it) == listener)
-                this->listeners_.erase(it++);
-            else
-                ++it;
-        }
-    }
-
-    OutputBuffer& OutputBuffer::operator<<(std::ostream& (*manipulator)(std::ostream&))
-    {
-                this->stream_ << manipulator;
-                this->callListeners();
-                return *this;
-    }
-
-    OutputBuffer& OutputBuffer::operator<<(std::ios& (*manipulator)(std::ios&))
-    {
-                this->stream_ << manipulator;
-                this->callListeners();
-                return *this;
-    }
-
-    OutputBuffer& OutputBuffer::operator<<(std::ios_base& (*manipulator)(std::ios_base&))
-    {
-                this->stream_ << manipulator;
-                this->callListeners();
-                return *this;
-    }
-
-    bool OutputBuffer::getLine(std::string* output)
-    {
-        char line[OUTPUTBUFFER_MAX_LINE_LENGTH];
-
-        this->stream_.getline(line, OUTPUTBUFFER_MAX_LINE_LENGTH);
-        (*output) = std::string(line);
-
-        bool eof = this->stream_.eof();
-        bool fail = this->stream_.fail();
-
-        if (eof)
-            this->stream_.flush();
-
-        if (eof || fail)
-            this->stream_.clear();
-
-        return (!eof && !fail);
-    }
-
-    void OutputBuffer::callListeners()
-    {
-        for (std::list<OutputBufferListener*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-            (*it)->outputChanged();
-    }
-}
Index: code/trunk/src/core/OutputBuffer.h
===================================================================
--- code/trunk/src/core/OutputBuffer.h	(revision 1740)
+++ 	(revision )
@@ -1,107 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-#ifndef _OutputBuffer_H__
-#define _OutputBuffer_H__
-
-#include <list>
-#include <sstream>
-#include <iostream>
-
-#include "CorePrereqs.h"
-
-namespace orxonox
-{
-    class _CoreExport OutputBufferListener
-    {
-        friend class OutputBuffer;
-
-        public:
-            virtual ~OutputBufferListener() {}
-
-        private:
-            virtual void outputChanged() = 0;
-    };
-
-    class _CoreExport OutputBuffer
-    {
-        public:
-            OutputBuffer() {}
-            ~OutputBuffer() {}
-
-            template <class T>
-            inline OutputBuffer& operator<<(T object)
-            {
-                this->stream_ << object;
-                this->callListeners();
-                return *this;
-            }
-
-            OutputBuffer& operator<<(std::ostream& (*manipulator)(std::ostream&));
-            OutputBuffer& operator<<(std::ios& (*manipulator)(std::ios&));
-            OutputBuffer& operator<<(std::ios_base& (*manipulator)(std::ios_base&));
-
-            template <class T>
-            inline void add(T object)
-            {
-                this->stream_ << object;
-                this->callListeners();
-            }
-
-            template <class T>
-            inline void addLine(T object)
-            {
-                this->stream_ << object << std::endl;
-                this->callListeners();
-            }
-
-            inline void newline()
-            {
-                this->stream_ << std::endl;
-                this->callListeners();
-            }
-
-            inline void flush()
-            {
-                this->stream_.flush();
-            }
-
-            bool getLine(std::string* output);
-
-            void registerListener(OutputBufferListener* listener);
-            void unregisterListener(OutputBufferListener* listener);
-
-        private:
-            void callListeners();
-
-            std::stringstream stream_;
-            std::list<OutputBufferListener*> listeners_;
-    };
-}
-
-#endif /* _OutputBuffer_H__ */
Index: code/trunk/src/core/OutputHandler.cc
===================================================================
--- code/trunk/src/core/OutputHandler.cc	(revision 1740)
+++ 	(revision )
@@ -1,185 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file OutputHandler.cc
-    @brief Implementation of the OutputHandler class.
-*/
-
-#include "OutputHandler.h"
-#include "Core.h"
-#include "ConsoleCommand.h"
-#include "Shell.h"
-
-namespace orxonox
-{
-    SetConsoleCommandShortcutGeneric(log,     createConsoleCommand(createFunctor(&OutputHandler::log),     "log"    ));
-    SetConsoleCommandShortcutGeneric(error,   createConsoleCommand(createFunctor(&OutputHandler::error),   "error"  ));
-    SetConsoleCommandShortcutGeneric(warning, createConsoleCommand(createFunctor(&OutputHandler::warning), "warning"));
-    SetConsoleCommandShortcutGeneric(info,    createConsoleCommand(createFunctor(&OutputHandler::info),    "info"   ));
-    SetConsoleCommandShortcutGeneric(debug,   createConsoleCommand(createFunctor(&OutputHandler::debug),   "debug"  ));
-
-    /**
-        @brief Constructor: Opens the logfile and writes the first line.
-        @param logfilename The name of the logfile
-    */
-    OutputHandler::OutputHandler(const std::string& logfilename)
-    {
-        this->logfilename_ = logfilename;
-        this->logfile_.open(this->logfilename_.c_str(), std::fstream::out);
-        this->logfile_ << "Started log at yyyy/mm/dd hh:mm:ss" << std::endl;
-        this->logfile_.flush();
-    }
-
-    /**
-        @brief Destructor: Writes the last line to the logfile and closes it.
-    */
-    OutputHandler::~OutputHandler()
-    {
-        this->logfile_ << "Closed log" << std::endl;
-        this->logfile_.close();
-    }
-
-    /**
-        @brief Returns a reference to the only existing instance of the OutputHandler class.
-        @return The instance
-    */
-    OutputHandler& OutputHandler::getOutStream()
-    {
-        static OutputHandler orxout("orxonox.log");
-        return orxout;
-    }
-
-    /**
-        @brief Returns the soft debug level for a given output device.
-        @param device The output device
-        @return The debug level
-    */
-    int OutputHandler::getSoftDebugLevel(OutputHandler::OutputDevice device)
-    {
-        return Core::getSoftDebugLevel(device);
-    }
-
-    /**
-        @brief Returns the Shell's OutputBuffer. This is mere placed here to avoid
-               recompiling the entire project when Shell.h changes.
-        @return The OutputBuffer of the Shell
-    */
-    OutputBuffer& OutputHandler::getShellOutputBuffer()
-    {
-        return Shell::getInstance().getOutputBuffer();
-    }
-
-    /**
-        @brief Overloaded << operator, redirects the output to the console and the logfile.
-        @param sb The streambuffer that should be shown in the console
-        @return A reference to the OutputHandler itself
-    */
-    OutputHandler& OutputHandler::operator<<(std::streambuf* sb)
-    {
-        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
-            std::cout << sb;
-
-        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
-        {
-            this->logfile_ << sb;
-            this->logfile_.flush();
-        }
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
-            Shell::getInstance().getOutputBuffer() << sb;
-
-        return *this;
-    }
-
-    /**
-        @brief Overloaded << operator, redirects the output to the console and the logfile.
-        @param manipulator A function, manipulating the outstream.
-        @return A reference to the OutputHandler itself
-    */
-    OutputHandler& OutputHandler::operator<<(std::ostream& (*manipulator)(std::ostream&))
-    {
-        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
-            manipulator(std::cout);
-
-        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
-        {
-            manipulator(this->logfile_);
-            this->logfile_.flush();
-        }
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
-            Shell::getInstance().getOutputBuffer() << manipulator;
-
-        return *this;
-    }
-
-    /**
-        @brief Overloaded << operator, redirects the output to the console and the logfile.
-        @param manipulator A function, manipulating the outstream.
-        @return A reference to the OutputHandler itself
-    */
-    OutputHandler& OutputHandler::operator<<(std::ios& (*manipulator)(std::ios&))
-    {
-        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
-            manipulator(std::cout);
-
-        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
-        {
-            manipulator(this->logfile_);
-            this->logfile_.flush();
-        }
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
-            Shell::getInstance().getOutputBuffer() << manipulator;
-
-        return *this;
-    }
-
-    /**
-        @brief Overloaded << operator, redirects the output to the console and the logfile.
-        @param manipulator A function, manipulating the outstream.
-        @return A reference to the OutputHandler itself
-    */
-    OutputHandler& OutputHandler::operator<<(std::ios_base& (*manipulator)(std::ios_base&))
-    {
-        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
-            manipulator(std::cout);
-
-        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
-        {
-            manipulator(this->logfile_);
-            this->logfile_.flush();
-        }
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
-            Shell::getInstance().getOutputBuffer() << manipulator;
-
-        return *this;
-    }
-}
Index: code/trunk/src/core/OutputHandler.h
===================================================================
--- code/trunk/src/core/OutputHandler.h	(revision 1740)
+++ 	(revision )
@@ -1,192 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file OutputHandler.h
-    @brief Definition of the OutputHandler class.
-
-    The OutputHandler acts like std::cout, but output isn't only shown in the console,
-    but also written to the logfile.
-*/
-
-#ifndef _OutputHandler_H__
-#define _OutputHandler_H__
-
-#include "CorePrereqs.h"
-
-#include <iostream>
-#include <fstream>
-#include <string>
-
-#include "OutputBuffer.h"
-
-namespace orxonox
-{
-    //! The OutputHandler acts like std::cout, but redirects output to the console AND the logfile.
-    class _CoreExport OutputHandler
-    {
-        public:
-            enum OutputDevice
-            {
-                LD_All,
-                LD_Console,
-                LD_Logfile,
-                LD_Shell
-            };
-
-            static OutputHandler& getOutStream();
-
-            /** @brief Puts some text on the outstream. @param text The text */
-            static inline std::string log(const std::string& text)
-                { OutputHandler::getOutStream().setOutputLevel(0); OutputHandler::getOutStream().output(text + "\n"); return text; }
-
-            /** @brief Puts an error on the outstream. @param text The text */
-            static inline std::string error(const std::string& text)
-                { OutputHandler::getOutStream().setOutputLevel(1); OutputHandler::getOutStream().output(text + "\n"); return text; }
-
-            /** @brief Puts a warning on the outstream. @param text The text */
-            static inline std::string warning(const std::string& text)
-                { OutputHandler::getOutStream().setOutputLevel(2); OutputHandler::getOutStream().output(text + "\n"); return text; }
-
-            /** @brief Puts an info on the outstream. @param text The text */
-            static inline std::string info(const std::string& text)
-                { OutputHandler::getOutStream().setOutputLevel(3); OutputHandler::getOutStream().output(text + "\n"); return text; }
-
-            /** @brief Puts some debug output on the outstream. @param text The text */
-            static inline std::string debug(const std::string& text)
-                { OutputHandler::getOutStream().setOutputLevel(4); OutputHandler::getOutStream().output(text + "\n"); return text; }
-
-            /** @brief Returns a reference to the logfile. @return The logfile */
-            inline std::ofstream& getLogfile()
-                { return this->logfile_; }
-
-            /** @brief Sets the level of the incoming output. @param level The level of the incoming output @return The OutputHandler itself */
-            inline OutputHandler& setOutputLevel(int level)
-                { this->outputLevel_ = level; return *this; }
-
-            /** @brief Returns the level of the incoming output. @return The level */
-            inline int getOutputLevel() const
-                { return this->outputLevel_; }
-
-            static int getSoftDebugLevel(OutputHandler::OutputDevice device);
-
-            OutputBuffer& getShellOutputBuffer();
-
-            template <class T>
-            OutputHandler& output(const T& output);
-
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(unsigned char val)   { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(short val)           { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(unsigned short val)  { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(int val)             { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(unsigned int val)    { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(long val)            { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(unsigned long val)   { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(float val)           { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(double val)          { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(long double val)     { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(const void* val)     { return this->output(val); }
-            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
-            inline OutputHandler& operator<<(bool val)            { return this->output(val); }
-
-            OutputHandler& operator<<(std::streambuf* sb);
-
-            OutputHandler& operator<<(std::ostream& (*manipulator)(std::ostream&));
-            OutputHandler& operator<<(std::ios& (*manipulator)(std::ios&));
-            OutputHandler& operator<<(std::ios_base& (*manipulator)(std::ios_base&));
-
-        private:
-            explicit OutputHandler(const std::string& logfilename);
-            OutputHandler(const OutputHandler& oh);  // don't copy
-            virtual ~OutputHandler();
-            std::ofstream logfile_;     //!< The logfile where the output is logged
-            std::string logfilename_;   //!< The name of the logfile
-            int outputLevel_;           //!< The level of the incoming output
-    };
-
-    /**
-        @brief Redirects the output to the console and the logfile.
-        @param output The value that should be shown in the console
-        @return A reference to the OutputHandler itself
-    */
-    template<class T>
-    OutputHandler& OutputHandler::output(const T& output)
-    {
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
-            std::cout << output;
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
-        {
-            this->logfile_ << output;
-            this->logfile_.flush();
-        }
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
-            OutputHandler::getOutStream().getShellOutputBuffer() << output;
-
-        return *this;
-    }
-
-    /**
-        @brief Overloading of the non-member << operator to redirect the output of classes with self defined '<< to std::ostream' operators to the console and the logfile.
-        @param out The OutputHandler itself
-        @param output The class that should be shown in the console
-        @return The OutputHandler itself
-    */
-    template<class T>
-    OutputHandler& operator<<(OutputHandler& out, const T& output)
-    {
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Console) >= out.getOutputLevel())
-            std::cout << output;
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Logfile) >= out.getOutputLevel())
-        {
-            out.getLogfile() << output;
-            out.getLogfile().flush();
-        }
-
-        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= out.getOutputLevel())
-            OutputHandler::getOutStream().getShellOutputBuffer() << output;
-
-        return out;
-    }
-
-}
-
-#endif /* _OutputHandler_H__ */
Index: code/trunk/src/core/Shell.cc
===================================================================
--- code/trunk/src/core/Shell.cc	(revision 1740)
+++ code/trunk/src/core/Shell.cc	(revision 1747)
@@ -34,4 +34,5 @@
 #include "ConsoleCommand.h"
 #include "input/InputInterfaces.h"
+#include "util/OutputHandler.h"
 
 #define SHELL_UPDATE_LISTENERS(function) \
@@ -43,4 +44,10 @@
     SetConsoleCommand(Shell, clearShell, true);
     SetConsoleCommand(Shell, history, true);
+
+    SetConsoleCommandShortcut(OutputHandler, log);
+    SetConsoleCommandShortcut(OutputHandler, error);
+    SetConsoleCommandShortcut(OutputHandler, warning);
+    SetConsoleCommandShortcut(OutputHandler, info);
+    SetConsoleCommandShortcut(OutputHandler, debug);
 
     Shell::Shell()
@@ -61,4 +68,5 @@
 
         this->outputBuffer_.registerListener(this);
+        OutputHandler::getOutStream().setOutputBuffer(this->outputBuffer_);
 
         this->setConfigValues();
@@ -82,10 +90,18 @@
     void Shell::setConfigValues()
     {
-        SetConfigValue(maxHistoryLength_, 100);
-        SetConfigValue(historyOffset_, 0);
+        SetConfigValue(maxHistoryLength_, 100).callback(this, &Shell::commandHistoryLengthChanged);
+        SetConfigValue(historyOffset_, 0).callback(this, &Shell::commandHistoryOffsetChanged);
         SetConfigValueVector(commandHistory_, std::vector<std::string>());
-
+    }
+
+    void Shell::commandHistoryOffsetChanged()
+    {
         if (this->historyOffset_ >= this->maxHistoryLength_)
             this->historyOffset_ = 0;
+    }
+
+    void Shell::commandHistoryLengthChanged()
+    {
+        this->commandHistoryOffsetChanged();
 
         while (this->commandHistory_.size() > this->maxHistoryLength_)
Index: code/trunk/src/core/Shell.h
===================================================================
--- code/trunk/src/core/Shell.h	(revision 1740)
+++ code/trunk/src/core/Shell.h	(revision 1747)
@@ -37,5 +37,5 @@
 #include "OrxonoxClass.h"
 #include "input/InputBuffer.h"
-#include "OutputBuffer.h"
+#include "util/OutputBuffer.h"
 
 namespace orxonox
@@ -67,4 +67,6 @@
 
             virtual void setConfigValues();
+            void commandHistoryOffsetChanged();
+            void commandHistoryLengthChanged();
 
             void registerListener(ShellListener* listener);
Index: code/trunk/src/core/SignalHandler.cc
===================================================================
--- code/trunk/src/core/SignalHandler.cc	(revision 1740)
+++ 	(revision )
@@ -1,355 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Christoph Renner
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file SignalHandler.cc
-    @brief Implementation of the SignalHandler class.
-*/
-
-#include "SignalHandler.h"
-
-#include <assert.h>
-#include <iostream>
-#include <cstdlib>
-#include <string.h>
-
-#include "Debug.h"
-
-SignalHandler * SignalHandler::singletonRef = NULL;
-
-#ifndef __WIN32__
-
-#include <wait.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/keysym.h>
-
-bool SignalHandler::bXAutoKeyRepeatOn_ = false;
-
-SignalHandler::SignalHandler()
-{
-}
-
-/**
- * register signal handlers for SIGSEGV and SIGABRT
- * @param appName path to executable eg argv[0]
- * @param fileName filename to append backtrace to
- */
-void SignalHandler::doCatch( const std::string & appName, const std::string & fileName )
-{
-  this->appName = appName;
-  this->fileName = fileName;
-
-  // prepare for restoring XAutoKeyRepeat
-  Display* display;
-  if ((display = XOpenDisplay(0)))
-  {
-    XKeyboardState oldState;
-    XGetKeyboardControl(display, &oldState);
-    if (oldState.global_auto_repeat == AutoRepeatModeOn)
-      bXAutoKeyRepeatOn_ = true;
-    else
-      bXAutoKeyRepeatOn_ = false;
-    XCloseDisplay(display);
-  }
-  else
-  {
-    std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
-    bXAutoKeyRepeatOn_ = false;
-  }
-
-
-  // make sure doCatch is only called once without calling dontCatch
-  assert( sigRecList.size() == 0 );
-
-  catchSignal( SIGSEGV );
-  catchSignal( SIGABRT );
-  catchSignal( SIGILL );
-}
-
-/**
- * restore previous signal handlers
- */
-void SignalHandler::dontCatch()
-{
-  for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
-  {
-    signal( it->signal, it->handler );
-  }
-
-  sigRecList.clear();
-}
-
-/**
- * catch signal sig
- * @param sig signal to catch
- */
-void SignalHandler::catchSignal( int sig )
-{
-  sig_t handler = signal( sig, SignalHandler::sigHandler );
-
-  assert( handler != SIG_ERR );
-
-  SignalRec rec;
-  rec.signal = sig;
-  rec.handler = handler;
-
-  sigRecList.push_front( rec );
-}
-
-/**
- * sigHandler is called when receiving signals
- * @param sig
- */
-void SignalHandler::sigHandler( int sig )
-{
-  for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
-  {
-    (*(it->cb))( it->someData );
-  }
-
-  std::string sigName = "UNKNOWN";
-
-  switch ( sig )
-  {
-    case SIGSEGV:
-      sigName = "SIGSEGV";
-      break;
-    case SIGABRT:
-      sigName = "SIGABRT";
-      break;
-    case SIGILL:
-      sigName = "SIGILL";
-      break;
-  }
-
-  if (bXAutoKeyRepeatOn_)
-  {
-    std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
-    Display* display;
-    if ((display = XOpenDisplay(0)))
-    {
-      XAutoRepeatOn(display);
-      XCloseDisplay(display);
-    }
-  }
-
-  PRINTF(0)( "recieved signal %s\ntry to write backtrace to file orxonox.log\n", sigName.c_str() );
-
-  int sigPipe[2];
-  if ( pipe(sigPipe) == -1 )
-  {
-    perror("pipe failed!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  int sigPid = fork();
-
-  if ( sigPid == -1 )
-  {
-    perror("fork failed!\n");
-    exit(EXIT_FAILURE);
-  }
-
-  // gdb will be attached to this process
-  if ( sigPid == 0 )
-  {
-    getInstance()->dontCatch();
-    // wait for message from parent when it has attached gdb
-    int someData;
-
-    read( sigPipe[0], &someData, sizeof(someData) );
-
-    if ( someData != 0x12345678 )
-    {
-      PRINTF(0)("something went wrong :(\n");
-    }
-
-    return;
-  }
-
-  int gdbIn[2];
-  int gdbOut[2];
-  int gdbErr[2];
-
-  if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
-  {
-    perror("pipe failed!\n");
-    kill( sigPid, SIGTERM );
-    waitpid( sigPid, NULL, 0 );
-    exit(EXIT_FAILURE);
-  }
-
-  int gdbPid = fork();
-  // this process will run gdb
-
-  if ( gdbPid == -1 )
-  {
-    perror("fork failed\n");
-    kill( sigPid, SIGTERM );
-    waitpid( sigPid, NULL, 0 );
-    exit(EXIT_FAILURE);
-  }
-
-  if ( gdbPid == 0 )
-  {
-    // start gdb
-
-    close(gdbIn[1]);
-    close(gdbOut[0]);
-    close(gdbErr[0]);
-
-    dup2( gdbIn[0], STDIN_FILENO );
-    dup2( gdbOut[1], STDOUT_FILENO );
-    dup2( gdbErr[1], STDERR_FILENO );
-
-    execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
-  }
-
-  char cmd[256];
-  snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
-  write( gdbIn[1], cmd, strlen(cmd) );
-
-  int charsFound = 0;
-  int promptFound = 0;
-  char byte;
-  while ( read( gdbOut[0], &byte, 1 ) == 1 )
-  {
-    if (
-      charsFound == 0 && byte == '(' ||
-      charsFound == 1 && byte == 'g' ||
-      charsFound == 2 && byte == 'd' ||
-      charsFound == 3 && byte == 'b' ||
-      charsFound == 4 && byte == ')' ||
-      charsFound == 5 && byte == ' '
-        )
-          charsFound++;
-    else
-      charsFound = 0;
-
-    if ( charsFound == 6 )
-    {
-      promptFound++;
-      charsFound = 0;
-    }
-
-    if ( promptFound == 3 )
-    {
-      break;
-    }
-  }
-
-  int someData = 0x12345678;
-  write( sigPipe[1], &someData, sizeof(someData) );
-
-  write( gdbIn[1], "bt\nk\nq\n", 7 );
-
-
-  charsFound = 0;
-  promptFound = 0;
-  std::string bt;
-  while ( read( gdbOut[0], &byte, 1 ) == 1 )
-  {
-    bt += std::string( &byte, 1 );
-
-    if (
-      charsFound == 0 && byte == '(' ||
-      charsFound == 1 && byte == 'g' ||
-      charsFound == 2 && byte == 'd' ||
-      charsFound == 3 && byte == 'b' ||
-      charsFound == 4 && byte == ')' ||
-      charsFound == 5 && byte == ' '
-        )
-          charsFound++;
-    else
-      charsFound = 0;
-
-    if ( charsFound == 6 )
-    {
-      promptFound++;
-      charsFound = 0;
-      bt += "\n";
-    }
-
-    if ( promptFound == 3 )
-    {
-      break;
-    }
-  }
-
-
-  waitpid( sigPid, NULL, 0 );
-  waitpid( gdbPid, NULL, 0 );
-
-  int wsRemoved = 0;
-
-  while ( wsRemoved < 2 && bt.length() > 0 )
-  {
-    if ( bt[1] == '\n' )
-      wsRemoved++;
-    bt.erase(0, 1);
-  }
-
-  if ( bt.length() > 0 )
-    bt.erase(0, 1);
-
-  time_t now = time(NULL);
-
-  std::string timeString = "\n\n\n\n"
-                     "=======================================================\n"
-                     "= time: " + std::string(ctime(&now)) +
-         "=======================================================\n";
-  bt.insert(0, timeString);
-
-  FILE * f = fopen( getInstance()->fileName.c_str(), "a" );
-
-  if ( !f )
-  {
-    perror( ( std::string( "could not append to " ) + getInstance()->fileName ).c_str() );
-    exit(EXIT_FAILURE);
-  }
-
-  if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
-  {
-    PRINTF(0)( ( std::string("could not write %d byte to ") + getInstance()->fileName ).c_str(), bt.length());
-    exit(EXIT_FAILURE);
-  }
-
-  exit(EXIT_FAILURE);
-}
-
-void SignalHandler::registerCallback( SignalCallback cb, void * someData )
-{
-  SignalCallbackRec rec;
-  rec.cb = cb;
-  rec.someData = someData;
-
-  callbackList.push_back(rec);
-}
-
-#endif /* __WIN32__ */
Index: code/trunk/src/core/SignalHandler.h
===================================================================
--- code/trunk/src/core/SignalHandler.h	(revision 1740)
+++ 	(revision )
@@ -1,108 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Christoph Renner
- *   Co-authors:
- *      ...
- *
- */
-
-/**
-    @file SignalHandler.h
-    @brief Definition of the SignalHandler class.
-*/
-
-#ifndef _SignalHandler_H__
-#define _SignalHandler_H__
-
-#include "CorePrereqs.h"
-
-#include <list>
-#include <string>
-
-typedef int (*SignalCallback)( void * someData );
-
-#ifndef __WIN32__
-#include <signal.h>
-
-struct SignalRec
-{
-  int signal;
-  sig_t handler;
-};
-
-struct SignalCallbackRec
-{
-  SignalCallback cb;
-  void * someData;
-};
-
-
-typedef std::list<SignalRec> SignalRecList;
-typedef std::list<SignalCallbackRec> SignalCallbackList;
-
-class SignalHandler
-{
-  private:
-    SignalHandler();
-  public:
-    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
-    ~SignalHandler(){ SignalHandler::singletonRef = NULL; }
-
-    void registerCallback( SignalCallback cb, void * someData );
-
-    void doCatch( const std::string & appName, const std::string & fileName );
-    void dontCatch();
-
-  private:
-    static void sigHandler( int sig );
-
-    void catchSignal( int sig );
-    SignalRecList sigRecList;
-
-    SignalCallbackList callbackList;
-
-    static SignalHandler * singletonRef;
-
-    std::string appName;
-    std::string fileName;
-
-    // used to turn on KeyAutoRepeat if OIS crashes
-    static bool bXAutoKeyRepeatOn_;
-};
-
-#else /* #ifndef __WIN32__ */
-
-class _CoreExport SignalHandler
-{
- public:
-   inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
-   void doCatch( const std::string & appName, const std::string & fileName ) {};
-  void dontCatch() {};
-  void registerCallback( SignalCallback cb, void * someData ) {};
-
- private:
-    static SignalHandler * singletonRef;
-};
-#endif /* #ifndef __WIN32__ */
-
-#endif /* _SignalHandler_H__ */
Index: code/trunk/src/core/Super.h
===================================================================
--- code/trunk/src/core/Super.h	(revision 1747)
+++ code/trunk/src/core/Super.h	(revision 1747)
@@ -0,0 +1,486 @@
+/*
+ *   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 Super.h
+    @brief Definition of all super-function related macros.
+
+    This file defines all macros needed to add a new "super-function".
+    If you add a super-function, you can call SUPER(myclass, functionname) inside your
+    code and the function of the parentclass gets called. This is comparable with
+    super.functionname() in Java or other languages.
+
+    This works only with virtual functions that return nothing (void) and belong to
+    classes that have an Identifier. Arguments however are supported.
+
+    To add a new super-function, you have process 4 steps:
+
+    1) Add a new SUPER macro
+       This allows you to call the super-function in your code.
+       Location: This file (Super.h), marked with --> HERE <-- comments (1/3)
+
+    2) Call the SUPER_FUNCTION_GLOBAL_DECLARATION_PART1/2 macros.
+       This defines some global classes and templates, needed to create and call the super-functions.
+       Location: This file (Super.h), marked with --> HERE <-- comments (2/3)
+
+    3) Call the SUPER_INTRUSIVE_DECLARATION macro.
+       This will be included into the declaration of ClassIdentifier<T>.
+       Location: This file (Super.h), marked with --> HERE <-- comments (3/3)
+
+    4) Call the SUPER_FUNCTION macro.
+       This defines a partially specialized template that will decide if a class is "super" to another class.
+       If the check returns true, a SuperFunctionCaller gets created, which will be used by the SUPER macro.
+       You have to add this into the header-file of the baseclass of the super-function (the class that first
+       implements the function), below the class declaration. You can't call it directly in this file, because
+       otherwise you had to include the headerfile right here, which would cause some ugly backdependencies,
+       include loops and slower compilation.
+       Dont forget to include Super.h in the header-file.
+       Location: The header-file of the baseclass (Baseclass.h), below the class declaration
+*/
+
+#ifndef _Super_H__
+#define _Super_H__
+
+#include <iostream>
+
+#include "CorePrereqs.h"
+
+#include "util/Debug.h"
+#include "util/XMLIncludes.h"
+
+///////////////////////
+// Macro definitions //
+///////////////////////
+
+//// Common macros ////
+
+    /**
+        @brief Declares a new super-function by creating a specialized template. Add this below the class declaration of the baseclass.
+        @param functionnumber Each super-function needs a unique number, starting with zero, increasing by one
+        @param baseclass The baseclass of the super-function (~the root)
+        @param functionname The name of the super-function
+        @param purevirtualbase "true" if the function is pure virtual in the baseclass, "false" if the function is implemented (without "")
+    */
+    #define SUPER_FUNCTION(functionnumber, baseclass, functionname, purevirtualbase) \
+        template <class T, int templatehack2> \
+        struct SuperFunctionCondition<functionnumber, T, 0, templatehack2> \
+        { \
+            static void check() \
+            { \
+                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply((T*)0); \
+                SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::check(); \
+            } \
+            \
+            static void apply(void* temp) {} \
+            static void apply(baseclass* temp) \
+            { \
+                ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier(); \
+                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it) \
+                { \
+                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
+                    { \
+                        COUT(5) << "Added SuperFunctionCaller for " << #functionname << ": " << ClassIdentifier<T>::getIdentifier()->getName() << " <- " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl; \
+                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>; \
+                    } \
+                } \
+            } \
+        }; \
+        \
+        SUPER_FUNCTION_PUREVIRTUAL_WORKAROUND##purevirtualbase(functionnumber, baseclass)
+
+    #define SUPER_FUNCTION_PUREVIRTUAL_WORKAROUND0(functionnumber, baseclass) SUPER_FUNCTION_PUREVIRTUAL_WORKAROUNDfalse(functionnumber, baseclass)
+    #define SUPER_FUNCTION_PUREVIRTUAL_WORKAROUND1(functionnumber, baseclass) SUPER_FUNCTION_PUREVIRTUAL_WORKAROUNDtrue(functionnumber, baseclass)
+    #define SUPER_FUNCTION_PUREVIRTUAL_WORKAROUNDfalse(functionnumber, baseclass)
+    #define SUPER_FUNCTION_PUREVIRTUAL_WORKAROUNDtrue(functionnumber, baseclass) \
+        template <int templatehack2> \
+        struct SuperFunctionCondition<functionnumber, baseclass, 0, templatehack2> \
+        { \
+            static void check() \
+            { \
+                SuperFunctionCondition<functionnumber + 1, baseclass, 0, templatehack2>::check(); \
+            } \
+        };
+
+
+    /*
+    //// Comments about the macro ////
+
+        // Partially specialized template (templatehack is now specialized too).
+        //
+        // This ensures the compiler takes THIS template if the header-file of the super-function
+        // is included. In any other case, the compiler just uses the fallback template which is
+        // defined in this file.
+        template <class T, templatehack2>
+        struct SuperFunctionCondition<functionnumber, T, 0, templatehack2>
+        {
+            static void check()
+            {
+                // This call to the apply-function is the whole check. By calling the function with
+                // a T* pointer, the right function get's called.
+                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply((T*)0);
+
+                // Go go the check for of next super-function (functionnumber + 1)
+                SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::check();
+            }
+
+            // This function gets called if T is not a child of the baseclass.
+            // The function does nothing.
+            static void apply(void* temp) {}
+
+            // This function gets called if T is a child of the baseclass and can therefore be converted.
+            // The function adds a SuperFunctionCaller to the Identifier of all subclasses of T.
+            static void apply(baseclass* temp)
+            {
+                ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
+
+                // Iterate through all children
+                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it)
+                {
+                    // Check if there's not already a caller
+                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
+                    {
+                        // Add the SuperFunctionCaller
+                        COUT(5) << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl;
+                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_##functionname <T>;
+                    }
+                }
+            }
+        };
+        SUPER_FUNCTION_PUREVIRTUAL_WORKAROUND##purevirtualbase
+
+
+        // The following piece of code is only added if purevirtualbase = true
+
+        // Explicit specialization of the Condition template for the baseclass to avoid
+        // errors if the function is pure virtual in the baseclass.
+        template <int templatehack2> \
+        struct SuperFunctionCondition<functionnumber, baseclass, 0, templatehack2> \
+        { \
+            // The check function just behaves like the fallback - it advances to the check for the next super-function (functionnumber + 1)
+            static void check() \
+            { \
+                SuperFunctionCondition<functionnumber + 1, baseclass, 0, templatehack2>::check(); \
+            } \
+        };
+    */
+
+    // SUPER-macro: Calls Parent::functionname() where Parent is the direct parent of classname
+    #define SUPER(classname, functionname, ...) \
+        SUPER_##functionname(classname, functionname, __VA_ARGS__)
+
+    // helper macro: for functions without arguments
+    #define SUPER_NOARGS(classname, functionname) \
+        (*ClassIdentifier<classname>::getIdentifier()->superFunctionCaller_##functionname##_)(this)
+
+    // helper macro: for functions with arguments
+    #define SUPER_ARGS(classname, functionname, ...) \
+        (*ClassIdentifier<classname>::getIdentifier()->superFunctionCaller_##functionname##_)(this, __VA_ARGS__)
+
+
+//// Function-specific macros ////
+
+    /*
+        Add a macro for each super-function
+
+        Example (no arguments):
+        #define SUPER_myfunction(classname, functionname, ...) \
+            SUPER_NOARGS(classname, functionname)
+
+        Example (with arguments):
+        #define SUPER_myfunction(classname, functionname, ...) \
+            SUPER_ARGS(classname, functionname, __VA_ARGS__)
+    */
+
+    // (1/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
+    #define SUPER_XMLPort(classname, functionname, ...) \
+        SUPER_ARGS(classname, functionname, __VA_ARGS__)
+
+    #define SUPER_tick(classname, functionname, ...) \
+        SUPER_ARGS(classname, functionname, __VA_ARGS__)
+
+    #define SUPER_changedActivity(classname, functionname, ...) \
+        SUPER_NOARGS(classname, functionname)
+
+    #define SUPER_changedVisibility(classname, functionname, ...) \
+        SUPER_NOARGS(classname, functionname)
+    // (1/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
+
+
+namespace orxonox
+{
+    /////////////////////////////////////////////////////////////////////////////////////////////////////
+    // This code gets included by Identifier.h and every other header file that needs a super-function //
+    /////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    //// Common code ////
+
+        // Base templates
+        /**
+            @brief Creates the SuperFunctionCaller if T is a child of the super-functions baseclass.
+        */
+        template <int functionnumber, class T, int templatehack1, int templatehack2>
+        struct SuperFunctionCondition
+        {
+            static void check() {}
+        };
+
+        /**
+            @brief Initializes the SuperFunctionCaller-pointer with zero.
+        */
+        template <int functionnumber, class T>
+        struct SuperFunctionInitialization
+        {
+            static void initialize(ClassIdentifier<T>* identifier) {}
+        };
+
+        /**
+            @brief Deletes the SuperFunctionCaller.
+        */
+        template <int functionnumber, class T>
+        struct SuperFunctionDestruction
+        {
+            static void destroy(ClassIdentifier<T>* identifier) {}
+        };
+
+
+    //// Function-specific code ////
+
+        /**
+            @brief Creates the needed objects and templates to call a super-function.
+            @param functionnumber Each super-function needs a unique number, starting with zero, increasing by one
+            @param functionname The name of the super-function
+            @param hasarguments "false" if the function doesn't take any arguments, "true" if it does (without "")
+            @param ... Variadic: If the function takes arguments, add them here with type and name. Example: int myvalue, float myothervalue
+        */
+        #define SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(functionnumber, functionname, hasarguments, ...) \
+            template <class T, int templatehack1, int templatehack2> \
+            struct SuperFunctionCondition<functionnumber, T, templatehack1, templatehack2> \
+            { \
+                static void check() \
+                { \
+                    SuperFunctionCondition<functionnumber + 1, T, templatehack1, templatehack2>::check(); \
+                } \
+            }; \
+            \
+            template <class T> \
+            struct SuperFunctionInitialization<functionnumber, T> \
+            { \
+                static void initialize(ClassIdentifier<T>* identifier) \
+                { \
+                    identifier->superFunctionCaller_##functionname##_ = 0; \
+                    SuperFunctionInitialization<functionnumber + 1, T>::initialize(identifier); \
+                } \
+            }; \
+            \
+            template <class T> \
+            struct SuperFunctionDestruction<functionnumber, T> \
+            { \
+                static void destroy(ClassIdentifier<T>* identifier) \
+                { \
+                    if (identifier->superFunctionCaller_##functionname##_) \
+                        delete identifier->superFunctionCaller_##functionname##_; \
+                    SuperFunctionDestruction<functionnumber + 1, T>::destroy(identifier); \
+                } \
+            }; \
+            \
+            class _CoreExport SuperFunctionCaller_##functionname \
+            { \
+                public: \
+                    virtual void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) = 0; \
+                    virtual ~SuperFunctionCaller_##functionname () {} \
+            }; \
+            \
+            template <class T> \
+            class SuperFunctionClassCaller_##functionname : public SuperFunctionCaller_##functionname \
+            { \
+                public: \
+                    inline void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) \
+                    { \
+                        (dynamic_cast<T*>(object))->T:: functionname
+
+        /*
+            JUST ADD THE FUNCTION ARGUMENTS BETWEEN BOTH MACROS, ENCLOSED BY BRACKETS
+            EXAMPLE:
+
+              SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(0, myfunction, true, int myvalue, float myothervalue) <-- !!! DONT ADD A SEMICOLON HERE !!!
+                (myvalue, myothervalue)
+              SUPER_FUNCTION_GLOBAL_DECLARATION_PART2
+        */
+
+        #define SUPER_FUNCTION_GLOBAL_DECLARATION_PART2 \
+                                                        ; \
+                    } \
+            };
+
+        #define SUPER_CALL_ARGUMENTSfalse(...) OrxonoxClass* object
+        #define SUPER_CALL_ARGUMENTS0(...)     OrxonoxClass* object
+        #define SUPER_CALL_ARGUMENTStrue(...) OrxonoxClass* object, __VA_ARGS__
+        #define SUPER_CALL_ARGUMENTS1(...)    OrxonoxClass* object, __VA_ARGS__
+
+
+    /*
+    //// COMMENTS ABOUT THE MACRO ////
+
+        // Partially specialized template (templatehack not yet specialized, this
+        // will be done by the real condition in the header-file of the super-function)
+        // Only used as fallback
+        template <class T, int templatehack1, int templatehack2>
+        struct SuperFunctionCondition<functionnumber, T, templatehack1, templatehack2>
+        {
+            // If this function gets called, the header-file of the super function is not
+            // included, so this fallback template (templatehack not specialized) is used
+            static void check()
+            {
+                // Calls the condition-check of the next super-function (functionnumber + 1)
+                SuperFunctionCondition<functionnumber + 1, T, templatehack1, templatehack2>::check();
+            }
+        };
+
+        // Initializes the SuperFunctionCaller-pointer with zero.
+        template <class T>
+        struct SuperFunctionInitialization<functionnumber, T>
+        {
+            static void initialize(ClassIdentifier<T>* identifier)
+            {
+                identifier->superFunctionCaller_##functionname##_ = 0;
+
+                // Calls the initialization of the next super-function (functionnumber + 1)
+                SuperFunctionInitialization<functionnumber + 1, T>::initialize(identifier);
+            }
+        };
+
+        // Deletes the SuperFunctionCaller.
+        template <class T>
+        struct SuperFunctionDestruction<functionnumber, T>
+        {
+            static void destroy(ClassIdentifier<T>* identifier)
+            {
+                if (identifier->superFunctionCaller_##functionname##_)
+                    delete identifier->superFunctionCaller_##functionname##_;
+
+                // Calls the destruction of the next super-function (functionnumber + 1)
+                SuperFunctionDestruction<functionnumber + 1, T>::destroy(identifier);
+            }
+        };
+
+        // Baseclass of the super-function caller. The real call will be done by a
+        // templatized subclass through the virtual () operator.
+        class _CoreExport SuperFunctionCaller_##functionname
+        {
+            public:
+                virtual void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) = 0;
+                virtual ~SuperFunctionCaller_##functionname () {}
+        };
+
+        // The real super-function caller: Calls T::functionname()
+        // T should be the parent, but this will be done by the spezialized condition template
+        template <class T>
+        class SuperFunctionClassCaller_##functionname : public SuperFunctionCaller_##functionname
+        {
+            public:
+                // @brief Calls the function.
+                // @param object The object to call the function on
+                // @param ... The arguments of the function
+                inline void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) )
+                {
+                    (dynamic_cast<T*>(object))->T:: functionname ( Call the function with it's arguments );
+                }
+        }
+    */
+
+
+    //// Execute the code for each super-function ////
+
+        // (2/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(0, XMLPort, true, Element& xmlelement, XMLPort::Mode mode)
+            (xmlelement, mode)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(1, tick, true, float dt)
+            (dt)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(2, changedActivity, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(3, changedVisibility, false)
+            ()
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        // (2/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
+
+}
+
+#else /* _Super_H__ */
+  #ifdef SUPER_INTRUSIVE_DECLARATION_INCLUDE
+
+//////////////////////////////////////////////////////////////////////////
+// This code gets included within the declaration of ClassIdentifier<T> //
+//////////////////////////////////////////////////////////////////////////
+
+//// Common code ////
+
+    private:
+
+        template <int functionnumber, class TT, int templatehack1, int templatehack2>
+        friend struct SuperFunctionCondition;
+
+        // Creates the super-function-callers by calling the first SuperFunctionCondition check
+        // This get's called within the initialization of an Identifier
+        virtual void createSuperFunctionCaller() const
+        {
+            SuperFunctionCondition<0, T, 0, 0>::check();
+        }
+
+
+//// Function-specific code ////
+
+    public:
+        /**
+            @brief Adds a pointer to the SuperFunctionCaller as a member of ClassIdentifier.
+            @param functionname The name of the super-function
+        */
+        #ifndef SUPER_INTRUSIVE_DECLARATION
+          #define SUPER_INTRUSIVE_DECLARATION(functionname) \
+            SuperFunctionCaller_##functionname * superFunctionCaller_##functionname##_
+        #endif
+
+
+//// Execute the code for each super-function ////
+
+    // (3/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
+    SUPER_INTRUSIVE_DECLARATION(XMLPort);
+    SUPER_INTRUSIVE_DECLARATION(tick);
+    SUPER_INTRUSIVE_DECLARATION(changedActivity);
+    SUPER_INTRUSIVE_DECLARATION(changedVisibility);
+    // (3/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
+
+
+    #undef SUPER_INTRUSIVE_DECLARATION_INCLUDE
+  #endif /* SUPER_INTRUSIVE_DECLARATION_INCLUDE */
+#endif /* _Super_H__ */
Index: code/trunk/src/core/TclBind.cc
===================================================================
--- code/trunk/src/core/TclBind.cc	(revision 1740)
+++ code/trunk/src/core/TclBind.cc	(revision 1747)
@@ -32,13 +32,13 @@
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
-#include "Debug.h"
 #include "TclThreadManager.h"
 #include "TclBind.h"
+#include "util/Debug.h"
 #include "util/String.h"
 
 namespace orxonox
 {
-    SetConsoleCommandShortcutGeneric(tcl, createConsoleCommand(createFunctor(&TclBind::tcl), "tcl"));
-    SetConsoleCommandShortcutGeneric(bgerror, createConsoleCommand(createFunctor(&TclBind::bgerror), "bgerror"));
+    SetConsoleCommandShortcut(TclBind, tcl);
+    SetConsoleCommandShortcut(TclBind, bgerror);
 
     TclBind::TclBind()
@@ -115,5 +115,5 @@
 
         if (CommandExecutor::getLastEvaluation().hasReturnvalue())
-            return CommandExecutor::getLastEvaluation().getReturnvalue().toString();
+            return CommandExecutor::getLastEvaluation().getReturnvalue().getString();
 
         return "";
Index: code/trunk/src/core/TclThreadManager.cc
===================================================================
--- code/trunk/src/core/TclThreadManager.cc	(revision 1740)
+++ code/trunk/src/core/TclThreadManager.cc	(revision 1747)
@@ -38,7 +38,7 @@
 #include "ConsoleCommand.h"
 #include "CommandExecutor.h"
-#include "Debug.h"
 #include "TclBind.h"
 #include "TclThreadManager.h"
+#include "util/Debug.h"
 #include "util/Convert.h"
 
@@ -48,15 +48,13 @@
 namespace orxonox
 {
-    SetConsoleCommandShortcutGeneric(tclexecute, createConsoleCommand(createFunctor(&TclThreadManager::execute), "tclexecute")).setArgumentCompleter(0, autocompletion::tclthreads());
-    SetConsoleCommandShortcutGeneric(tclquery,   createConsoleCommand(createFunctor(&TclThreadManager::query),   "tclquery"  )).setArgumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommandShortcutAlias(TclThreadManager, execute, "tclexecute").argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommandShortcutAlias(TclThreadManager, query,   "tclquery"  ).argumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, create,  false);
-    SetConsoleCommand(TclThreadManager, destroy, false).setArgumentCompleter(0, autocompletion::tclthreads());
-    SetConsoleCommand(TclThreadManager, execute, false).setArgumentCompleter(0, autocompletion::tclthreads());
-    SetConsoleCommand(TclThreadManager, query,   false).setArgumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, destroy, false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, execute, false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, query,   false).argumentCompleter(0, autocompletion::tclthreads());
     SetConsoleCommand(TclThreadManager, status,  false);
-    SetConsoleCommand(TclThreadManager, dump,    false).setArgumentCompleter(0, autocompletion::tclthreads());
-    SetConsoleCommand(TclThreadManager, flush,   false).setArgumentCompleter(0, autocompletion::tclthreads());
-
-    TclThreadManager* instance_tclthreadmanager = &TclThreadManager::getInstance();
+    SetConsoleCommand(TclThreadManager, dump,    false).argumentCompleter(0, autocompletion::tclthreads());
+    SetConsoleCommand(TclThreadManager, flush,   false).argumentCompleter(0, autocompletion::tclthreads());
 
     TclThreadManager::TclThreadManager()
@@ -72,4 +70,17 @@
         //
 #endif
+    }
+
+    TclThreadManager::~TclThreadManager()
+    {
+        unsigned int threadID;
+        {
+            boost::mutex::scoped_lock bundles_lock(this->bundlesMutex_);
+            if (this->interpreterBundles_.begin() == this->interpreterBundles_.end())
+                return;
+            else
+                threadID = this->interpreterBundles_.begin()->first;
+        }
+        this->destroy(threadID);
     }
 
@@ -508,5 +519,5 @@
 
                 if (CommandExecutor::getLastEvaluation().hasReturnvalue())
-                    output = CommandExecutor::getLastEvaluation().getReturnvalue().toString();
+                    output = CommandExecutor::getLastEvaluation().getReturnvalue().getString();
             }
 
Index: code/trunk/src/core/TclThreadManager.h
===================================================================
--- code/trunk/src/core/TclThreadManager.h	(revision 1740)
+++ code/trunk/src/core/TclThreadManager.h	(revision 1747)
@@ -69,4 +69,7 @@
     class _CoreExport TclThreadManager : public OrxonoxClass
     {
+        friend class IRC;
+        friend class TclBind;
+
         public:
             static TclThreadManager& getInstance();
@@ -81,4 +84,16 @@
             static void flush(unsigned int threadID);
 
+            void error(const std::string& error);
+            void debug(const std::string& error);
+
+            virtual void tick(float dt);
+
+            std::list<unsigned int> getThreadList() const;
+
+        private:
+            TclThreadManager();
+            TclThreadManager(const TclThreadManager& other);
+            ~TclThreadManager();
+
             static void tcl_execute(Tcl::object const &args);
             static std::string tcl_query(int querierID, Tcl::object const &args);
@@ -89,6 +104,4 @@
             TclInterpreterBundle* getInterpreterBundle(unsigned int threadID);
             std::string dumpList(const std::list<unsigned int>& list);
-            void error(const std::string& error);
-            void debug(const std::string& error);
 
             void pushCommandToQueue(const std::string& command);
@@ -105,13 +118,4 @@
             std::string evalQuery(unsigned int querierID, const std::string& command);
             std::string evalQuery(unsigned int querierID, unsigned int threadID, const std::string& command);
-
-            virtual void tick(float dt);
-
-            std::list<unsigned int> getThreadList() const;
-
-        private:
-            TclThreadManager();
-            TclThreadManager(const TclThreadManager& other);
-            ~TclThreadManager() {}
 
             unsigned int threadCounter_;
Index: code/trunk/src/core/XMLPort.h
===================================================================
--- code/trunk/src/core/XMLPort.h	(revision 1740)
+++ code/trunk/src/core/XMLPort.h	(revision 1747)
@@ -32,9 +32,9 @@
 #include "CorePrereqs.h"
 
+#include "util/Debug.h"
 #include "util/XMLIncludes.h"
-#include "util/MultiTypeMath.h"
+#include "util/MultiType.h"
 #include "tinyxml/ticpp.h"
 #include "Executor.h"
-#include "Debug.h"
 #include "CoreIncludes.h"
 #include "BaseObject.h"
@@ -42,34 +42,39 @@
 
 #define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode)
-#define XMLPortParam_Template(classname, paramname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
+#define XMLPortParamTemplate(classname, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
 
 #define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
-#define XMLPortParamLoadOnly_Template(classname, paramname, loadtemplate, loadfunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
-
-#define XMLPortParamGeneric(containername, classname, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
-    orxonox::XMLPortClassParamContainer<classname>* containername = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamLoadOnlyTemplate(classname, paramname, loadfunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+
+#define XMLPortParamExtern(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
+#define XMLPortParamExternTemplate(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
+
+#define XMLPortParamGeneric(containername, classname, objectclass, object, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
+    orxonox::XMLPortClassParamContainer<objectclass>* containername = (orxonox::XMLPortClassParamContainer<objectclass>*)(ClassIdentifier<classname>::getIdentifier()->getXMLPortParamContainer(paramname)); \
     if (!containername) \
     { \
-        containername = new orxonox::XMLPortClassParamContainer<classname>(std::string(paramname), loadexecutor, saveexecutor); \
-        this->getIdentifier()->addXMLPortParamContainer(paramname, containername); \
+        containername = new orxonox::XMLPortClassParamContainer<objectclass>(std::string(paramname), ClassIdentifier<classname>::getIdentifier(), loadexecutor, saveexecutor); \
+        ClassIdentifier<classname>::getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     } \
-    containername->port(this, xmlelement, mode)
+    containername->port((BaseObject*)this, object, xmlelement, mode)
 
 
 #define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
-#define XMLPortObject_Template(classname, objectclass, sectionname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+#define XMLPortObjectTemplate(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore, ...) \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 
 #define XMLPortObjectGeneric(containername, classname, objectclass, sectionname, loadexecutor, saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(this->getIdentifier()->getXMLPortObjectContainer(sectionname)); \
+    orxonox::XMLPortClassObjectContainer<classname, objectclass>* containername = (orxonox::XMLPortClassObjectContainer<classname, objectclass>*)(ClassIdentifier<classname>::getIdentifier()->getXMLPortObjectContainer(sectionname)); \
     if (!containername) \
     { \
-        containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
-        this->getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
+        containername = new orxonox::XMLPortClassObjectContainer<classname, objectclass>(std::string(sectionname), ClassIdentifier<classname>::getIdentifier(), loadexecutor, saveexecutor, bApplyLoaderMask, bLoadBefore); \
+        ClassIdentifier<classname>::getIdentifier()->addXMLPortObjectContainer(sectionname, containername); \
     } \
     containername->port(this, xmlelement, mode)
@@ -102,15 +107,16 @@
             virtual const std::string& getDescription() = 0;
 
-            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4) = 0;
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5) = 0;
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4) = 0;
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) = 0;
 
         protected:
             std::string paramname_;
             ParseResult parseResult_;
-
+            Identifier* identifier_;
+            BaseObject* owner_;
     };
 
@@ -126,13 +132,15 @@
 
         public:
-            XMLPortClassParamContainer(const std::string paramname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
+            XMLPortClassParamContainer(const std::string paramname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor)
             {
                 this->paramname_ = paramname;
+                this->identifier_ = identifier;
                 this->loadexecutor_ = loadexecutor;
                 this->saveexecutor_ = saveexecutor;
             }
 
-            XMLPortParamContainer& port(T* object, Element& xmlelement, XMLPort::Mode mode)
-            {
+            XMLPortParamContainer& port(BaseObject* owner, T* object, Element& xmlelement, XMLPort::Mode mode)
+            {
+                this->owner_ = owner;
                 this->parseParams_.object = object;
                 this->parseParams_.xmlelement = &xmlelement;
@@ -146,5 +154,5 @@
                         if ((attribute.size() > 0) || (this->loadexecutor_->allDefaultValuesSet()))
                         {
-                            COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")." << std::endl << ((BaseObject*)object)->getLoaderIndentation();
+                            COUT(5) << this->owner_->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << this->owner_->getName() << ")." << std::endl << this->owner_->getLoaderIndentation();
                             if (this->loadexecutor_->parse(object, attribute, ","))
                                 this->parseResult_ = PR_finished;
@@ -158,5 +166,5 @@
                     {
                         COUT(1) << std::endl;
-                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << ((BaseObject*)object)->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
                     }
@@ -173,7 +181,7 @@
             }
 
-            XMLPortParamContainer& port(const ParseParams& parseParams)
-            {
-                return this->port(parseParams.object, *parseParams.xmlelement, parseParams.mode);
+            XMLPortParamContainer& port(BaseObject* owner, const ParseParams& parseParams)
+            {
+                return this->port(owner, parseParams.object, *parseParams.xmlelement, parseParams.mode);
             }
 
@@ -181,5 +189,5 @@
             {
                 if (result == PR_waiting_for_default_values)
-                    return this->port(params);
+                    return this->port(this->owner_, params);
                 else
                     return (*this);
@@ -191,5 +199,5 @@
                 { return this->loadexecutor_->getDescription(); }
 
-            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiTypeMath& param)
+            virtual XMLPortParamContainer& defaultValue(unsigned int index, const MultiType& param)
             {
                 if (!this->loadexecutor_->defaultValueSet(index))
@@ -197,5 +205,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1)
             {
                 if (!this->loadexecutor_->defaultValueSet(0))
@@ -203,5 +211,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)))
@@ -209,5 +217,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)))
@@ -215,5 +223,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)))
@@ -221,5 +229,5 @@
                 return this->portIfWaitingForDefaultValues(this->parseResult_, this->parseParams_);
             }
-            virtual XMLPortParamContainer& defaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+            virtual XMLPortParamContainer& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
             {
                 if ((!this->loadexecutor_->defaultValueSet(0)) || (!this->loadexecutor_->defaultValueSet(1)) || (!this->loadexecutor_->defaultValueSet(2)) || (!this->loadexecutor_->defaultValueSet(3)) || (!this->loadexecutor_->defaultValueSet(4)))
@@ -257,4 +265,5 @@
             bool bApplyLoaderMask_;
             bool bLoadBefore_;
+            Identifier* identifier_;
     };
 
@@ -263,7 +272,8 @@
     {
         public:
-            XMLPortClassObjectContainer(const std::string sectionname, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
+            XMLPortClassObjectContainer(const std::string sectionname, Identifier* identifier, ExecutorMember<T>* loadexecutor, ExecutorMember<T>* saveexecutor, bool bApplyLoaderMask, bool bLoadBefore)
             {
                 this->sectionname_ = sectionname;
+                this->identifier_ = identifier;
                 this->loadexecutor_ = loadexecutor;
                 this->saveexecutor_ = saveexecutor;
@@ -305,9 +315,9 @@
                                             {
                                                 newObject->XMLPort(*child, XMLPort::LoadObject);
-                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
                                             }
                                             else
                                             {
-                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
                                             }
 
@@ -336,5 +346,5 @@
                     {
                         COUT(1) << std::endl;
-                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
                     }
Index: code/trunk/src/core/input/Button.cc
===================================================================
--- code/trunk/src/core/input/Button.cc	(revision 1740)
+++ code/trunk/src/core/input/Button.cc	(revision 1747)
@@ -36,5 +36,5 @@
 #include "util/SubString.h"
 #include "util/String.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/ConsoleCommand.h"
 #include "core/CommandEvaluation.h"
Index: code/trunk/src/core/input/InputManager.cc
===================================================================
--- code/trunk/src/core/input/InputManager.cc	(revision 1740)
+++ code/trunk/src/core/input/InputManager.cc	(revision 1747)
@@ -39,8 +39,8 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Debug.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
 #include "core/Shell.h"               // hack!
+#include "util/Debug.h"
 
 #include "InputBuffer.h"
@@ -321,7 +321,7 @@
     if (joySticksSize_)
     {
-      std::vector<MultiTypeMath> coeffPos;
-      std::vector<MultiTypeMath> coeffNeg;
-      std::vector<MultiTypeMath> zero;
+      std::vector<double> coeffPos;
+      std::vector<double> coeffNeg;
+      std::vector<int> zero;
       coeffPos.resize(24);
       coeffNeg.resize(24);
@@ -340,5 +340,5 @@
           getIdentifier()->addConfigValueContainer("CoeffPos", cont);
       }
-      cont->getValue(&coeffPos);
+      cont->getValue(&coeffPos, this);
 
       cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
@@ -348,5 +348,5 @@
           getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
       }
-      cont->getValue(&coeffNeg);
+      cont->getValue(&coeffNeg, this);
 
       cont = getIdentifier()->getConfigValueContainer("Zero");
@@ -356,5 +356,5 @@
           getIdentifier()->addConfigValueContainer("Zero", cont);
       }
-      cont->getValue(&zero);
+      cont->getValue(&zero, this);
 
       // copy values to our own variables
Index: code/trunk/src/core/input/KeyBinder.cc
===================================================================
--- code/trunk/src/core/input/KeyBinder.cc	(revision 1740)
+++ code/trunk/src/core/input/KeyBinder.cc	(revision 1747)
@@ -36,5 +36,5 @@
 #include <string>
 #include "util/Convert.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
@@ -216,10 +216,10 @@
     if (!infile)
     {
-      ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "def_keybindings.ini");
-      ConfigFileManager::getSingleton()->save(CFT_Keybindings, "keybindings.ini");
+      ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "def_keybindings.ini");
+      ConfigFileManager::getInstance()->save(CFT_Keybindings, "keybindings.ini");
     }
     else
       infile.close();
-    ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "keybindings.ini");
+    ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "keybindings.ini");
 
     // parse key bindings
@@ -234,13 +234,13 @@
   void KeyBinder::setConfigValues()
   {
-    SetConfigValueGeneric(KeyBinder, analogThreshold_, 0.05f)  .description("Threshold for analog axes until which the state is 0.");
-    SetConfigValueGeneric(KeyBinder, mouseSensitivity_, 1.0f)  .description("Mouse sensitivity.");
-    SetConfigValueGeneric(KeyBinder, bDeriveMouseInput_, false).description("Whether or not to derive moues movement for the absolute value.");
-    SetConfigValueGeneric(KeyBinder, derivePeriod_, 0.05f).description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
-    SetConfigValueGeneric(KeyBinder, mouseSensitivityDerived_, 1.0f).description("Mouse sensitivity if mouse input is derived.");
-    SetConfigValueGeneric(KeyBinder, bClipMouse_, true).description("Whether or not to clip absolute value of mouse in non derive mode.");
+    SetConfigValue(analogThreshold_, 0.05f)  .description("Threshold for analog axes until which the state is 0.");
+    SetConfigValue(mouseSensitivity_, 1.0f)  .description("Mouse sensitivity.");
+    SetConfigValue(bDeriveMouseInput_, false).description("Whether or not to derive moues movement for the absolute value.");
+    SetConfigValue(derivePeriod_, 0.05f).description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
+    SetConfigValue(mouseSensitivityDerived_, 1.0f).description("Mouse sensitivity if mouse input is derived.");
+    SetConfigValue(bClipMouse_, true).description("Whether or not to clip absolute value of mouse in non derive mode.");
 
     float oldThresh = buttonThreshold_;
-    SetConfigValueGeneric(KeyBinder, buttonThreshold_, 0.80f).description("Threshold for analog axes until which the button is not pressed.");
+    SetConfigValue(buttonThreshold_, 0.80f).description("Threshold for analog axes until which the button is not pressed.");
     if (oldThresh != buttonThreshold_)
       for (unsigned int i = 0; i < nHalfAxes_s; i++)
@@ -268,9 +268,9 @@
     if (!cont)
     {
-      cont = new ConfigValueContainer(CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "");
+      cont = new ConfigValueContainer(CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "", button.name_);
       ClassIdentifier<KeyBinder>::getIdentifier()->addConfigValueContainer(button.name_, cont);
     }
     std::string old = button.bindingString_;
-    cont->getValue(&button.bindingString_);
+    cont->getValue(&button.bindingString_, this);
 
     // keybinder stuff
Index: code/trunk/src/core/input/KeyDetector.cc
===================================================================
--- code/trunk/src/core/input/KeyDetector.cc	(revision 1740)
+++ code/trunk/src/core/input/KeyDetector.cc	(revision 1747)
@@ -33,5 +33,5 @@
 
 #include "KeyDetector.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
 #include "core/CommandExecutor.h"
Index: code/trunk/src/network/ClientConnection.cc
===================================================================
--- code/trunk/src/network/ClientConnection.cc	(revision 1740)
+++ code/trunk/src/network/ClientConnection.cc	(revision 1747)
@@ -45,5 +45,5 @@
 
 #include "util/Sleep.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 
 namespace network
@@ -91,5 +91,5 @@
     return getPacket(address);
   }*/
-  
+
   ENetEvent *ClientConnection::getEvent(){
     if(!buffer.isEmpty())
Index: code/trunk/src/network/ConnectionManager.cc
===================================================================
--- code/trunk/src/network/ConnectionManager.cc	(revision 1740)
+++ code/trunk/src/network/ConnectionManager.cc	(revision 1747)
@@ -45,4 +45,5 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "objects/SpaceShip.h"
 #include "util/Math.h"
@@ -66,7 +67,7 @@
 {
   //boost::thread_group network_threads;
-  
+
   ConnectionManager *ConnectionManager::instance_=0;
-  
+
   ConnectionManager::ConnectionManager():receiverThread_(0){
     assert(instance_==0);
@@ -77,5 +78,5 @@
   }
   boost::recursive_mutex ConnectionManager::enet_mutex;
-  
+
 //   ConnectionManager::ConnectionManager(ClientInformation *head) : receiverThread_(0) {
 //     assert(instance_==0);
@@ -85,5 +86,5 @@
 //     bindAddress.port = NETWORK_PORT;
 //   }
-  
+
   ConnectionManager::ConnectionManager(int port){
     assert(instance_==0);
@@ -109,5 +110,5 @@
     bindAddress.port = NETWORK_PORT;
   }
-  
+
   ConnectionManager::~ConnectionManager(){
     instance_=0;
@@ -135,5 +136,5 @@
     return packet;
   }*/
-  
+
   ENetEvent *ConnectionManager::getEvent(){
     if(!buffer.isEmpty())
@@ -160,5 +161,5 @@
     return true;
   }
-  
+
 //   bool ConnectionManager::addPacket(Packet::Packet *packet){
 //     ClientInformation *temp = instance_->head_->findClient(packet->getClientID());
@@ -170,6 +171,6 @@
 //     //  TODO: finish implementation
 //   }
-//   
-  
+//
+
   bool ConnectionManager::addPacket(ENetPacket *packet, ENetPeer *peer) {
     boost::recursive_mutex::scoped_lock lock(instance_->enet_mutex);
@@ -276,5 +277,5 @@
     }
   }
-  
+
   //### added some bugfixes here, but we cannot test them because
   //### the server crashes everytime because of some gamestates
@@ -335,6 +336,6 @@
 
   /**
-   * 
-   * @param clientID 
+   *
+   * @param clientID
    */
   void ConnectionManager::syncClassid(unsigned int clientID) {
@@ -364,10 +365,10 @@
   }
 
-  
-  
+
+
   bool ConnectionManager::removeShip(ClientInformation *client){
     unsigned int id=client->getShipID();
-    orxonox::Iterator<orxonox::SpaceShip> it;
-    for(it = orxonox::ObjectList<orxonox::SpaceShip>::start(); it; ++it){
+    orxonox::ObjectList<orxonox::SpaceShip>::iterator it;
+    for(it = orxonox::ObjectList<orxonox::SpaceShip>::begin(); it; ++it){
       if(it->objectID!=id)
         continue;
@@ -376,6 +377,6 @@
     return true;
   }
-  
-  
+
+
   void ConnectionManager::disconnectClient(ClientInformation *client){
     {
@@ -386,5 +387,5 @@
     removeShip(client);
   }
-  
+
 
 }
Index: code/trunk/src/network/GamestateClient.cc
===================================================================
--- code/trunk/src/network/GamestateClient.cc	(revision 1740)
+++ code/trunk/src/network/GamestateClient.cc	(revision 1747)
@@ -33,4 +33,5 @@
 #include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
+#include "core/Iterator.h"
 #include "Synchronisable.h"
 
@@ -68,5 +69,5 @@
     return true;
   }
-  
+
   int GamestateClient::processGamestates(){
     if(tempGamestate_==NULL)
@@ -89,6 +90,6 @@
   * @return iterator pointing to the next object in the list
   */
-  void GamestateClient::removeObject(orxonox::Iterator<Synchronisable> &it) {
-    orxonox::Iterator<Synchronisable> temp=it;
+  void GamestateClient::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
+    orxonox::ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;
Index: code/trunk/src/network/GamestateClient.h
===================================================================
--- code/trunk/src/network/GamestateClient.h	(revision 1740)
+++ code/trunk/src/network/GamestateClient.h	(revision 1747)
@@ -42,5 +42,5 @@
 
 #include <map>
-// 
+//
 #include "NetworkPrereqs.h"
 #include "core/CorePrereqs.h"
@@ -58,8 +58,8 @@
     GamestateClient();
     ~GamestateClient();
-    
+
     bool add(packet::Gamestate *gs, int clientID);
     bool ack(int gamestateID, int clientID);
-    
+
     int processGamestates();
     packet::Gamestate *getGamestate();
@@ -67,5 +67,5 @@
   private:
     bool processGamestate(packet::Gamestate *gs);
-    void removeObject(orxonox::Iterator<Synchronisable> &it);
+    void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
     void printGamestateMap();
     bool saveShipCache();
@@ -78,5 +78,5 @@
     orxonox::SpaceShip *myShip_;
     unsigned char *shipCache_;
-    
+
   };
 
Index: code/trunk/src/network/Server.cc
===================================================================
--- code/trunk/src/network/Server.cc	(revision 1740)
+++ code/trunk/src/network/Server.cc	(revision 1747)
@@ -50,4 +50,5 @@
 #include "objects/SpaceShip.h"
 #include "core/ConsoleCommand.h"
+#include "core/Iterator.h"
 #include "packet/Chat.h"
 #include "packet/Packet.h"
@@ -58,5 +59,5 @@
   #define MAX_FAILURES 20;
   #define NETWORK_FREQUENCY 30
-  
+
   /**
   * Constructor for default values (bindaddress is set to ENET_HOST_ANY
@@ -68,5 +69,5 @@
     gamestates_ = new GamestateManager();
   }
-  
+
   Server::Server(int port){
     timeSinceLastUpdate_=0;
@@ -123,5 +124,5 @@
     return message->process();
   }
-  
+
   /**
   * This function sends out a message to all clients
@@ -175,5 +176,5 @@
     return;
   }
-  
+
   bool Server::queuePacket(ENetPacket *packet, int clientID){
     return connection->addPacket(packet, clientID);
@@ -230,5 +231,5 @@
     return p->process();
   }
-  
+
   /**
   * sends the gamestate
@@ -261,5 +262,5 @@
       assert(gs->compressData());
       if ( !gs->send() ){
-        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();
       }else
@@ -276,5 +277,5 @@
     return true;
   }
-  
+
 //   void Server::processChat( chat *data, int clientId){
 //     char *message = new char [strlen(data->message)+10+1];
@@ -286,5 +287,5 @@
 //     delete data;
 //   }
-  
+
   bool Server::addClient(ENetEvent *event){
     ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
@@ -303,5 +304,5 @@
     return createClient(temp->getID());
   }
-  
+
   bool Server::createClient(int clientID){
     ClientInformation *temp = ClientInformation::findClient(clientID);
@@ -325,5 +326,5 @@
     return true;
   }
-  
+
   bool Server::createShip(ClientInformation *client){
     if(!client)
@@ -351,14 +352,14 @@
     no->create();
     no->setBacksync(true);
-    
+
     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::ObjectList<orxonox::SpaceShip>::iterator it = orxonox::ObjectList<orxonox::SpaceShip>::begin();
     ClientInformation *client = ClientInformation::findClient(&event->peer->address);
     if(!client)
@@ -369,5 +370,5 @@
         continue;
       }
-      orxonox::Iterator<orxonox::SpaceShip> temp=it;
+      orxonox::ObjectList<orxonox::SpaceShip>::iterator temp=it;
       ++it;
       delete  *temp;
@@ -386,4 +387,4 @@
     gamestates_->removeClient(client);
   }
-  
+
 }
Index: code/trunk/src/network/Synchronisable.h
===================================================================
--- code/trunk/src/network/Synchronisable.h	(revision 1740)
+++ code/trunk/src/network/Synchronisable.h	(revision 1747)
@@ -92,5 +92,5 @@
     Synchronisable();
   private:
-    /*  bool removeObject(Iterator<Synchronisable> it);*/
+    /*  bool removeObject(ObjectList<Synchronisable>::iterator it);*/
 
     std::list<synchronisableVariable *> *syncList;
Index: code/trunk/src/network/packet/Gamestate.cc
===================================================================
--- code/trunk/src/network/packet/Gamestate.cc	(revision 1740)
+++ code/trunk/src/network/packet/Gamestate.cc	(revision 1747)
@@ -30,4 +30,5 @@
 #include "network/ClientInformation.h"
 #include "network/GamestateHandler.h"
+#include "core/Iterator.h"
 
 #include <zlib.h>
@@ -79,6 +80,6 @@
   unsigned char *mem=data_;
   mem+=sizeof(GamestateHeader);
-  orxonox::Iterator<Synchronisable> it;
-  for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it){
+  orxonox::ObjectList<Synchronisable>::iterator it;
+  for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
     tempsize=it->getSize2(mode);
 
@@ -86,5 +87,5 @@
       // start allocate additional memory
       COUT(3) << "G.St.Man: need additional memory" << std::endl;
-      orxonox::Iterator<Synchronisable> temp = it;
+      orxonox::ObjectList<Synchronisable>::iterator temp = it;
       int addsize=tempsize;
       while(++temp)
@@ -124,5 +125,5 @@
   unsigned char *mem=data_+sizeof(GamestateHeader);
     // get the start of the Synchronisable list
-  orxonox::Iterator<Synchronisable> it=orxonox::ObjectList<Synchronisable>::start();
+  orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
 
   while(mem < data_+sizeof(GamestateHeader)+HEADER->normsize){
@@ -318,7 +319,7 @@
   int size=0;
     // get the start of the Synchronisable list
-  orxonox::Iterator<Synchronisable> it;
+  orxonox::ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
-  for(it = orxonox::ObjectList<Synchronisable>::start(); it; ++it)
+  for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it)
     size+=it->getSize2(mode); // size of the actual data of the synchronisable
 //  size+=sizeof(GamestateHeader);
@@ -331,6 +332,6 @@
  * @return iterator pointing to the next object in the list
  */
-  void Gamestate::removeObject(orxonox::Iterator<Synchronisable> &it) {
-    orxonox::Iterator<Synchronisable> temp=it;
+  void Gamestate::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
+    orxonox::ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;
Index: code/trunk/src/network/packet/Gamestate.h
===================================================================
--- code/trunk/src/network/packet/Gamestate.h	(revision 1740)
+++ code/trunk/src/network/packet/Gamestate.h	(revision 1747)
@@ -38,5 +38,5 @@
 
 namespace packet {
-  
+
 struct GamestateHeader{
   ENUM::Type packetType;
@@ -51,5 +51,5 @@
 
 /**
-	@author 
+	@author
 */
 class Gamestate: public Packet{
@@ -57,7 +57,7 @@
     Gamestate();
     Gamestate(unsigned char *data, int clientID);
-    
+
     ~Gamestate();
-    
+
     bool collectData(int id, int mode=0x0);
     bool spreadData(int mode=0x0);
@@ -69,15 +69,15 @@
     bool compressData();
     bool decompressData();
-    
+
     // Packet functions
     virtual unsigned int getSize() const;
     virtual bool process();
 
-    
+
   private:
     unsigned int calcGamestateSize(int mode=0x0);
-    void removeObject(orxonox::Iterator<Synchronisable> &it);
+    void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
 
-    
+
     //Bytestream *bs_;
     //GamestateHeader *header_;
Index: code/trunk/src/orxonox/CMakeLists.txt
===================================================================
--- code/trunk/src/orxonox/CMakeLists.txt	(revision 1740)
+++ code/trunk/src/orxonox/CMakeLists.txt	(revision 1747)
@@ -7,4 +7,5 @@
   RadarViewable.cc
   Settings.cc
+  SignalHandler.cc
 
   overlays/OrxonoxOverlay.cc
Index: code/trunk/src/orxonox/GraphicsEngine.cc
===================================================================
--- code/trunk/src/orxonox/GraphicsEngine.cc	(revision 1740)
+++ code/trunk/src/orxonox/GraphicsEngine.cc	(revision 1747)
@@ -47,7 +47,8 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Debug.h"
+#include "core/Iterator.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
+#include "util/Debug.h"
 
 #include "overlays/console/InGameConsole.h"
@@ -97,10 +98,11 @@
     SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
 
-    unsigned int old = this->detailLevelParticle_;
-    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high");
-
-    if (this->detailLevelParticle_ != old)
-      for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
-        it->detailLevelChanged(this->detailLevelParticle_);
+    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
+  }
+
+  void GraphicsEngine::detailLevelParticleChanged()
+  {
+    for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
+      it->detailLevelChanged(this->detailLevelParticle_);
   }
 
@@ -441,5 +443,5 @@
   void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
   {
-    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
       it->windowMoved();
   }
@@ -453,5 +455,5 @@
   void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
   {
-    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
       it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
   }
@@ -463,5 +465,5 @@
   void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
   {
-    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
       it->windowFocusChanged();
   }
Index: code/trunk/src/orxonox/GraphicsEngine.h
===================================================================
--- code/trunk/src/orxonox/GraphicsEngine.h	(revision 1740)
+++ code/trunk/src/orxonox/GraphicsEngine.h	(revision 1747)
@@ -56,4 +56,5 @@
         public:
             void setConfigValues();
+            void detailLevelParticleChanged();
             bool setup();
             bool declareRessourceLocations();
Index: code/trunk/src/orxonox/Main.cc
===================================================================
--- code/trunk/src/orxonox/Main.cc	(revision 1740)
+++ code/trunk/src/orxonox/Main.cc	(revision 1747)
@@ -37,5 +37,5 @@
 
 #include "util/OrxonoxPlatform.h"
-#include "core/SignalHandler.h"
+#include "SignalHandler.h"
 #include "Orxonox.h"
 
Index: code/trunk/src/orxonox/Orxonox.cc
===================================================================
--- code/trunk/src/orxonox/Orxonox.cc	(revision 1740)
+++ code/trunk/src/orxonox/Orxonox.cc	(revision 1747)
@@ -54,10 +54,11 @@
 // core
 #include "core/ConfigFileManager.h"
+#include "core/Iterator.h"
 #include "core/ConsoleCommand.h"
-#include "core/Debug.h"
 #include "core/Loader.h"
 #include "core/input/InputManager.h"
 #include "core/TclBind.h"
 #include "core/Core.h"
+#include "util/Debug.h"
 
 // audio
@@ -85,7 +86,7 @@
 namespace orxonox
 {
-  SetConsoleCommandShortcut(Orxonox, exit).setKeybindMode(KeybindMode::OnPress);
-  SetConsoleCommandShortcut(Orxonox, slomo).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
-  SetConsoleCommandShortcut(Orxonox, setTimeFactor).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  SetConsoleCommandShortcut(Orxonox, exit).keybindMode(KeybindMode::OnPress);
+  SetConsoleCommandShortcut(Orxonox, slomo).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
+  SetConsoleCommandShortcut(Orxonox, setTimeFactor).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);
 
   /**
@@ -181,5 +182,5 @@
     float change = factor / Orxonox::getSingleton()->getTimeFactor();
     Orxonox::getSingleton()->timefactor_ = factor;
-    for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+    for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
         it->setSpeedFactor(it->getSpeedFactor() * change);
 
@@ -197,7 +198,7 @@
   {
 #ifdef _DEBUG
-    ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox_d.ini");
+    ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox_d.ini");
 #else
-    ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox.ini");
+    ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox.ini");
 #endif
     Factory::createClassHierarchy();
@@ -442,5 +443,5 @@
 
     unsigned long frameCount = 0;
-    
+
     // TODO: this would very well fit into a configValue
     const unsigned long refreshTime = 200000;
@@ -468,8 +469,8 @@
 
       // Call those objects that need the real time
-      for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+      for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
         it->tick(dt);
       // Call the scene objects
-      for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+      for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
         it->tick(dt * this->timefactor_);
 
Index: code/trunk/src/orxonox/OrxonoxStableHeaders.h
===================================================================
--- code/trunk/src/orxonox/OrxonoxStableHeaders.h	(revision 1740)
+++ code/trunk/src/orxonox/OrxonoxStableHeaders.h	(revision 1747)
@@ -92,7 +92,9 @@
 
 #include "util/Convert.h"
+#include "util/Debug.h"
 #include "util/Math.h"
 #include "util/Multitype.h"
-#include "util/MultiTypeMath.h"
+#include "util/OutputBuffer.h"
+#include "util/OutputHandler.h"
 #include "util/Sleep.h"
 #include "util/String.h"
@@ -104,7 +106,4 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Debug.h"
-#include "core/OutputBuffer.h"
-#include "core/OutputHandler.h"
 #include "core/Executor.h"
 #include "core/XMLPort.h"
Index: code/trunk/src/orxonox/Radar.cc
===================================================================
--- code/trunk/src/orxonox/Radar.cc	(revision 1740)
+++ code/trunk/src/orxonox/Radar.cc	(revision 1747)
@@ -39,10 +39,11 @@
 #include "core/CoreIncludes.h"
 #include "core/ConsoleCommand.h"
+#include "core/Iterator.h"
 #include "RadarListener.h"
 
 namespace orxonox
 {
-    SetConsoleCommand(Radar, cycleNavigationFocus, true).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(Radar, releaseNavigationFocus, true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(Radar, cycleNavigationFocus, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(Radar, releaseNavigationFocus, true).accessLevel(AccessLevel::User);
 
     Radar* Radar::instance_s = 0;
@@ -106,9 +107,9 @@
         }
 
-        for (Iterator<RadarListener> itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
+        for (ObjectList<RadarListener>::iterator itListener = ObjectList<RadarListener>::begin(); itListener; ++itListener)
         {
             (*itListener)->radarTick(dt);
 
-            for (Iterator<RadarViewable> itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            for (ObjectList<RadarViewable>::iterator itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
             {
                 if ((*itElement) != SpaceShip::getLocalShip() && (*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectCamouflage())
@@ -120,5 +121,5 @@
     void Radar::cycleFocus()
     {
-        if (*(ObjectList<RadarViewable>::begin()) == 0)
+        if (ObjectList<RadarViewable>::begin() == 0)
         {
             // list is empty
@@ -137,7 +138,7 @@
             float nextDistance = FLT_MAX;
             float minimumDistance = FLT_MAX;
-            Iterator<RadarViewable> itFallback = 0;
-
-            for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::begin(); it; ++it)
+            ObjectList<RadarViewable>::iterator itFallback = 0;
+
+            for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it)
             {
                 if (*it == SpaceShip::getLocalShip())
@@ -181,5 +182,5 @@
         // iterate through all Radar Objects
         unsigned int i = 0;
-        for (Iterator<RadarViewable> it = ObjectList<RadarViewable>::start(); it; ++it, ++i)
+        for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it, ++i)
         {
             COUT(3) << i++ << ": " << (*it)->getWorldPosition() << std::endl;
Index: code/trunk/src/orxonox/Radar.h
===================================================================
--- code/trunk/src/orxonox/Radar.h	(revision 1740)
+++ code/trunk/src/orxonox/Radar.h	(revision 1747)
@@ -55,5 +55,5 @@
         RadarBase() { }
     };
- 
+
     class _OrxonoxExport Radar : public Tickable, private virtual RadarBase
     {
@@ -61,4 +61,6 @@
         Radar();
         ~Radar();
+
+        virtual void tick(float dt);
 
         const RadarViewable* getFocus();
@@ -75,5 +77,4 @@
     private:
         Radar(Radar& instance);
-        void tick(float dt);
 
         void releaseFocus();
@@ -81,8 +82,8 @@
         void cycleFocus();
 
-        Iterator<RadarViewable> itFocus_;
+        ObjectListIterator<RadarViewable> itFocus_;
         RadarViewable* focus_;
         std::map<std::string, RadarViewable::Shape> objectTypes_;
-        int objectTypeCounter_; 
+        int objectTypeCounter_;
 
         static Radar* instance_s;
Index: code/trunk/src/orxonox/RadarViewable.cc
===================================================================
--- code/trunk/src/orxonox/RadarViewable.cc	(revision 1740)
+++ code/trunk/src/orxonox/RadarViewable.cc	(revision 1747)
@@ -29,5 +29,5 @@
 #include "OrxonoxStableHeaders.h"
 #include "RadarViewable.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
 #include "objects/WorldEntity.h"
Index: code/trunk/src/orxonox/RadarViewable.h
===================================================================
--- code/trunk/src/orxonox/RadarViewable.h	(revision 1740)
+++ code/trunk/src/orxonox/RadarViewable.h	(revision 1747)
@@ -33,5 +33,5 @@
 #include <string>
 #include "util/Math.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/OrxonoxClass.h"
 
Index: code/trunk/src/orxonox/Settings.cc
===================================================================
--- code/trunk/src/orxonox/Settings.cc	(revision 1740)
+++ code/trunk/src/orxonox/Settings.cc	(revision 1747)
@@ -68,5 +68,12 @@
   void Settings::setConfigValues()
   {
-    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.");
+    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
+  }
+
+  /**
+    @brief Callback function if the datapath has changed.
+  */
+  void Settings::dataPathChanged()
+  {
     if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
     {
Index: code/trunk/src/orxonox/Settings.h
===================================================================
--- code/trunk/src/orxonox/Settings.h	(revision 1740)
+++ code/trunk/src/orxonox/Settings.h	(revision 1747)
@@ -48,4 +48,5 @@
     public:
       void setConfigValues();
+      void dataPathChanged();
 
       static const std::string& getDataPath();
Index: code/trunk/src/orxonox/SignalHandler.cc
===================================================================
--- code/trunk/src/orxonox/SignalHandler.cc	(revision 1747)
+++ code/trunk/src/orxonox/SignalHandler.cc	(revision 1747)
@@ -0,0 +1,353 @@
+/*
+ *   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:
+ *      Christoph Renner
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file SignalHandler.cc
+    @brief Implementation of the SignalHandler class.
+*/
+
+#include "OrxonoxStableHeaders.h"
+#include "SignalHandler.h"
+#include "util/Debug.h"
+
+#include <assert.h>
+#include <iostream>
+
+SignalHandler * SignalHandler::singletonRef = NULL;
+
+#if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
+
+#include <wait.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/keysym.h>
+
+bool SignalHandler::bXAutoKeyRepeatOn_ = false;
+
+SignalHandler::SignalHandler()
+{
+}
+
+/**
+ * register signal handlers for SIGSEGV and SIGABRT
+ * @param appName path to executable eg argv[0]
+ * @param fileName filename to append backtrace to
+ */
+void SignalHandler::doCatch( const std::string & appName, const std::string & fileName )
+{
+  this->appName = appName;
+  this->fileName = fileName;
+
+  // prepare for restoring XAutoKeyRepeat
+  Display* display;
+  if ((display = XOpenDisplay(0)))
+  {
+    XKeyboardState oldState;
+    XGetKeyboardControl(display, &oldState);
+    if (oldState.global_auto_repeat == AutoRepeatModeOn)
+      bXAutoKeyRepeatOn_ = true;
+    else
+      bXAutoKeyRepeatOn_ = false;
+    XCloseDisplay(display);
+  }
+  else
+  {
+    std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
+    bXAutoKeyRepeatOn_ = false;
+  }
+
+
+  // make sure doCatch is only called once without calling dontCatch
+  assert( sigRecList.size() == 0 );
+
+  catchSignal( SIGSEGV );
+  catchSignal( SIGABRT );
+  catchSignal( SIGILL );
+}
+
+/**
+ * restore previous signal handlers
+ */
+void SignalHandler::dontCatch()
+{
+  for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
+  {
+    signal( it->signal, it->handler );
+  }
+
+  sigRecList.clear();
+}
+
+/**
+ * catch signal sig
+ * @param sig signal to catch
+ */
+void SignalHandler::catchSignal( int sig )
+{
+  sig_t handler = signal( sig, SignalHandler::sigHandler );
+
+  assert( handler != SIG_ERR );
+
+  SignalRec rec;
+  rec.signal = sig;
+  rec.handler = handler;
+
+  sigRecList.push_front( rec );
+}
+
+/**
+ * sigHandler is called when receiving signals
+ * @param sig
+ */
+void SignalHandler::sigHandler( int sig )
+{
+  for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
+  {
+    (*(it->cb))( it->someData );
+  }
+
+  std::string sigName = "UNKNOWN";
+
+  switch ( sig )
+  {
+    case SIGSEGV:
+      sigName = "SIGSEGV";
+      break;
+    case SIGABRT:
+      sigName = "SIGABRT";
+      break;
+    case SIGILL:
+      sigName = "SIGILL";
+      break;
+  }
+
+  if (bXAutoKeyRepeatOn_)
+  {
+    std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
+    Display* display;
+    if ((display = XOpenDisplay(0)))
+    {
+      XAutoRepeatOn(display);
+      XCloseDisplay(display);
+    }
+  }
+
+  COUT(0) << "recieved signal " << sigName.c_str() << std::endl << "try to write backtrace to file orxonox.log" << std::endl;
+
+  int sigPipe[2];
+  if ( pipe(sigPipe) == -1 )
+  {
+    perror("pipe failed!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  int sigPid = fork();
+
+  if ( sigPid == -1 )
+  {
+    perror("fork failed!\n");
+    exit(EXIT_FAILURE);
+  }
+
+  // gdb will be attached to this process
+  if ( sigPid == 0 )
+  {
+    getInstance()->dontCatch();
+    // wait for message from parent when it has attached gdb
+    int someData;
+
+    read( sigPipe[0], &someData, sizeof(someData) );
+
+    if ( someData != 0x12345678 )
+    {
+      COUT(0) << "something went wrong :(" << std::endl;
+    }
+
+    return;
+  }
+
+  int gdbIn[2];
+  int gdbOut[2];
+  int gdbErr[2];
+
+  if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
+  {
+    perror("pipe failed!\n");
+    kill( sigPid, SIGTERM );
+    waitpid( sigPid, NULL, 0 );
+    exit(EXIT_FAILURE);
+  }
+
+  int gdbPid = fork();
+  // this process will run gdb
+
+  if ( gdbPid == -1 )
+  {
+    perror("fork failed\n");
+    kill( sigPid, SIGTERM );
+    waitpid( sigPid, NULL, 0 );
+    exit(EXIT_FAILURE);
+  }
+
+  if ( gdbPid == 0 )
+  {
+    // start gdb
+
+    close(gdbIn[1]);
+    close(gdbOut[0]);
+    close(gdbErr[0]);
+
+    dup2( gdbIn[0], STDIN_FILENO );
+    dup2( gdbOut[1], STDOUT_FILENO );
+    dup2( gdbErr[1], STDERR_FILENO );
+
+    execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
+  }
+
+  char cmd[256];
+  snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
+  write( gdbIn[1], cmd, strlen(cmd) );
+
+  int charsFound = 0;
+  int promptFound = 0;
+  char byte;
+  while ( read( gdbOut[0], &byte, 1 ) == 1 )
+  {
+    if (
+      charsFound == 0 && byte == '(' ||
+      charsFound == 1 && byte == 'g' ||
+      charsFound == 2 && byte == 'd' ||
+      charsFound == 3 && byte == 'b' ||
+      charsFound == 4 && byte == ')' ||
+      charsFound == 5 && byte == ' '
+        )
+          charsFound++;
+    else
+      charsFound = 0;
+
+    if ( charsFound == 6 )
+    {
+      promptFound++;
+      charsFound = 0;
+    }
+
+    if ( promptFound == 3 )
+    {
+      break;
+    }
+  }
+
+  int someData = 0x12345678;
+  write( sigPipe[1], &someData, sizeof(someData) );
+
+  write( gdbIn[1], "bt\nk\nq\n", 7 );
+
+
+  charsFound = 0;
+  promptFound = 0;
+  std::string bt;
+  while ( read( gdbOut[0], &byte, 1 ) == 1 )
+  {
+    bt += std::string( &byte, 1 );
+
+    if (
+      charsFound == 0 && byte == '(' ||
+      charsFound == 1 && byte == 'g' ||
+      charsFound == 2 && byte == 'd' ||
+      charsFound == 3 && byte == 'b' ||
+      charsFound == 4 && byte == ')' ||
+      charsFound == 5 && byte == ' '
+        )
+          charsFound++;
+    else
+      charsFound = 0;
+
+    if ( charsFound == 6 )
+    {
+      promptFound++;
+      charsFound = 0;
+      bt += "\n";
+    }
+
+    if ( promptFound == 3 )
+    {
+      break;
+    }
+  }
+
+
+  waitpid( sigPid, NULL, 0 );
+  waitpid( gdbPid, NULL, 0 );
+
+  int wsRemoved = 0;
+
+  while ( wsRemoved < 2 && bt.length() > 0 )
+  {
+    if ( bt[1] == '\n' )
+      wsRemoved++;
+    bt.erase(0, 1);
+  }
+
+  if ( bt.length() > 0 )
+    bt.erase(0, 1);
+
+  time_t now = time(NULL);
+
+  std::string timeString = "\n\n\n\n"
+                     "=======================================================\n"
+                     "= time: " + std::string(ctime(&now)) +
+         "=======================================================\n";
+  bt.insert(0, timeString);
+
+  FILE * f = fopen( getInstance()->fileName.c_str(), "a" );
+
+  if ( !f )
+  {
+    perror( ( std::string( "could not append to " ) + getInstance()->fileName ).c_str() );
+    exit(EXIT_FAILURE);
+  }
+
+  if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+  {
+    COUT(0) << "could not write " << bt.length() << " byte to " << getInstance()->fileName << std::endl;
+    exit(EXIT_FAILURE);
+  }
+
+  exit(EXIT_FAILURE);
+}
+
+void SignalHandler::registerCallback( SignalCallback cb, void * someData )
+{
+  SignalCallbackRec rec;
+  rec.cb = cb;
+  rec.someData = someData;
+
+  callbackList.push_back(rec);
+}
+
+#endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
Index: code/trunk/src/orxonox/SignalHandler.h
===================================================================
--- code/trunk/src/orxonox/SignalHandler.h	(revision 1747)
+++ code/trunk/src/orxonox/SignalHandler.h	(revision 1747)
@@ -0,0 +1,109 @@
+/*
+ *   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:
+ *      Christoph Renner
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file SignalHandler.h
+    @brief Definition of the SignalHandler class.
+*/
+
+#ifndef _SignalHandler_H__
+#define _SignalHandler_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include <list>
+#include <string>
+
+typedef int (*SignalCallback)( void * someData );
+
+#if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
+#include <signal.h>
+
+struct SignalRec
+{
+  int signal;
+  sig_t handler;
+};
+
+struct SignalCallbackRec
+{
+  SignalCallback cb;
+  void * someData;
+};
+
+
+typedef std::list<SignalRec> SignalRecList;
+typedef std::list<SignalCallbackRec> SignalCallbackList;
+
+class SignalHandler
+{
+  private:
+    SignalHandler();
+  public:
+    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
+    ~SignalHandler(){ SignalHandler::singletonRef = NULL; }
+
+    void registerCallback( SignalCallback cb, void * someData );
+
+    void doCatch( const std::string & appName, const std::string & fileName );
+    void dontCatch();
+
+  private:
+    static void sigHandler( int sig );
+
+    void catchSignal( int sig );
+    SignalRecList sigRecList;
+
+    SignalCallbackList callbackList;
+
+    static SignalHandler * singletonRef;
+
+    std::string appName;
+    std::string fileName;
+
+    // used to turn on KeyAutoRepeat if OIS crashes
+    static bool bXAutoKeyRepeatOn_;
+};
+
+#else /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
+
+class _OrxonoxExport SignalHandler
+{
+  public:
+    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
+    void doCatch( const std::string & appName, const std::string & fileName ) {};
+    void dontCatch() {};
+    void registerCallback( SignalCallback cb, void * someData ) {};
+
+  private:
+    static SignalHandler * singletonRef;
+};
+
+#endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
+
+#endif /* _SignalHandler_H__ */
Index: code/trunk/src/orxonox/objects/Ambient.cc
===================================================================
--- code/trunk/src/orxonox/objects/Ambient.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/Ambient.cc	(revision 1747)
@@ -39,13 +39,13 @@
 #include "util/Convert.h"
 #include "util/Math.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
-#include "GraphicsEngine.h"
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
+#include "GraphicsEngine.h"
 
 namespace orxonox
 {
-    SetConsoleCommand(Ambient, setAmbientLightTest, false).setDefaultValues(ColourValue(1, 1, 1, 1)).setAccessLevel(AccessLevel::Offline);
+    SetConsoleCommandAlias(Ambient, setAmbientLightTest, "setAmbientLight", false).defaultValues(ColourValue(1, 1, 1, 1)).accessLevel(AccessLevel::Offline);
 
     CreateFactory(Ambient);
@@ -64,18 +64,19 @@
     }
 
-    bool Ambient::create(){
-      GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
-      return Synchronisable::create();
+    bool Ambient::create()
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+        return Synchronisable::create();
     }
-    
-    void Ambient::registerAllVariables(){
-      registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
-      
+
+    void Ambient::registerAllVariables()
+    {
+        registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
     }
 
     void Ambient::setAmbientLight(const ColourValue& colour)
     {
-	    GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
-      ambientLight_=colour;	
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+        ambientLight_=colour;
     }
 
@@ -88,7 +89,7 @@
     void Ambient::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlelement, mode);
+        SUPER(Ambient, XMLPort, xmlelement, mode);
 
-        XMLPortParamLoadOnly(Ambient, "colourvalue", setAmbientLight, xmlelement, mode);
+        XMLPortParam(Ambient, "colourvalue", setAmbientLight, getAmbienetLight, xmlelement, mode);
         create();
     }
Index: code/trunk/src/orxonox/objects/Ambient.h
===================================================================
--- code/trunk/src/orxonox/objects/Ambient.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/Ambient.h	(revision 1747)
@@ -45,7 +45,10 @@
 
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void setAmbientLight(const ColourValue& colour);
             virtual bool create();
             void registerAllVariables();
+
+            void setAmbientLight(const ColourValue& colour);
+            inline const ColourValue& getAmbienetLight() const
+                { return this->ambientLight_; }
 
             static void setAmbientLightTest(const ColourValue& colour)
Index: code/trunk/src/orxonox/objects/Backlight.cc
===================================================================
--- code/trunk/src/orxonox/objects/Backlight.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/Backlight.cc	(revision 1747)
@@ -103,5 +103,5 @@
     void Backlight::tick(float dt)
     {
-        WorldEntity::tick(dt);
+        SUPER(Backlight, tick, dt);
 
         if (this->isActive())
@@ -147,5 +147,5 @@
     void Backlight::changedVisibility()
     {
-        WorldEntity::changedVisibility();
+        SUPER(Backlight, changedVisibility);
 
         this->billboard_.setVisible(this->isVisible());
Index: code/trunk/src/orxonox/objects/BillboardProjectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/BillboardProjectile.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/BillboardProjectile.cc	(revision 1747)
@@ -63,5 +63,5 @@
     void BillboardProjectile::changedVisibility()
     {
-        Projectile::changedVisibility();
+        SUPER(BillboardProjectile, changedVisibility);
         this->billboard_.setVisible(this->isVisible());
     }
Index: code/trunk/src/orxonox/objects/Camera.cc
===================================================================
--- code/trunk/src/orxonox/objects/Camera.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/Camera.cc	(revision 1747)
@@ -42,5 +42,5 @@
 #include "util/Convert.h"
 #include "util/Math.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
 #include "GraphicsEngine.h"
Index: code/trunk/src/orxonox/objects/Model.cc
===================================================================
--- code/trunk/src/orxonox/objects/Model.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/Model.cc	(revision 1747)
@@ -65,14 +65,9 @@
     void Model::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        WorldEntity::XMLPort(xmlelement, mode);
+        SUPER(Model, XMLPort, xmlelement, mode);
 
-        XMLPortParamLoadOnly(Model, "mesh", setMesh, xmlelement, mode);
+        XMLPortParam(Model, "mesh", setMesh, getMesh, xmlelement, mode);
 
         Model::create();
-    }
-
-    void Model::setMesh(const std::string& meshname)
-    {
-        this->meshSrc_ = meshname;
     }
 
@@ -98,5 +93,5 @@
     void Model::changedVisibility()
     {
-        WorldEntity::changedVisibility();
+        SUPER(Model, changedVisibility);
         if (this->isInitialized())
             this->mesh_.setVisible(this->isVisible());
Index: code/trunk/src/orxonox/objects/Model.h
===================================================================
--- code/trunk/src/orxonox/objects/Model.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/Model.h	(revision 1747)
@@ -45,5 +45,8 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void changedVisibility();
-            void setMesh(const std::string& meshname);
+            inline void setMesh(const std::string& meshname)
+                { this->meshSrc_ = meshname; }
+            inline const std::string& getMesh() const
+                { return this->meshSrc_; }
             virtual bool create();
 
Index: code/trunk/src/orxonox/objects/NPC.cc
===================================================================
--- code/trunk/src/orxonox/objects/NPC.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/NPC.cc	(revision 1747)
@@ -31,4 +31,5 @@
 
 #include "core/CoreIncludes.h"
+#include "core/Iterator.h"
 
 namespace orxonox {
@@ -56,10 +57,10 @@
     movable_ = movable;
   }
-  
+
   void NPC::registerAllVariables(){
     Model::registerAllVariables();
     registerVar(&movable_, sizeof(movable_), network::DATA);
   }
-  
+
 
   /**
@@ -112,5 +113,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(ObjectList<WorldEntity>::iterator 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
@@ -139,5 +140,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(ObjectList<NPC>::iterator 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
@@ -159,5 +160,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(ObjectList<NPC>::iterator 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/trunk/src/orxonox/objects/NPC.h
===================================================================
--- code/trunk/src/orxonox/objects/NPC.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/NPC.h	(revision 1747)
@@ -48,5 +48,5 @@
       NPC();
       virtual ~NPC();
-      void tick(float dt);
+      virtual void tick(float dt);
       void update();
       void setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable);
Index: code/trunk/src/orxonox/objects/ParticleProjectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/ParticleProjectile.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/ParticleProjectile.cc	(revision 1747)
@@ -32,4 +32,5 @@
 #include "SpaceShip.h"
 #include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
 
 namespace orxonox
@@ -52,4 +53,6 @@
             this->particles_ = 0;
         }
+
+        this->setConfigValues();
     }
 
@@ -60,7 +63,12 @@
     }
 
+    void ParticleProjectile::setConfigValues()
+    {
+        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback((Projectile*)this, &ParticleProjectile::speedChanged);
+    }
+
     void ParticleProjectile::changedVisibility()
     {
-        BillboardProjectile::changedVisibility();
+        SUPER(ParticleProjectile, changedVisibility);
         this->particles_->setEnabled(this->isVisible());
     }
Index: code/trunk/src/orxonox/objects/ParticleProjectile.h
===================================================================
--- code/trunk/src/orxonox/objects/ParticleProjectile.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/ParticleProjectile.h	(revision 1747)
@@ -44,4 +44,5 @@
             virtual ~ParticleProjectile();
             virtual void changedVisibility();
+            void setConfigValues();
 
         private:
Index: code/trunk/src/orxonox/objects/Projectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/Projectile.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/Projectile.cc	(revision 1747)
@@ -35,4 +35,5 @@
 #include "core/Executor.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Iterator.h"
 #include "tools/ParticleInterface.h"
 
@@ -43,5 +44,5 @@
 namespace orxonox
 {
-    float Projectile::speed_ = 5000;
+    float Projectile::speed_s = 5000;
 
     Projectile::Projectile(SpaceShip* owner) : owner_(owner)
@@ -73,13 +74,17 @@
         SetConfigValue(damage_, 15.0).description("The damage caused by the projectile");
         SetConfigValue(lifetime_, 4.0).description("The time in seconds a projectile stays alive");
-        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second");
+        SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second").callback(this, &Projectile::speedChanged);
+    }
 
-	if(this->owner_)
-          this->setVelocity(this->owner_->getInitialDir() * this->speed_);
+    void Projectile::speedChanged()
+    {
+        Projectile::speed_s = this->speed_;
+        if (this->owner_)
+            this->setVelocity(this->owner_->getInitialDir() * this->speed_);
     }
 
     void Projectile::tick(float dt)
     {
-        WorldEntity::tick(dt);
+        SUPER(Projectile, tick, dt);
 
         if (!this->isActive())
@@ -87,9 +92,9 @@
 
         float radius;
-        for (Iterator<Model> it = ObjectList<Model>::start(); it; ++it)
+        for (ObjectList<Model>::iterator it = ObjectList<Model>::begin(); it; ++it)
         {
             if ((*it) != this->owner_)
             {
-                radius = it->getScale().x * 3.0;
+                radius = it->getScale3D().x * 3.0;
 
                 if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))
Index: code/trunk/src/orxonox/objects/Projectile.h
===================================================================
--- code/trunk/src/orxonox/objects/Projectile.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/Projectile.h	(revision 1747)
@@ -42,9 +42,10 @@
             virtual ~Projectile();
             void setConfigValues();
+            void speedChanged();
             void destroyObject();
             virtual void tick(float dt);
 
             static float getSpeed()
-                { return Projectile::speed_; }
+                { return Projectile::speed_s; }
 
         protected:
@@ -55,5 +56,8 @@
             std::string explosionTemplateName_;
             std::string smokeTemplateName_;
-            static float speed_;
+        protected:
+            static float speed_s;
+            float speed_;
+        private:
             float lifetime_;
             float damage_;
Index: code/trunk/src/orxonox/objects/RotatingProjectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/RotatingProjectile.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/RotatingProjectile.cc	(revision 1747)
@@ -65,8 +65,14 @@
     void RotatingProjectile::setConfigValues()
     {
-        SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0));
+        SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0)).callback(this, &RotatingProjectile::colourChanged);
+    }
 
-        this->rotatingBillboard1_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
-        this->rotatingBillboard2_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+    void RotatingProjectile::colourChanged()
+    {
+        if (this->isInitialized())
+        {
+            this->rotatingBillboard1_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+            this->rotatingBillboard2_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+        }
     }
 
@@ -81,10 +87,10 @@
         }
 
-        Projectile::tick(dt);
+        SUPER(RotatingProjectile, tick, dt);
     }
 
     void RotatingProjectile::changedVisibility()
     {
-        BillboardProjectile::changedVisibility();
+        SUPER(RotatingProjectile, changedVisibility);
         this->rotatingBillboard1_.setVisible(this->isVisible());
         this->rotatingBillboard2_.setVisible(this->isVisible());
Index: code/trunk/src/orxonox/objects/RotatingProjectile.h
===================================================================
--- code/trunk/src/orxonox/objects/RotatingProjectile.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/RotatingProjectile.h	(revision 1747)
@@ -14,4 +14,5 @@
             virtual ~RotatingProjectile();
             void setConfigValues();
+            void colourChanged();
             virtual void tick(float dt);
             virtual void changedVisibility();
Index: code/trunk/src/orxonox/objects/Skybox.cc
===================================================================
--- code/trunk/src/orxonox/objects/Skybox.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/Skybox.cc	(revision 1747)
@@ -37,6 +37,6 @@
 #include "GraphicsEngine.h"
 #include "core/CoreIncludes.h"
-#include "core/Debug.h"
 #include "core/XMLPort.h"
+#include "util/Debug.h"
 
 namespace orxonox
@@ -59,9 +59,4 @@
     }
 
-    void Skybox::setSkyboxSrc(const std::string& src)
-    {
-        this->skyboxSrc_ = src;
-    }
-
     /**
         @brief XML loading and saving.
@@ -72,7 +67,7 @@
     void Skybox::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlelement, mode);
+        SUPER(Skybox, XMLPort, xmlelement, mode);
 
-        XMLPortParamLoadOnly(Skybox, "src", setSkyboxSrc, xmlelement, mode);
+        XMLPortParam(Skybox, "src", setSkyboxSrc, getSkyboxSrc, xmlelement, mode);
         create();
     }
@@ -91,5 +86,5 @@
     void Skybox::changedVisibility()
     {
-        BaseObject::changedVisibility();
+        SUPER(Skybox, changedVisibility);
         GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
     }
Index: code/trunk/src/orxonox/objects/Skybox.h
===================================================================
--- code/trunk/src/orxonox/objects/Skybox.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/Skybox.h	(revision 1747)
@@ -49,5 +49,9 @@
             virtual bool create();
             void registerAllVariables();
-            void setSkyboxSrc(const std::string &src);
+
+            inline void setSkyboxSrc(const std::string &src)
+                { this->skyboxSrc_ = src; }
+            inline const std::string& getSkyboxSrc() const
+                { return this->skyboxSrc_; }
 
         private:
Index: code/trunk/src/orxonox/objects/SpaceShip.cc
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShip.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/SpaceShip.cc	(revision 1747)
@@ -37,34 +37,33 @@
 #include "util/Convert.h"
 #include "util/Math.h"
-
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Debug.h"
+#include "core/Iterator.h"
+#include "core/input/InputManager.h"
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
-#include "network/Host.h"
-
 #include "tools/ParticleInterface.h"
-
-#include "GraphicsEngine.h"
+#include "network/Client.h"
+#include "Backlight.h"
+#include "CameraHandler.h"
+#include "ParticleSpawner.h"
 #include "RotatingProjectile.h"
 #include "ParticleProjectile.h"
-#include "ParticleSpawner.h"
-#include "Backlight.h"
-#include "CameraHandler.h"
+#include "GraphicsEngine.h"
 
 namespace orxonox
 {
-    SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).setAccessLevel(AccessLevel::Debug);
-    SetConsoleCommand(SpaceShip, whereAmI, true).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(SpaceShip, moveLongitudinal, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
-    SetConsoleCommand(SpaceShip, moveLateral, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
-    SetConsoleCommand(SpaceShip, moveYaw, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
-    SetConsoleCommand(SpaceShip, movePitch, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
-    SetConsoleCommand(SpaceShip, moveRoll, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
-    SetConsoleCommand(SpaceShip, fire, true).setAccessLevel(AccessLevel::User).setKeybindMode(KeybindMode::OnHold);
-    SetConsoleCommandGeneric(test1, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed"), false).setAccessLevel(AccessLevel::Debug);
-    SetConsoleCommandGeneric(test2, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber"), false).setAccessLevel(AccessLevel::Debug);
-    SetConsoleCommandGeneric(test3, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).accessLevel(AccessLevel::Debug);
+    SetConsoleCommand(SpaceShip, whereAmI, true).accessLevel(AccessLevel::User);
+    SetConsoleCommand(SpaceShip, moveLongitudinal, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveLateral, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveYaw, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, movePitch, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveRoll, true).accessLevel(AccessLevel::User).defaultValue(0, 1.0f).axisParamIndex(0).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, fire, true).accessLevel(AccessLevel::User).keybindMode(KeybindMode::OnHold);
+    SetConsoleCommandAliasMulti(SpaceShip, setMaxSpeedTest, "setMaxSpeed", 1, false).accessLevel(AccessLevel::Debug);
+    SetConsoleCommandAliasMulti(SpaceShip, setMaxSpeedTest, "setMaxBlubber", 2, false).accessLevel(AccessLevel::Debug);
+    SetConsoleCommandAliasMulti(SpaceShip, setMaxSpeedTest, "setRofl", 3, false).accessLevel(AccessLevel::Debug);
 
     CreateFactory(SpaceShip);
@@ -74,6 +73,6 @@
 
     SpaceShip *SpaceShip::getLocalShip(){
-      Iterator<SpaceShip> it;
-      for(it = ObjectList<SpaceShip>::start(); it; ++it){
+      ObjectList<SpaceShip>::iterator it;
+      for(it = ObjectList<SpaceShip>::begin(); it; ++it){
         if( (it)->myShip_ )
           return *it;
@@ -289,5 +288,5 @@
     void SpaceShip::changedVisibility()
     {
-        Model::changedVisibility();
+        SUPER(SpaceShip, changedVisibility);
 
         this->tt1_->setEnabled(this->isVisible());
@@ -306,5 +305,5 @@
     void SpaceShip::changedActivity()
     {
-        Model::changedActivity();
+        SUPER(SpaceShip, changedActivity);
 
         this->tt1_->setEnabled(this->isVisible());
@@ -392,14 +391,14 @@
     void SpaceShip::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        Model::XMLPort(xmlelement, mode);
-
-        XMLPortParamLoadOnly(SpaceShip, "camera", setCamera, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "maxSpeed", setMaxSpeed, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "maxRotation", setMaxRotation, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "transAcc", setTransAcc, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "rotAcc", setRotAcc, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, mode);
+        SUPER(SpaceShip, XMLPort, xmlelement, mode);
+
+        XMLPortParam(SpaceShip, "camera", setCamera, getCamera, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxSpeed", setMaxSpeed, getMaxSpeed, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, getMaxSideAndBackSpeed, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxRotation", setMaxRotation, getMaxRotation, xmlelement, mode);
+        XMLPortParam(SpaceShip, "transAcc", setTransAcc, getTransAcc, xmlelement, mode);
+        XMLPortParam(SpaceShip, "rotAcc", setRotAcc, getRotAcc, xmlelement, mode);
+        XMLPortParam(SpaceShip, "transDamp", setTransDamp, getTransDamp, xmlelement, mode);
+        XMLPortParam(SpaceShip, "rotDamp", setRotDamp, getRotDamp, xmlelement, mode);
 
         myShip_=true; //TODO: this is a hack
@@ -535,5 +534,5 @@
 
 
-        WorldEntity::tick(dt);
+        SUPER(SpaceShip, tick, dt);
 
         this->roll(this->mouseXRotation_ * dt);
Index: code/trunk/src/orxonox/objects/SpaceShipAI.cc
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShipAI.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/SpaceShipAI.cc	(revision 1747)
@@ -44,6 +44,6 @@
 namespace orxonox
 {
-    SetConsoleCommand(SpaceShipAI, createEnemy, true).setDefaultValue(0, 1);
-    SetConsoleCommand(SpaceShipAI, killEnemies, true).setDefaultValue(0, 0);
+    SetConsoleCommand(SpaceShipAI, createEnemy, true).defaultValue(0, 1);
+    SetConsoleCommand(SpaceShipAI, killEnemies, true).defaultValue(0, 0);
 
     CreateFactory(SpaceShipAI);
@@ -72,5 +72,5 @@
     SpaceShipAI::~SpaceShipAI()
     {
-        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; ++it)
+        for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; ++it)
             it->shipDied(this);
     }
@@ -78,5 +78,5 @@
     void SpaceShipAI::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        SpaceShip::XMLPort(xmlelement, mode);
+        SUPER(SpaceShipAI, XMLPort, xmlelement, mode);
 
         this->actionTimer_.setTimer(ACTION_INTERVAL, true, this, createExecutor(createFunctor(&SpaceShipAI::action)));
@@ -111,5 +111,5 @@
     {
         int i = 0;
-        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; )
+        for (ObjectList<SpaceShipAI>::iterator it = ObjectList<SpaceShipAI>::begin(); it; )
         {
             (it++)->kill();
@@ -229,5 +229,5 @@
             this->doFire();
 
-        SpaceShip::tick(dt);
+        SUPER(SpaceShipAI, tick, dt);
     }
 
@@ -263,5 +263,5 @@
         this->forgetTarget();
 
-        for (Iterator<SpaceShip> it = ObjectList<SpaceShip>::begin(); it; ++it)
+        for (ObjectList<SpaceShip>::iterator it = ObjectList<SpaceShip>::begin(); it; ++it)
         {
             if (it->getTeamNr() != this->getTeamNr())
Index: code/trunk/src/orxonox/objects/SpaceShipAI.h
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShipAI.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/SpaceShipAI.h	(revision 1747)
@@ -47,4 +47,5 @@
 
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void tick(float dt);
             static void createEnemy(int num);
             static void killEnemies(int num);
@@ -54,5 +55,4 @@
 
         private:
-            virtual void tick(float dt);
             virtual ColourValue getProjectileColour() const;
 
Index: code/trunk/src/orxonox/objects/Tickable.h
===================================================================
--- code/trunk/src/orxonox/objects/Tickable.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/Tickable.h	(revision 1747)
@@ -45,4 +45,5 @@
 
 #include "core/OrxonoxClass.h"
+#include "core/Super.h"
 
 namespace orxonox
@@ -61,4 +62,6 @@
             Tickable();
     };
+
+    SUPER_FUNCTION(1, Tickable, tick, true);
 
     //! The Tickable interface provides a tick(dt) function, that gets called every frame.
Index: code/trunk/src/orxonox/objects/WorldEntity.cc
===================================================================
--- code/trunk/src/orxonox/objects/WorldEntity.cc	(revision 1740)
+++ code/trunk/src/orxonox/objects/WorldEntity.cc	(revision 1747)
@@ -95,5 +95,4 @@
     }
 
-
     void WorldEntity::setYawPitchRoll(const Degree& yaw, const Degree& pitch, const Degree& roll)
     {
@@ -111,11 +110,11 @@
     void WorldEntity::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlelement, mode);
+        SUPER(WorldEntity, XMLPort, xmlelement, mode);
 
-        XMLPortParam(WorldEntity, "position", setPositionLoader2, getPosition, xmlelement, mode);
-        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionLoader, xmlelement, mode);
+        XMLPortParamExternTemplate(WorldEntity, Ogre::Node, this->node_, "position", setPosition, getPosition, xmlelement, mode, Ogre::Node, const Vector3&);
+        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionSimple, xmlelement, mode);
         XMLPortParamLoadOnly(WorldEntity, "yawpitchroll", setYawPitchRoll, xmlelement, mode);
-        XMLPortParam(WorldEntity, "scale", setTotalScale, getScale, xmlelement, mode);
-        XMLPortParam(WorldEntity, "rotationAxis", setRotationAxisLoader, getRotationAxis, xmlelement, mode);
+        XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
+        XMLPortParamTemplate(WorldEntity, "rotationAxis", setRotationAxis, getRotationAxis, xmlelement, mode, WorldEntity, const Vector3&);
         XMLPortParam(WorldEntity, "rotationRate", setRotationRate, getRotationRate, xmlelement, mode);
 
@@ -150,7 +149,7 @@
       registerVar( (void*) &(this->getRotationAxis().z), sizeof(this->getRotationAxis().z), network::DATA, 0x3);
       // register scale of node
-      registerVar( (void*) &(this->getScale().x), sizeof(this->getScale().x), network::DATA, 0x3);
-      registerVar( (void*) &(this->getScale().y), sizeof(this->getScale().y), network::DATA, 0x3);
-      registerVar( (void*) &(this->getScale().z), sizeof(this->getScale().z), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().x), sizeof(this->getScale3D().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().y), sizeof(this->getScale3D().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().z), sizeof(this->getScale3D().z), network::DATA, 0x3);
       //register staticity
       registerVar( (void*) &(this->bStatic_), sizeof(this->bStatic_), network::DATA, 0x3);
Index: code/trunk/src/orxonox/objects/WorldEntity.h
===================================================================
--- code/trunk/src/orxonox/objects/WorldEntity.h	(revision 1740)
+++ code/trunk/src/orxonox/objects/WorldEntity.h	(revision 1747)
@@ -65,8 +65,4 @@
             inline void setPosition(const Vector3& pos)
                 { this->node_->setPosition(pos); }
-            inline void setPositionLoader1(const Vector3& pos)
-                { this->node_->setPosition(pos); }
-            inline void setPositionLoader2(Real x, Real y, Real z)
-                { this->node_->setPosition(x, y, z); }
             inline void setPosition(Real x, Real y, Real z)
                 { this->node_->setPosition(x, y, z); }
@@ -108,5 +104,5 @@
             inline void rotate(const Vector3& axis, const Radian& angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
               { this->node_->rotate(axis, angle, relativeTo); }
-            inline void setDirectionLoader(Real x, Real y, Real z)
+            inline void setDirectionSimple(Real x, Real y, Real z)
               { this->setDirection(x, y, z); }
             inline void setDirection(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
@@ -117,17 +113,17 @@
               { this->node_->lookAt(targetPoint, relativeTo, localDirectionVector); }
 
-            inline void setScale(const Vector3& scale)
+            inline void setScale3D(const Vector3 &scale)
               { this->node_->setScale(scale); }
-            inline void setScale(Real x, Real y, Real z)
+            inline void setScale3D(Real x, Real y, Real z)
               { this->node_->setScale(x, y, z); }
-            inline void setScale(Real scale)
+            inline const Vector3& getScale3D(void) const
+              { return this->node_->getScale(); }
+            inline void setScale(float scale)
               { this->node_->setScale(scale, scale, scale); }
-            inline void setTotalScale(Real scale)
-              { this->node_->setScale(scale, scale, scale); }
-            inline const Vector3& getScale(void) const
-              { return this->node_->getScale(); }
-            inline void scale(const Vector3& scale)
+            inline float getScale() const
+              { Vector3 scale = this->getScale3D(); return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1; }
+            inline void scale3D(const Vector3 &scale)
               { this->node_->scale(scale); }
-            inline void scale(Real x, Real y, Real z)
+            inline void scale3D(Real x, Real y, Real z)
               { this->node_->scale(x, y, z); }
             inline void scale(Real scale)
@@ -159,8 +155,6 @@
                 { return this->acceleration_; }
 
-            inline void setRotationAxisLoader(const Vector3& axis)
-                { this->rotationAxis_ = axis; rotationAxis_.normalise(); }
             inline void setRotationAxis(const Vector3& axis)
-                { this->rotationAxis_ = axis; rotationAxis_.normalise(); }
+                { this->rotationAxis_ = axis; this->rotationAxis_.normalise(); }
             inline void setRotationAxis(Real x, Real y, Real z)
                 { this->rotationAxis_.x = x; this->rotationAxis_.y = y; this->rotationAxis_.z = z; rotationAxis_.normalise(); }
Index: code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc
===================================================================
--- code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc	(revision 1747)
@@ -51,7 +51,7 @@
     std::map<std::string, OrxonoxOverlay*> OrxonoxOverlay::overlays_s;
 
-    SetConsoleCommand(OrxonoxOverlay, scaleOverlay, false).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(OrxonoxOverlay, scrollOverlay, false).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, scaleOverlay, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, scrollOverlay, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).accessLevel(AccessLevel::User);
 
     OrxonoxOverlay::OrxonoxOverlay()
@@ -84,5 +84,5 @@
     @brief
         Loads the OrxonoxOverlay.
-        
+
         This has to be called before usage, otherwise strange behaviour is
         guaranteed! (there should be no segfaults however).
@@ -92,5 +92,5 @@
     void OrxonoxOverlay::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlElement, mode);
+        SUPER(OrxonoxOverlay, XMLPort, xmlElement, mode);
 
         if (mode == XMLPort::LoadObject)
@@ -267,5 +267,5 @@
         if (angle > Ogre::Math::PI * 0.5)
             angle = Ogre::Math::PI - angle;
-        
+
         // do some mathematical fiddling for a bounding box
         Vector2 actualSize = size_ * sizeCorrection_;
Index: code/trunk/src/orxonox/overlays/OrxonoxOverlay.h
===================================================================
--- code/trunk/src/orxonox/overlays/OrxonoxOverlay.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/OrxonoxOverlay.h	(revision 1747)
@@ -150,6 +150,7 @@
         static void rotateOverlay(const std::string& name, const Degree& angle);
 
+        virtual void changedVisibility();
+
     protected:
-        virtual void changedVisibility();
         virtual void angleChanged();
         virtual void sizeCorrectionChanged();
Index: code/trunk/src/orxonox/overlays/OverlayGroup.cc
===================================================================
--- code/trunk/src/orxonox/overlays/OverlayGroup.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/OverlayGroup.cc	(revision 1747)
@@ -35,7 +35,8 @@
 #include "OverlayGroup.h"
 
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
+#include "core/Iterator.h"
 #include "core/XMLPort.h"
 #include "OrxonoxOverlay.h"
@@ -45,7 +46,7 @@
     CreateFactory(OverlayGroup);
 
-    SetConsoleCommand(OverlayGroup, toggleVisibility, false).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(OverlayGroup, scaleGroup, false).setAccessLevel(AccessLevel::User);
-    SetConsoleCommand(OverlayGroup, scrollGroup, false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, toggleVisibility, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, scaleGroup, false).accessLevel(AccessLevel::User);
+    SetConsoleCommand(OverlayGroup, scrollGroup, false).accessLevel(AccessLevel::User);
 
     OverlayGroup::OverlayGroup()
@@ -62,5 +63,5 @@
     void OverlayGroup::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlElement, mode);
+        SUPER(OverlayGroup, XMLPort, xmlElement, mode);
 
         XMLPortParam(OverlayGroup, "scale",  setScale,  getScale,  xmlElement, mode).defaultValues(Vector2(1.0, 1.0));
@@ -135,5 +136,5 @@
     /*static*/ void OverlayGroup::toggleVisibility(const std::string& name)
     {
-        for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
         {
             if ((*it)->getName() == name)
@@ -151,5 +152,5 @@
     /*static*/ void OverlayGroup::scaleGroup(const std::string& name, float scale)
     {
-        for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
         {
             if ((*it)->getName() == name)
@@ -167,5 +168,5 @@
     /*static*/ void OverlayGroup::scrollGroup(const std::string& name, const Vector2& scroll)
     {
-        for (Iterator<OverlayGroup> it = ObjectList<OverlayGroup>::begin(); it; ++it)
+        for (ObjectList<OverlayGroup>::iterator it = ObjectList<OverlayGroup>::begin(); it; ++it)
         {
             if ((*it)->getName() == name)
Index: code/trunk/src/orxonox/overlays/OverlayGroup.h
===================================================================
--- code/trunk/src/orxonox/overlays/OverlayGroup.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/OverlayGroup.h	(revision 1747)
@@ -58,9 +58,11 @@
         ~OverlayGroup() { }
 
-        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
         static void toggleVisibility(const std::string& name);
         static void scaleGroup(const std::string& name, float scale);
         static void scrollGroup(const std::string& name, const Vector2& scroll);
+
+        void changedVisibility();
 
     private:
@@ -80,6 +82,4 @@
         OrxonoxOverlay* getElement(unsigned int index);
 
-        void changedVisibility();
-
         std::map<std::string, OrxonoxOverlay*> hudElements_;    //!< Contains all the OrxonoxOverlays of the this group.
         Vector2 scale_;                                         //!< Current scale (independant of the elements).
Index: code/trunk/src/orxonox/overlays/OverlayText.cc
===================================================================
--- code/trunk/src/orxonox/overlays/OverlayText.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/OverlayText.cc	(revision 1747)
@@ -57,5 +57,5 @@
     void OverlayText::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        OrxonoxOverlay::XMLPort(xmlElement, mode);
+        SUPER(OverlayText, XMLPort, xmlElement, mode);
 
         if (mode == XMLPort::LoadObject)
Index: code/trunk/src/orxonox/overlays/console/InGameConsole.cc
===================================================================
--- code/trunk/src/orxonox/overlays/console/InGameConsole.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/console/InGameConsole.cc	(revision 1747)
@@ -41,5 +41,5 @@
 #include "util/Math.h"
 #include "util/Convert.h"
-#include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
Index: code/trunk/src/orxonox/overlays/console/InGameConsole.h
===================================================================
--- code/trunk/src/orxonox/overlays/console/InGameConsole.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/console/InGameConsole.h	(revision 1747)
@@ -50,5 +50,5 @@
             void setConfigValues();
 
-            void tick(float dt);
+            virtual void tick(float dt);
 
             static InGameConsole& getInstance();
Index: code/trunk/src/orxonox/overlays/debug/DebugFPSText.h
===================================================================
--- code/trunk/src/orxonox/overlays/debug/DebugFPSText.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/debug/DebugFPSText.h	(revision 1747)
@@ -43,8 +43,5 @@
         ~DebugFPSText();
 
-    private:
-        void tick(float dt);
-
-    private:
+        virtual void tick(float dt);
     };
 }
Index: code/trunk/src/orxonox/overlays/debug/DebugRTRText.h
===================================================================
--- code/trunk/src/orxonox/overlays/debug/DebugRTRText.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/debug/DebugRTRText.h	(revision 1747)
@@ -43,6 +43,5 @@
         ~DebugRTRText();
 
-    private:
-        void tick(float dt);
+        virtual void tick(float dt);
     };
 }
Index: code/trunk/src/orxonox/overlays/hud/HUDBar.cc
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDBar.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDBar.cc	(revision 1747)
@@ -53,5 +53,5 @@
     void BarColour::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        BaseObject::XMLPort(xmlElement, mode);
+        SUPER(BarColour, XMLPort, xmlElement, mode);
 
         XMLPortParam(BarColour, "colour", setColour, getColour, xmlElement, mode)
@@ -78,5 +78,5 @@
     void HUDBar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        OrxonoxOverlay::XMLPort(xmlElement, mode);
+        SUPER(HUDBar, XMLPort, xmlElement, mode);
 
         if (mode == XMLPort::LoadObject)
Index: code/trunk/src/orxonox/overlays/hud/HUDBar.h
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDBar.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDBar.h	(revision 1747)
@@ -47,5 +47,5 @@
         ~BarColour() { }
 
-        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
         void setColour(const ColourValue& colour) { this->colour_ = colour; }
Index: code/trunk/src/orxonox/overlays/hud/HUDNavigation.cc
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDNavigation.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDNavigation.cc	(revision 1747)
@@ -69,5 +69,5 @@
     void HUDNavigation::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        OrxonoxOverlay::XMLPort(xmlElement, mode);
+        SUPER(HUDNavigation, XMLPort, xmlElement, mode);
 
         if (mode == XMLPort::LoadObject)
@@ -87,5 +87,5 @@
                 .createOverlayElement("Panel", "HUDNavigation_aimMarker_" + getUniqueNumberStr()));
             aimMarker_->setMaterialName("Orxonox/NavCrosshair");
-            
+
             background_->addChild(navMarker_);
             background_->addChild(aimMarker_);
Index: code/trunk/src/orxonox/overlays/hud/HUDNavigation.h
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDNavigation.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDNavigation.h	(revision 1747)
@@ -44,5 +44,6 @@
         ~HUDNavigation();
 
-        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void tick(float dt);
 
     private:
@@ -50,6 +51,4 @@
         void angleChanged() { }
         void positionChanged() { }
-
-        void tick(float dt);
 
         // XMLPort accessors
Index: code/trunk/src/orxonox/overlays/hud/HUDRadar.cc
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDRadar.cc	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDRadar.cc	(revision 1747)
@@ -66,5 +66,5 @@
     void HUDRadar::XMLPort(Element& xmlElement, XMLPort::Mode mode)
     {
-        OrxonoxOverlay::XMLPort(xmlElement, mode);
+        SUPER(HUDRadar, XMLPort, xmlElement, mode);
 
         if (mode == XMLPort::LoadObject)
Index: code/trunk/src/orxonox/overlays/hud/HUDRadar.h
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDRadar.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDRadar.h	(revision 1747)
@@ -48,5 +48,5 @@
         ~HUDRadar();
 
-        void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 
     private:
Index: code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.h
===================================================================
--- code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.h	(revision 1740)
+++ code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.h	(revision 1747)
@@ -44,6 +44,5 @@
         ~HUDSpeedBar();
 
-    private:
-        void tick(float dt);
+        virtual void tick(float dt);
     };
 }
Index: code/trunk/src/orxonox/tools/WindowEventListener.cc
===================================================================
--- code/trunk/src/orxonox/tools/WindowEventListener.cc	(revision 1740)
+++ code/trunk/src/orxonox/tools/WindowEventListener.cc	(revision 1747)
@@ -38,5 +38,5 @@
     WindowEventListener::WindowEventListener()
     {
-        RegisterObject(WindowEventListener);
+        RegisterRootObject(WindowEventListener);
     }
 }
Index: code/trunk/src/util/CMakeLists.txt
===================================================================
--- code/trunk/src/util/CMakeLists.txt	(revision 1740)
+++ code/trunk/src/util/CMakeLists.txt	(revision 1747)
@@ -2,9 +2,10 @@
   ArgReader.cc
   Clipboard.cc
+  Error.cc
   ExprParser.cc
   Math.cc
-  MultiTypePrimitive.cc
-  MultiTypeString.cc
-  MultiTypeMath.cc
+  MultiType.cc
+  OutputBuffer.cc
+  OutputHandler.cc
   String.cc
   SubString.cc
Index: code/trunk/src/util/Convert.h
===================================================================
--- code/trunk/src/util/Convert.h	(revision 1740)
+++ code/trunk/src/util/Convert.h	(revision 1747)
@@ -41,6 +41,6 @@
 
 #include "Math.h"
+#include "Debug.h"
 #include "SubString.h"
-#include "MultiTypeMath.h"
 #include "String.h"
 
@@ -75,5 +75,8 @@
     enum { specialized = false };
     static bool convert(ToType* output, const FromType& input)
-    { return false; }
+    {
+        COUT(2) << "Warning: Couldn't convert a value: From \"" << typeid(FromType).name() << "\" to \"" << typeid(ToType).name() << "\"" << std::endl;
+        return false;
+    }
 };
 
@@ -95,20 +98,22 @@
 
 // Defines the levels of all types: Default is __high__ so you don't have to define every high-level type
-template <class T> struct ConverterLevel           { enum { level = __high__ }; };
-template <> struct ConverterLevel<std::string>     { enum { level = __mid__ }; };
-template <> struct ConverterLevel<orxonox::Radian> { enum { level = __mid__ }; };
-template <> struct ConverterLevel<orxonox::Degree> { enum { level = __mid__ }; };
-template <> struct ConverterLevel<int>             { enum { level = __low__ }; };
-template <> struct ConverterLevel<unsigned int>    { enum { level = __low__ }; };
-template <> struct ConverterLevel<char>            { enum { level = __low__ }; };
-template <> struct ConverterLevel<unsigned char>   { enum { level = __low__ }; };
-template <> struct ConverterLevel<short>           { enum { level = __low__ }; };
-template <> struct ConverterLevel<unsigned short>  { enum { level = __low__ }; };
-template <> struct ConverterLevel<long>            { enum { level = __low__ }; };
-template <> struct ConverterLevel<unsigned long>   { enum { level = __low__ }; };
-template <> struct ConverterLevel<float>           { enum { level = __low__ }; };
-template <> struct ConverterLevel<double>          { enum { level = __low__ }; };
-template <> struct ConverterLevel<long double>     { enum { level = __low__ }; };
-template <> struct ConverterLevel<bool>            { enum { level = __low__ }; };
+template <class T> struct ConverterLevel              { enum { level = __high__ }; };
+template <> struct ConverterLevel<std::string>        { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Radian>    { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Degree>    { enum { level = __mid__ }; };
+template <> struct ConverterLevel<int>                { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned int>       { enum { level = __low__ }; };
+template <> struct ConverterLevel<char>               { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned char>      { enum { level = __low__ }; };
+template <> struct ConverterLevel<short>              { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned short>     { enum { level = __low__ }; };
+template <> struct ConverterLevel<long>               { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long>      { enum { level = __low__ }; };
+template <> struct ConverterLevel<long long>          { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long long> { enum { level = __low__ }; };
+template <> struct ConverterLevel<float>              { enum { level = __low__ }; };
+template <> struct ConverterLevel<double>             { enum { level = __low__ }; };
+template <> struct ConverterLevel<long double>        { enum { level = __low__ }; };
+template <> struct ConverterLevel<bool>               { enum { level = __low__ }; };
 
 
@@ -140,4 +145,5 @@
     static bool convert(ToType* output, const FromType& input)
     {
+        COUT(2) << "Warning: Couldn't convert a value: From \"" << typeid(FromType).name() << "\" to \"" << typeid(ToType).name() << "\"" << std::endl;
         return false;
     }
@@ -330,85 +336,32 @@
 
 
-////////////////
-// MULTITYPES //
-////////////////
-
-// convert from MultiTypePrimitive
-template <class ToType>
-struct ConverterSpecialized<MultiTypePrimitive, ToType, _FromType_>
-{
-    enum { specialized = true };
-    static bool convert(ToType* output, const MultiTypePrimitive& input)
-    {
-        if (input.getType() == MT_void)
-            return ConvertValue(output, input.getVoid());
-        else if (input.getType() == MT_int)
-            return ConvertValue(output, input.getInt());
-        else if (input.getType() == MT_uint)
-            return ConvertValue(output, input.getUnsignedInt());
-        else if (input.getType() == MT_char)
-            return ConvertValue(output, input.getChar());
-        else if (input.getType() == MT_uchar)
-            return ConvertValue(output, input.getUnsignedChar());
-        else if (input.getType() == MT_short)
-            return ConvertValue(output, input.getShort());
-        else if (input.getType() == MT_ushort)
-            return ConvertValue(output, input.getUnsignedShort());
-        else if (input.getType() == MT_long)
-            return ConvertValue(output, input.getLong());
-        else if (input.getType() == MT_ulong)
-            return ConvertValue(output, input.getUnsignedLong());
-        else if (input.getType() == MT_float)
-            return ConvertValue(output, input.getFloat());
-        else if (input.getType() == MT_double)
-            return ConvertValue(output, input.getDouble());
-        else if (input.getType() == MT_longdouble)
-            return ConvertValue(output, input.getLongDouble());
-        else if (input.getType() == MT_bool)
-            return ConvertValue(output, input.getBool());
-        else
-            return false;
-    }
-};
-
-// convert from MultiTypeString
-template <class ToType>
-struct ConverterSpecialized<MultiTypeString, ToType, _FromType_>
-{
-    enum { specialized = true };
-    static bool convert(ToType* output, const MultiTypeString& input)
-    {
-        if (input.getType() == MT_constchar)
-            return ConvertValue(output, input.getConstChar());
-        else if (input.getType() == MT_string)
-            return ConvertValue(output, input.getString());
-        else
-            return ConvertValue(output, (MultiTypePrimitive)input);
-    }
-};
-
-// convert from MultiTypeMath
-template <class ToType>
-struct ConverterSpecialized<MultiTypeMath, ToType, _FromType_>
-{
-    enum { specialized = true };
-    static bool convert(ToType* output, const MultiTypeMath& input)
-    {
-        if (input.getType() == MT_vector2)
-            return ConvertValue(output, input.getVector2());
-        else if (input.getType() == MT_vector3)
-            return ConvertValue(output, input.getVector3());
-        else if (input.getType() == MT_vector4)
-            return ConvertValue(output, input.getVector4());
-        else if (input.getType() == MT_quaternion)
-            return ConvertValue(output, input.getQuaternion());
-        else if (input.getType() == MT_colourvalue)
-            return ConvertValue(output, input.getColourValue());
-        else if (input.getType() == MT_radian)
-            return ConvertValue(output, input.getRadian());
-        else if (input.getType() == MT_degree)
-            return ConvertValue(output, input.getDegree());
-        else
-            return ConvertValue(output, (MultiTypeString)input);
+//////////
+// MATH //
+//////////
+// convert everything to Degree
+template <class FromType>
+struct ConverterSpecialized<FromType, Ogre::Degree, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(Ogre::Degree* output, const FromType& input)
+    {
+        float angle = 0;
+        bool success = ConvertValue<FromType, float>(&angle, input);
+        (*output) = angle;
+        return success;
+    }
+};
+
+// convert everything to Radian
+template <class FromType>
+struct ConverterSpecialized<FromType, Ogre::Radian, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(Ogre::Radian* output, const FromType& input)
+    {
+        float angle = 0;
+        bool success = ConvertValue<FromType, float>(&angle, input);
+        (*output) = angle;
+        return success;
     }
 };
Index: code/trunk/src/util/Debug.h
===================================================================
--- code/trunk/src/util/Debug.h	(revision 1747)
+++ code/trunk/src/util/Debug.h	(revision 1747)
@@ -0,0 +1,234 @@
+/*
+ *   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:
+ *      Benjamin Grauer
+ *   Co-authors:
+ *      Fabian 'x3n' Landau
+ *
+ */
+
+/**
+ * @file Debug.h
+ * @brief Handles the output for different verbose-modes.
+ *
+ * There are two modes: HARD and SOFT. HARD is precessed during compiletime, while SOFT is for runtime.
+ */
+
+#ifndef _Debug_H__
+#define _Debug_H__
+
+#include "UtilPrereqs.h"
+
+#include <stdio.h>
+
+#include "OutputHandler.h"
+
+
+/**
+    @brief Returns the soft debug level, stored in the only existing instance of the OutputHandler class, configured in the config-file.
+    @return The soft debug level
+*/
+static inline int getSoftDebugLevel()
+{
+    return orxonox::OutputHandler::getSoftDebugLevel();
+}
+
+
+// DEFINE ERROR MODES
+#define ORX_NONE            0
+#define ORX_ERROR           1
+#define ORX_WARNING         2
+#define ORX_INFO            3
+#define ORX_DEBUG           4
+#define ORX_VERBOSE         5
+#define ORX_ULTRA           6
+
+//definitions
+#define ORX_PRINT_DEBUG_OUTPUT 1
+#define ORX_HARD_DEBUG_LEVEL ORX_VERBOSE
+
+#define COUT_EXEC(x) orxonox::OutputHandler::getOutStream().setOutputLevel(x)
+
+////////////////////////////////////////////////////////
+///  COUT: just prints output as is with std::cout   ///
+////////////////////////////////////////////////////////
+#define COUTORX_NONE    COUT0
+#define COUTORX_ERROR   COUT1
+#define COUTORX_WARNING COUT2
+#define COUTORX_INFO    COUT3
+#define COUTORX_DEBUG   COUT4
+#define COUTORX_VERBOSE COUT5
+#define COUTORX_ULTRA   COUT6
+
+#ifndef COUT
+ #if ORX_PRINT_DEBUG_OUTPUT
+  #define COUT(x) \
+   COUT ## x
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
+   #define COUT0 \
+    (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : COUT_EXEC(0)
+  #else
+   #define COUT0 \
+    false ? COUT_EXEC(0) : COUT_EXEC(0)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
+   #define COUT1 \
+    (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : COUT_EXEC(1)
+  #else
+   #define COUT1 \
+    false ? COUT_EXEC(1) : COUT_EXEC(1)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
+   #define COUT2 \
+    (getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : COUT_EXEC(2)
+  #else
+   #define COUT2 \
+    false ? COUT_EXEC(2) : COUT_EXEC(2)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
+   #define COUT3 \
+    (getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : COUT_EXEC(3)
+  #else
+   #define COUT3 \
+    false ? COUT_EXEC(3) : COUT_EXEC(3)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
+   #define COUT4 \
+    (getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : COUT_EXEC(4)
+  #else
+   #define COUT4 \
+    false ? COUT_EXEC(4) : COUT_EXEC(4)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_VERBOSE
+   #define COUT5 \
+    (getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : COUT_EXEC(5)
+  #else
+   #define COUT5 \
+    false ? COUT_EXEC(5) : COUT_EXEC(5)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_ULTRA
+   #define COUT6 \
+    (getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : COUT_EXEC(6)
+  #else
+   #define COUT6 \
+    false ? COUT_EXEC(6) : COUT_EXEC(6)
+  #endif
+
+ #else /* if ORX_PRINT_DEBUG_OUTPUT */
+  #define COUT(x) \
+    false ? COUT_EXEC(6) : COUT_EXEC(6)
+ #endif /* if ORX_PRINT_DEBUG_OUTPUT */
+
+#endif /* ifndef COUT */
+
+
+/////////////////////////////////////////////////////////////////////
+///  CCOUT: Prints output with std::cout and adds the classname   ///
+/////////////////////////////////////////////////////////////////////
+#define CCOUTORX_NONE    CCOUT0
+#define CCOUTORX_ERROR   CCOUT1
+#define CCOUTORX_WARNING CCOUT2
+#define CCOUTORX_INFO    CCOUT3
+#define CCOUTORX_DEBUG   CCOUT4
+#define CCOUTORX_VERBOSE CCOUT5
+#define CCOUTORX_ULTRA   CCOUT6
+
+#define CCOUT_EXEC(x) \
+  orxonox::OutputHandler::getOutStream().setOutputLevel(x) \
+  << this->getIdentifier()->getName() << ": "
+
+#ifndef CCOUT
+ #if ORX_PRINT_DEBUG_OUTPUT
+  #define CCOUT(x) \
+   CCOUT ## x
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
+   #define CCOUT0 \
+    (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : CCOUT_EXEC(0)
+  #else
+   #define CCOUT0 \
+    false ? COUT_EXEC(0) : CCOUT_EXEC(0)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
+   #define CCOUT1 \
+    (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : CCOUT_EXEC(1)
+  #else
+   #define CCOUT1 \
+    false ? COUT_EXEC(1) : CCOUT_EXEC(1)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
+   #define CCOUT2 \
+    (getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : CCOUT_EXEC(2)
+  #else
+   #define CCOUT2 \
+    false ? COUT_EXEC(2) : CCOUT_EXEC(2)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
+   #define CCOUT3 \
+    (getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : CCOUT_EXEC(3)
+  #else
+   #define CCOUT3 \
+    false ? COUT_EXEC(3) : CCOUT_EXEC(3)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
+   #define CCOUT4 \
+    (getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : CCOUT_EXEC(4)
+  #else
+   #define CCOUT4 \
+    false ? COUT_EXEC(4) : CCOUT_EXEC(4)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_VERBOSE
+   #define CCOUT5 \
+    (getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : CCOUT_EXEC(5)
+  #else
+   #define CCOUT5 \
+    false ? COUT_EXEC(5) : CCOUT_EXEC(5)
+  #endif
+
+  #if ORX_HARD_DEBUG_LEVEL >= ORX_ULTRA
+   #define CCOUT6 \
+    (getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : CCOUT_EXEC(6)
+  #else
+   #define CCOUT6 \
+    false ? COUT_EXEC(6) : CCOUT_EXEC(6)
+  #endif
+
+ #else /* if ORX_PRINT_DEBUG_OUTPUT */
+  #define CCOUT(x) \
+   false ? CCOUT_EXEC(6) : CCOUT_EXEC(6)
+ #endif /* if ORX_PRINT_DEBUG_OUTPUT */
+
+#endif /* ifndef CCOUT */
+
+#endif /* _Debug_H__ */
Index: code/trunk/src/util/Error.cc
===================================================================
--- code/trunk/src/util/Error.cc	(revision 1747)
+++ code/trunk/src/util/Error.cc	(revision 1747)
@@ -0,0 +1,60 @@
+/*
+ *   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:
+ *      Nicolas Perrenoud
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Error.cc
+    @brief Implementation of the Error class.
+*/
+
+#include "Error.h"
+#include "Debug.h"
+
+namespace orxonox
+{
+	Error::Error(std::string errorMsg, int errorCode)
+	{
+		COUT(1) << "############################ " << std::endl
+					  << "#         Error " << errorCode << "          #" << std::endl
+						<< "############################ " << std::endl
+						<< "An error occured in Orxonox: " << std::endl;
+
+		if (errorMsg == "")
+		{
+			switch (errorCode)
+			{
+				case 1:
+					errorMsg = "Some error!";
+					break;
+
+				default:
+					errorMsg = "Unknown error!";
+			}
+		}
+		COUT(1) << errorMsg << std::endl << std::endl;
+	}
+}
Index: code/trunk/src/util/Error.h
===================================================================
--- code/trunk/src/util/Error.h	(revision 1747)
+++ code/trunk/src/util/Error.h	(revision 1747)
@@ -0,0 +1,52 @@
+/*
+ *   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:
+ *      Nicolas Perrenoud
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file Error.h
+    @brief Definition of the Error class.
+*/
+
+#ifndef _Error_H__
+#define _Error_H__
+
+#include "UtilPrereqs.h"
+
+#include <string>
+
+namespace orxonox
+{
+	class _UtilExport Error
+	{
+	public:
+		Error(std::string errorMsg = "", int errorCode = 0);
+	private:
+
+	};
+}
+
+#endif /* _Error_H__ */
Index: code/trunk/src/util/MultiType.cc
===================================================================
--- code/trunk/src/util/MultiType.cc	(revision 1747)
+++ code/trunk/src/util/MultiType.cc	(revision 1747)
@@ -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:
+ *      ...
+ *
+ */
+
+#include "MultiType.h"
+#include "MultiTypeValue.h"
+
+void MultiType::convert(MT_Type type)
+{
+    switch (type)
+    {
+        case MT_char:
+            this->convert<char>(); break;
+        case MT_uchar:
+            this->convert<unsigned char>(); break;
+        case MT_short:
+            this->convert<short>(); break;
+        case MT_ushort:
+            this->convert<unsigned short>(); break;
+        case MT_int:
+            this->convert<int>(); break;
+        case MT_uint:
+            this->convert<unsigned int>(); break;
+        case MT_long:
+            this->convert<long>(); break;
+        case MT_ulong:
+            this->convert<unsigned long>(); break;
+        case MT_longlong:
+            this->convert<long long>(); break;
+        case MT_ulonglong:
+            this->convert<unsigned long long>(); break;
+        case MT_float:
+            this->convert<float>(); break;
+        case MT_double:
+            this->convert<double>(); break;
+        case MT_longdouble:
+            this->convert<long double>(); break;
+        case MT_bool:
+            this->convert<bool>(); break;
+        case MT_void:
+            this->convert<void*>(); break;
+        case MT_string:
+            this->convert<std::string>(); break;
+        case MT_vector2:
+            this->convert<orxonox::Vector2>(); break;
+        case MT_vector3:
+            this->convert<orxonox::Vector3>(); break;
+        case MT_vector4:
+            this->convert<orxonox::Vector4>(); break;
+        case MT_colourvalue:
+            this->convert<orxonox::ColourValue>(); break;
+        case MT_quaternion:
+            this->convert<orxonox::Quaternion>(); break;
+        case MT_radian:
+            this->convert<orxonox::Radian>(); break;
+        case MT_degree:
+            this->convert<orxonox::Degree>(); break;
+        default:
+            this->reset(); break;
+    };
+}
+
+std::string MultiType::getTypename() const
+{
+    MT_Type type = (this->value_) ? this->value_->type_ : MT_null;
+
+    switch (type)
+    {
+        case MT_char:
+            return "char"; break;
+        case MT_uchar:
+            return "unsigned char"; break;
+        case MT_short:
+            return "short"; break;
+        case MT_ushort:
+            return "unsigned short"; break;
+        case MT_int:
+            return "int"; break;
+        case MT_uint:
+            return "unsigned int"; break;
+        case MT_long:
+            return "long"; break;
+        case MT_ulong:
+            return "unsigned long"; break;
+        case MT_longlong:
+            return "long long"; break;
+        case MT_ulonglong:
+            return "unsigned long long"; break;
+        case MT_float:
+            return "float"; break;
+        case MT_double:
+            return "double"; break;
+        case MT_longdouble:
+            return "long double"; break;
+        case MT_bool:
+            return "bool"; break;
+        case MT_void:
+            return "void*"; break;
+        case MT_string:
+            return "std::string"; break;
+        case MT_vector2:
+            return "orxonox::Vector2"; break;
+        case MT_vector3:
+            return "orxonox::Vector3"; break;
+        case MT_vector4:
+            return "orxonox::Vector4"; break;
+        case MT_colourvalue:
+            return "orxonox::ColourValue"; break;
+        case MT_quaternion:
+            return "orxonox::Quaternion"; break;
+        case MT_radian:
+            return "orxonox::Radian"; break;
+        case MT_degree:
+            return "orxonox::Degree"; break;
+        default:
+            return "unknown"; break;
+    };
+}
+
+MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_char       ) ? ((MT_Value<char>                *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_uchar      ) ? ((MT_Value<unsigned char>       *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_short      ) ? ((MT_Value<short>               *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_ushort     ) ? ((MT_Value<unsigned short>      *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_int        ) ? ((MT_Value<int>                 *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_uint       ) ? ((MT_Value<unsigned int>        *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_long       ) ? ((MT_Value<long>                *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_ulong      ) ? ((MT_Value<unsigned long>       *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_longlong   ) ? ((MT_Value<long long>           *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_ulonglong  ) ? ((MT_Value<unsigned long long>  *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_float      ) ? ((MT_Value<float>               *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? ((MT_Value<double>              *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? ((MT_Value<long double>         *)this->value_)->value_ : (*this->value_)) : 0;                      }
+MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : false;                  }
+MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : (void*)0;               }
+MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : std::string();          }
+MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : orxonox::Vector2();     }
+MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : orxonox::Vector3();     }
+MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : orxonox::Vector4();     }
+MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : orxonox::ColourValue(); }
+MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : orxonox::Quaternion();  }
+MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : orxonox::Radian();      }
+MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : orxonox::Degree();      }
+
+template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); }
+template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_uchar      ); }
+template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_short      ); }
+template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_ushort     ); }
+template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_int        ); }
+template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_uint       ); }
+template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_long       ); }
+template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_ulong      ); }
+template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_longlong   ); }
+template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_ulonglong  ); }
+template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_float      ); }
+template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_double     ); }
+template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_longdouble ); }
+template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_bool       ); }
+template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_void       ); }
+template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_string     ); }
+template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_vector2    ); }
+template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_vector3    ); }
+template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_vector4    ); }
+template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_colourvalue); }
+template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_quaternion ); }
+template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_radian     ); }
+template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_degree     ); }
Index: code/trunk/src/util/MultiType.h
===================================================================
--- code/trunk/src/util/MultiType.h	(revision 1740)
+++ code/trunk/src/util/MultiType.h	(revision 1747)
@@ -25,5 +25,4 @@
  *      ...
  *
- *   Inspiration: MultiType by Benjamin Grauer
  */
 
@@ -33,23 +32,27 @@
 #include "UtilPrereqs.h"
 
-enum _UtilExport MultiType
+#include <boost/static_assert.hpp>
+
+#include "Math.h"
+
+enum MT_Type
 {
     MT_null,
-    MT_void,
-    MT_int,
-    MT_uint,
     MT_char,
     MT_uchar,
     MT_short,
     MT_ushort,
+    MT_int,
+    MT_uint,
     MT_long,
     MT_ulong,
+    MT_longlong,
+    MT_ulonglong,
     MT_float,
     MT_double,
     MT_longdouble,
     MT_bool,
-    MT_constchar,
+    MT_void,
     MT_string,
-    MT_xmlelement,
     MT_vector2,
     MT_vector3,
@@ -57,24 +60,355 @@
     MT_colourvalue,
     MT_quaternion,
-    MT_degree,
-    MT_radian
+    MT_radian,
+    MT_degree
 };
 
-union _UtilExport MultiTypeValue
+class _UtilExport MultiType
 {
-    void*           void_;
-    int             int_;
-    unsigned int    uint_;
-    char            char_;
-    unsigned char   uchar_;
-    short           short_;
-    unsigned short  ushort_;
-    long            long_;
-    unsigned long   ulong_;
-    float           float_;
-    double          double_;
-    long double     longdouble_;
-    bool            bool_;
+    _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
+    template <typename T> friend struct MT_Value;
+
+    struct _UtilExport MT_ValueBase
+    {
+        MT_ValueBase(MT_Type type) : type_(type) {}
+        virtual ~MT_ValueBase() {}
+
+        virtual MT_ValueBase* clone() const = 0;
+
+        virtual void reset() = 0;
+        virtual void assimilate(const MultiType& other) = 0;
+        const MT_Type& getType() const { return this->type_; }
+
+        virtual void setValue(const char& value)                 = 0;
+        virtual void setValue(const unsigned char& value)        = 0;
+        virtual void setValue(const short& value)                = 0;
+        virtual void setValue(const unsigned short& value)       = 0;
+        virtual void setValue(const int& value)                  = 0;
+        virtual void setValue(const unsigned int& value)         = 0;
+        virtual void setValue(const long& value)                 = 0;
+        virtual void setValue(const unsigned long& value)        = 0;
+        virtual void setValue(const long long& value)            = 0;
+        virtual void setValue(const unsigned long long& value)   = 0;
+        virtual void setValue(const float& value)                = 0;
+        virtual void setValue(const double& value)               = 0;
+        virtual void setValue(const long double& value)          = 0;
+        virtual void setValue(const bool& value)                 = 0;
+        virtual void setValue(      void* const& value)          = 0;
+        virtual void setValue(const std::string& value)          = 0;
+        virtual void setValue(const orxonox::Vector2& value)     = 0;
+        virtual void setValue(const orxonox::Vector3& value)     = 0;
+        virtual void setValue(const orxonox::Vector4& value)     = 0;
+        virtual void setValue(const orxonox::ColourValue& value) = 0;
+        virtual void setValue(const orxonox::Quaternion& value)  = 0;
+        virtual void setValue(const orxonox::Radian& value)      = 0;
+        virtual void setValue(const orxonox::Degree& value)      = 0;
+
+        virtual operator char()                 const = 0;
+        virtual operator unsigned char()        const = 0;
+        virtual operator short()                const = 0;
+        virtual operator unsigned short()       const = 0;
+        virtual operator int()                  const = 0;
+        virtual operator unsigned int()         const = 0;
+        virtual operator long()                 const = 0;
+        virtual operator unsigned long()        const = 0;
+        virtual operator long long()            const = 0;
+        virtual operator unsigned long long()   const = 0;
+        virtual operator float()                const = 0;
+        virtual operator double()               const = 0;
+        virtual operator long double()          const = 0;
+        virtual operator bool()                 const = 0;
+        virtual operator void*()                const = 0;
+        virtual operator std::string()          const = 0;
+        virtual operator orxonox::Vector2()     const = 0;
+        virtual operator orxonox::Vector3()     const = 0;
+        virtual operator orxonox::Vector4()     const = 0;
+        virtual operator orxonox::ColourValue() const = 0;
+        virtual operator orxonox::Quaternion()  const = 0;
+        virtual operator orxonox::Radian()      const = 0;
+        virtual operator orxonox::Degree()      const = 0;
+
+        virtual void toString(std::ostream& outstream) const = 0;
+
+        MT_Type type_;
+    };
+
+    public:
+        inline MultiType()                                  : value_(0) {}
+        inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }
+        inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }
+        inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }
+        inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }
+        inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }
+        inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }
+        inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }
+        inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }
+        inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }
+        inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }
+        inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }
+        inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }
+        inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }
+        inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); }
+        inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }
+        inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }
+
+        inline ~MultiType() { if (this->value_) { delete this->value_; } }
+
+        template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); }
+        inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); }
+        inline                       MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); }
+
+        inline void                                   setValue(const char& value);
+        inline void                                   setValue(const unsigned char& value);
+        inline void                                   setValue(const short& value);
+        inline void                                   setValue(const unsigned short& value);
+        inline void                                   setValue(const int& value);
+        inline void                                   setValue(const unsigned int& value);
+        inline void                                   setValue(const long& value);
+        inline void                                   setValue(const unsigned long& value);
+        inline void                                   setValue(const long long& value);
+        inline void                                   setValue(const unsigned long long& value);
+        inline void                                   setValue(const float& value);
+        inline void                                   setValue(const double& value);
+        inline void                                   setValue(const long double& value);
+        inline void                                   setValue(const bool& value);
+        inline void                                   setValue(      void* const& value);
+        inline void                                   setValue(const std::string& value);
+        inline void                                   setValue(const orxonox::Vector2& value);
+        inline void                                   setValue(const orxonox::Vector3& value);
+        inline void                                   setValue(const orxonox::Vector4& value);
+        inline void                                   setValue(const orxonox::ColourValue& value);
+        inline void                                   setValue(const orxonox::Quaternion& value);
+        inline void                                   setValue(const orxonox::Radian& value);
+        inline void                                   setValue(const orxonox::Degree& value);
+        template <typename V> inline void             setValue(V* value)               { if (this->value_) { this->value_->setValue((void*)value); } else { this->assignValue((void*)value); } }
+        void                                          setValue(const MultiType& other) { if (this->value_) { this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } } }
+        template <typename T, typename V> inline void setValue(const V& value)         { this->setType<T>(); this->setValue(value); }
+        inline void                                   setValue(const char* value);
+
+        inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
+
+        template <typename T> inline void convert()                       { this->setValue<T>((T)(*this));  }
+        inline void                       convert(const MultiType& other) { this->convert(other.getType()); }
+        void                              convert(MT_Type type);
+
+        inline void                       reset()                         { if (this->value_) { delete this->value_; this->value_ = 0; } }
+
+        template <typename T> inline void setType()                       { this->assignValue(T());             }
+        inline void                       setType(const MultiType& other) { this->setType(other.getType());     }
+        inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); }
+
+        inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
+        inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
+        template <typename T> inline bool isType()                  const { return false; }
+        std::string                       getTypename()             const;
+
+        operator char()                  const;
+        operator unsigned char()         const;
+        operator short()                 const;
+        operator unsigned short()        const;
+        operator int()                   const;
+        operator unsigned int()          const;
+        operator long()                  const;
+        operator unsigned long()         const;
+        operator long long()             const;
+        operator unsigned long long()    const;
+        operator float()                 const;
+        operator double()                const;
+        operator long double()           const;
+        operator bool()                  const;
+        operator void*()                 const;
+        operator std::string()           const;
+        operator orxonox::Vector2()      const;
+        operator orxonox::Vector3()      const;
+        operator orxonox::Vector4()      const;
+        operator orxonox::ColourValue()  const;
+        operator orxonox::Quaternion()   const;
+        operator orxonox::Radian()       const;
+        operator orxonox::Degree()       const;
+        template <class T> operator T*() const { return ((T*)this->operator void*()); }
+
+        inline void getValue(char*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned char*        value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(short*                value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned short*       value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(int*                  value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned int*         value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned long*        value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long long*            value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(unsigned long long*   value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(float*                value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(double*               value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(long double*          value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(bool*                 value) const { if (this->value_) { (*value) = (*this->value_); } }
+        inline void getValue(void*                 value) const { if (this->value_) {   value  = (*this->value_); } }
+        inline void getValue(std::string*          value) const { if (this->value_) { (*value) = this->value_->operator std::string();          } }
+        inline void getValue(orxonox::Vector2*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector2();     } }
+        inline void getValue(orxonox::Vector3*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector3();     } }
+        inline void getValue(orxonox::Vector4*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector4();     } }
+        inline void getValue(orxonox::ColourValue* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::ColourValue(); } }
+        inline void getValue(orxonox::Quaternion*  value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Quaternion();  } }
+        inline void getValue(orxonox::Radian*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Radian();      } }
+        inline void getValue(orxonox::Degree*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Degree();      } }
+
+        inline char                     getChar()             const { return this->operator char();                 }
+        inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        }
+        inline short                    getShort()            const { return this->operator short();                }
+        inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       }
+        inline int                      getInt()              const { return this->operator int();                  }
+        inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         }
+        inline long                     getLong()             const { return this->operator long();                 }
+        inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        }
+        inline long long                getLongLong()         const { return this->operator long long();            }
+        inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   }
+        inline float                    getFloat()            const { return this->operator float();                }
+        inline double                   getDouble()           const { return this->operator double();               }
+        inline long double              getLongDouble()       const { return this->operator long double();          }
+        inline bool                     getBool()             const { return this->operator bool();                 }
+        inline void*                    getVoid()             const { return this->operator void*();                }
+        inline std::string              getString()           const { return this->operator std::string();          }
+        inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     }
+        inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     }
+        inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     }
+        inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); }
+        inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  }
+        inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      }
+        inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      }
+        template <typename T> inline T* getPointer()          const { return ((T*)this->getVoid());                 }
+
+    private:
+        inline void assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 } }
+        inline void assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        } }
+        inline void assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                } }
+        inline void assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       } }
+        inline void assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  } }
+        inline void assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         } }
+        inline void assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 } }
+        inline void assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        } }
+        inline void assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            } }
+        inline void assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   } }
+        inline void assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                } }
+        inline void assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               } }
+        inline void assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          } }
+        inline void assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 } }
+        inline void assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                } }
+        inline void assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          } }
+        inline void assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     } }
+        inline void assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     } }
+        inline void assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     } }
+        inline void assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); } }
+        inline void assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  } }
+        inline void assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      } }
+        inline void assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      } }
+
+        template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+        template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
+
+        MT_ValueBase* value_;
 };
 
+_UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
+
+template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_char);        }
+template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       }
+template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       }
+template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      }
+template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         }
+template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        }
+template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        }
+template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       }
+template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    }
+template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   }
+template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       }
+template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      }
+template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  }
+template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        }
+template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        }
+template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      }
+template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     }
+template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     }
+template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     }
+template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); }
+template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  }
+template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      }
+template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      }
+
+template <> inline void MultiType::convert<std::string>()          { this->setValue<std::string>         (this->operator std::string());          }
+template <> inline void MultiType::convert<orxonox::Vector2>()     { this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     }
+template <> inline void MultiType::convert<orxonox::Vector3>()     { this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     }
+template <> inline void MultiType::convert<orxonox::Vector4>()     { this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     }
+template <> inline void MultiType::convert<orxonox::ColourValue>() { this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); }
+template <> inline void MultiType::convert<orxonox::Quaternion>()  { this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  }
+template <> inline void MultiType::convert<orxonox::Radian>()      { this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      }
+template <> inline void MultiType::convert<orxonox::Degree>()      { this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      }
+
+template <> inline void MultiType::convert<const std::string&>()          { this->convert<std::string>();          }
+template <> inline void MultiType::convert<const orxonox::Vector2&>()     { this->convert<orxonox::Vector2>();     }
+template <> inline void MultiType::convert<const orxonox::Vector3&>()     { this->convert<orxonox::Vector3>();     }
+template <> inline void MultiType::convert<const orxonox::Vector4&>()     { this->convert<orxonox::Vector4>();     }
+template <> inline void MultiType::convert<const orxonox::ColourValue&>() { this->convert<orxonox::ColourValue>(); }
+template <> inline void MultiType::convert<const orxonox::Quaternion&>()  { this->convert<orxonox::Quaternion>();  }
+template <> inline void MultiType::convert<const orxonox::Radian&>()      { this->convert<orxonox::Radian>();      }
+template <> inline void MultiType::convert<const orxonox::Degree&>()      { this->convert<orxonox::Degree>();      }
+
+template <> void MultiType::createNewValueContainer(const char& value);
+template <> void MultiType::createNewValueContainer(const unsigned char& value);
+template <> void MultiType::createNewValueContainer(const short& value);
+template <> void MultiType::createNewValueContainer(const unsigned short& value);
+template <> void MultiType::createNewValueContainer(const int& value);
+template <> void MultiType::createNewValueContainer(const unsigned int& value);
+template <> void MultiType::createNewValueContainer(const long& value);
+template <> void MultiType::createNewValueContainer(const unsigned long& value);
+template <> void MultiType::createNewValueContainer(const long long& value);
+template <> void MultiType::createNewValueContainer(const unsigned long long& value);
+template <> void MultiType::createNewValueContainer(const float& value);
+template <> void MultiType::createNewValueContainer(const double& value);
+template <> void MultiType::createNewValueContainer(const bool& value);
+template <> void MultiType::createNewValueContainer(const long double& value);
+template <> void MultiType::createNewValueContainer(      void* const& value);
+template <> void MultiType::createNewValueContainer(const std::string& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
+template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
+
+inline void MultiType::setValue(const char& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned char& value)         { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const short& value)                 { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned short& value)        { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const int& value)                   { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned int& value)          { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const long& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned long& value)         { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const long long& value)             { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const unsigned long long& value)    { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const float& value)                 { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const double& value)                { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const long double& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const bool& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(      void* const& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const std::string& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+inline void MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } }
+
+inline void MultiType::setValue(const char* value)                  { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->assignValue(std::string(value)); } }
+
 #endif /* _MultiType_H__ */
Index: code/trunk/src/util/MultiTypeMath.cc
===================================================================
--- code/trunk/src/util/MultiTypeMath.cc	(revision 1740)
+++ 	(revision )
@@ -1,302 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- *   Inspiration: MultiType by Benjamin Grauer
- */
-
-#include "MultiTypeMath.h"
-#include "Convert.h"
-
-MultiTypeMath::MultiTypeMath(MultiType type) : MultiTypeString(type)
-{
-    if (type == MT_vector2)
-        this->vector2_ = orxonox::Vector2(0, 0);
-    else if (type == MT_vector3)
-        this->vector3_ = orxonox::Vector3(0, 0, 0);
-    else if (type == MT_vector4)
-        this->vector4_ = orxonox::Vector4(0, 0, 0, 0);
-    else if (type == MT_colourvalue)
-        this->colourvalue_ = orxonox::ColourValue(0, 0, 0, 0);
-    else if (type == MT_quaternion)
-        this->quaternion_ = orxonox::Quaternion(1, 0, 0, 0);
-    else if (type == MT_radian)
-        this->radian_ = orxonox::Radian(0);
-    else if (type == MT_degree)
-        this->degree_ = orxonox::Degree(0);
-}
-
-bool MultiTypeMath::operator==(const MultiTypeMath& mtm) const
-{
-    if (!MultiTypeString::operator==(mtm) && this->type_ == mtm.type_)
-    {
-        if (this->type_ == MT_vector2)
-            return (this->vector2_ == mtm.vector2_);
-        else if (this->type_ == MT_vector3)
-            return (this->vector3_ == mtm.vector3_);
-        else if (this->type_ == MT_vector4)
-            return (this->vector4_ == mtm.vector4_);
-        else if (this->type_ == MT_colourvalue)
-            return (this->colourvalue_ == mtm.colourvalue_);
-        else if (this->type_ == MT_quaternion)
-            return (this->quaternion_ == mtm.quaternion_);
-        else if (this->type_ == MT_radian)
-            return (this->radian_ == mtm.radian_);
-        else if (this->type_ == MT_degree)
-            return (this->degree_ == mtm.degree_);
-    }
-
-    return false;
-}
-
-bool MultiTypeMath::operator==(const MultiTypeString& mts) const
-{
-    return MultiTypeString::operator==(mts);
-}
-
-bool MultiTypeMath::operator==(const MultiTypePrimitive& mtp) const
-{
-    return MultiTypePrimitive::operator==(mtp);
-}
-
-bool MultiTypeMath::operator!=(const MultiTypeMath& mtm) const
-{
-    if (MultiTypeString::operator==(mtm) && this->type_ == mtm.type_)
-    {
-        if (this->type_ == MT_vector2)
-            return (this->vector2_ != mtm.vector2_);
-        else if (this->type_ == MT_vector3)
-            return (this->vector3_ != mtm.vector3_);
-        else if (this->type_ == MT_vector4)
-            return (this->vector4_ != mtm.vector4_);
-        else if (this->type_ == MT_colourvalue)
-            return (this->colourvalue_ != mtm.colourvalue_);
-        else if (this->type_ == MT_quaternion)
-            return (this->quaternion_ != mtm.quaternion_);
-        else if (this->type_ == MT_radian)
-            return (this->radian_ != mtm.radian_);
-        else if (this->type_ == MT_degree)
-            return (this->degree_ != mtm.degree_);
-    }
-
-    return true;
-}
-
-bool MultiTypeMath::operator!=(const MultiTypeString& mts) const
-{
-    return MultiTypeString::operator!=(mts);
-}
-
-bool MultiTypeMath::operator!=(const MultiTypePrimitive& mtp) const
-{
-    return MultiTypePrimitive::operator!=(mtp);
-}
-
-MultiTypeMath::operator void*() const
-{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypeMath, void*>(*this, 0); }
-MultiTypeMath::operator int() const
-{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypeMath, int>(*this, 0); }
-MultiTypeMath::operator unsigned int() const
-{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypeMath, unsigned int>(*this, 0); }
-MultiTypeMath::operator char() const
-{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypeMath, char>(*this, 0); }
-MultiTypeMath::operator unsigned char() const
-{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypeMath, unsigned char>(*this, 0); }
-MultiTypeMath::operator short() const
-{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypeMath, short>(*this, 0); }
-MultiTypeMath::operator unsigned short() const
-{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypeMath, unsigned short>(*this, 0); }
-MultiTypeMath::operator long() const
-{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypeMath, long>(*this, 0); }
-MultiTypeMath::operator unsigned long() const
-{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypeMath, unsigned long>(*this, 0); }
-MultiTypeMath::operator float() const
-{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypeMath, float>(*this, 0); }
-MultiTypeMath::operator double() const
-{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypeMath, double>(*this, 0); }
-MultiTypeMath::operator long double() const
-{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypeMath, long double>(*this, 0); }
-MultiTypeMath::operator bool() const
-{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypeMath, bool>(*this, 0); }
-MultiTypeMath::operator std::string() const
-{ return (this->type_ == MT_string) ? this->string_ : getConvertedValue<MultiTypeMath, std::string>(*this); }
-MultiTypeMath::operator const char*() const
-{ return ((this->type_ == MT_constchar) ? this->string_ : getConvertedValue<MultiTypeMath, std::string>(*this)).c_str(); }
-MultiTypeMath::operator orxonox::Vector2() const
-{ return (this->type_ == MT_vector2) ? this->vector2_ : getConvertedValue<MultiTypeMath, orxonox::Vector2>(*this); }
-MultiTypeMath::operator orxonox::Vector3() const
-{ return (this->type_ == MT_vector3) ? this->vector3_ : getConvertedValue<MultiTypeMath, orxonox::Vector3>(*this); }
-MultiTypeMath::operator orxonox::Vector4() const
-{ return (this->type_ == MT_vector4) ? this->vector4_ : getConvertedValue<MultiTypeMath, orxonox::Vector4>(*this); }
-MultiTypeMath::operator orxonox::Quaternion() const
-{ return (this->type_ == MT_quaternion) ? this->quaternion_ : getConvertedValue<MultiTypeMath, orxonox::Quaternion>(*this); }
-MultiTypeMath::operator orxonox::ColourValue() const
-{ return (this->type_ == MT_colourvalue) ? this->colourvalue_ : getConvertedValue<MultiTypeMath, orxonox::ColourValue>(*this); }
-MultiTypeMath::operator orxonox::Radian() const
-{ return (this->type_ == MT_radian) ? this->radian_ : getConvertedValue<MultiTypeMath, orxonox::Radian>(*this); }
-MultiTypeMath::operator orxonox::Degree() const
-{ return (this->type_ == MT_degree) ? this->degree_ : getConvertedValue<MultiTypeMath, orxonox::Degree>(*this); }
-
-void MultiTypeMath::setValue(const MultiTypeMath& mtm)
-{
-    MultiTypeString::setValue(mtm);
-    this->vector2_ = mtm.vector2_;
-    this->vector3_ = mtm.vector3_;
-    this->vector4_ = mtm.vector4_;
-    this->quaternion_ = mtm.quaternion_;
-    this->colourvalue_ = mtm.colourvalue_;
-    this->radian_ = mtm.radian_;
-    this->degree_ = mtm.degree_;
-}
-
-void MultiTypeMath::setValue(const MultiTypeString& mts)
-{
-    MultiTypeString::setValue(mts);
-}
-
-void MultiTypeMath::setValue(const MultiTypePrimitive& mtp)
-{
-    MultiTypePrimitive::setValue(mtp);
-}
-
-std::string MultiTypeMath::getTypename() const
-{
-    if (this->type_ == MT_vector2)
-        return "Vector2";
-    else if (this->type_ == MT_vector3)
-        return "Vector3";
-    else if (this->type_ == MT_vector4)
-        return "Vector4";
-    else if (this->type_ == MT_colourvalue)
-        return "ColourValue";
-    else if (this->type_ == MT_quaternion)
-        return "Quaternion";
-    else if (this->type_ == MT_radian)
-        return "Radian";
-    else if (this->type_ == MT_degree)
-        return "Degree";
-    else
-        return MultiTypeString::getTypename();
-}
-
-std::string MultiTypeMath::toString() const
-{
-    std::string output;
-
-    if (this->type_ == MT_vector2)
-        ConvertValue(&output, this->vector2_);
-    else if (this->type_ == MT_vector3)
-        ConvertValue(&output, this->vector3_);
-    else if (this->type_ == MT_vector4)
-        ConvertValue(&output, this->vector4_);
-    else if (this->type_ == MT_colourvalue)
-        ConvertValue(&output, this->colourvalue_);
-    else if (this->type_ == MT_quaternion)
-        ConvertValue(&output, this->quaternion_);
-    else if (this->type_ == MT_radian)
-        ConvertValue(&output, this->radian_);
-    else if (this->type_ == MT_degree)
-        ConvertValue(&output, this->degree_);
-    else
-        return MultiTypeString::toString();
-
-    return output;
-}
-
-bool MultiTypeMath::fromString(const std::string value)
-{
-    if (this->type_ == MT_vector2)
-        return ConvertValue(&this->vector2_, value, orxonox::Vector2(0, 0));
-    else if (this->type_ == MT_vector3)
-        return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0));
-    else if (this->type_ == MT_vector4)
-        return ConvertValue(&this->vector4_, value, orxonox::Vector4(0, 0, 0, 0));
-    else if (this->type_ == MT_colourvalue)
-        return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0));
-    else if (this->type_ == MT_quaternion)
-        return ConvertValue(&this->quaternion_, value, orxonox::Quaternion(1, 0, 0, 0));
-    else if (this->type_ == MT_radian)
-        return ConvertValue(&this->radian_, value, orxonox::Radian(0));
-    else if (this->type_ == MT_degree)
-        return ConvertValue(&this->degree_, value, orxonox::Degree(0));
-    else
-        return MultiTypeString::fromString(value);
-}
-
-bool MultiTypeMath::assimilate(const MultiTypeMath& mtm, const MultiTypeMath& defvalue)
-{
-    if (this->type_ == MT_void)
-        return ConvertValue(&this->value_.void_, mtm, defvalue.value_.void_);
-    else if (this->type_ == MT_int)
-        return ConvertValue(&this->value_.int_, mtm, defvalue.value_.int_);
-    else if (this->type_ == MT_uint)
-        return ConvertValue(&this->value_.uint_, mtm, defvalue.value_.uint_);
-    else if (this->type_ == MT_char)
-        return ConvertValue(&this->value_.char_, mtm, defvalue.value_.char_);
-    else if (this->type_ == MT_uchar)
-        return ConvertValue(&this->value_.uchar_, mtm, defvalue.value_.uchar_);
-    else if (this->type_ == MT_short)
-        return ConvertValue(&this->value_.short_, mtm, defvalue.value_.short_);
-    else if (this->type_ == MT_ushort)
-        return ConvertValue(&this->value_.ushort_, mtm, defvalue.value_.ushort_);
-    else if (this->type_ == MT_long)
-        return ConvertValue(&this->value_.long_, mtm, defvalue.value_.long_);
-    else if (this->type_ == MT_ulong)
-        return ConvertValue(&this->value_.ulong_, mtm, defvalue.value_.ulong_);
-    else if (this->type_ == MT_float)
-        return ConvertValue(&this->value_.float_, mtm, defvalue.value_.float_);
-    else if (this->type_ == MT_double)
-        return ConvertValue(&this->value_.double_, mtm, defvalue.value_.double_);
-    else if (this->type_ == MT_longdouble)
-        return ConvertValue(&this->value_.longdouble_, mtm, defvalue.value_.longdouble_);
-    else if (this->type_ == MT_bool)
-        return ConvertValue(&this->value_.bool_, mtm, defvalue.value_.bool_);
-    else if (this->type_ == MT_constchar)
-        return ConvertValue(&this->string_, mtm, defvalue.string_);
-    else if (this->type_ == MT_string)
-        return ConvertValue(&this->string_, mtm, defvalue.string_);
-    else if (this->type_ == MT_vector2)
-        return ConvertValue(&this->vector2_, mtm, defvalue.vector2_);
-    else if (this->type_ == MT_vector3)
-        return ConvertValue(&this->vector3_, mtm, defvalue.vector3_);
-    else if (this->type_ == MT_vector4)
-        return ConvertValue(&this->vector4_, mtm, defvalue.vector4_);
-    else if (this->type_ == MT_colourvalue)
-        return ConvertValue(&this->colourvalue_, mtm, defvalue.colourvalue_);
-    else if (this->type_ == MT_quaternion)
-        return ConvertValue(&this->quaternion_, mtm, defvalue.quaternion_);
-    else if (this->type_ == MT_radian)
-        return ConvertValue(&this->radian_, mtm, defvalue.radian_);
-    else if (this->type_ == MT_degree)
-        return ConvertValue(&this->degree_, mtm, defvalue.degree_);
-    else
-        return false;
-}
-
-std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm)
-{
-    out << mtm.toString();
-    return out;
-}
Index: code/trunk/src/util/MultiTypeMath.h
===================================================================
--- code/trunk/src/util/MultiTypeMath.h	(revision 1740)
+++ 	(revision )
@@ -1,194 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- *   Inspiration: MultiType by Benjamin Grauer
- */
-
-#ifndef _MultiTypeMath_H__
-#define _MultiTypeMath_H__
-
-#include "UtilPrereqs.h"
-
-#include "MultiTypeString.h"
-#include "Math.h"
-
-// disable annoying warning about multiple assignment operators
-#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
-#pragma warning(push)
-#pragma warning(disable:4522)
-#endif
-
-class _UtilExport MultiTypeMath : public MultiTypeString
-{
-    public:
-        MultiTypeMath(MultiType type = MT_null);
-        inline MultiTypeMath(void*          value) : MultiTypeString(value) {}
-        inline MultiTypeMath(int            value) : MultiTypeString(value) {}
-        inline MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
-        inline MultiTypeMath(char           value) : MultiTypeString(value) {}
-        inline MultiTypeMath(unsigned char  value) : MultiTypeString(value) {}
-        inline MultiTypeMath(short          value) : MultiTypeString(value) {}
-        inline MultiTypeMath(unsigned short value) : MultiTypeString(value) {}
-        inline MultiTypeMath(long           value) : MultiTypeString(value) {}
-        inline MultiTypeMath(unsigned long  value) : MultiTypeString(value) {}
-        inline MultiTypeMath(float          value) : MultiTypeString(value) {}
-        inline MultiTypeMath(double         value) : MultiTypeString(value) {}
-        inline MultiTypeMath(long double    value) : MultiTypeString(value) {}
-        inline MultiTypeMath(bool           value) : MultiTypeString(value) {}
-        inline MultiTypeMath(const char*             value) : MultiTypeString(value) {}
-        inline MultiTypeMath(const std::string&      value) : MultiTypeString(value) {}
-        inline MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
-        inline MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
-        inline MultiTypeMath(const orxonox::Vector4&     value) { this->setValue(value); }
-        inline MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }
-        inline MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }
-        inline MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }
-        inline MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
-        inline MultiTypeMath(const MultiTypeMath& mtm)          { this->setValue(mtm);   }
-        inline MultiTypeMath(const MultiTypeString& mts)        { this->setValue(mts);   }
-        inline MultiTypeMath(const MultiTypePrimitive& mtp)     { this->setValue(mtp);   }
-        virtual inline ~MultiTypeMath() {}
-
-        using MultiTypeString::operator=;
-        inline MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const orxonox::Vector4&     value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
-        inline MultiTypeMath& operator=(const MultiTypeMath& mtm)          { this->setValue(mtm);   return *this; }
-        inline MultiTypeMath& operator=(const MultiTypeString& mts)        { this->setValue(mts);   return *this; }
-        inline MultiTypeMath& operator=(const MultiTypePrimitive mtp)      { this->setValue(mtp);   return *this; }
-
-        using MultiTypeString::operator==;
-        inline bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }
-        inline bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }
-        inline bool operator==(const orxonox::Vector4&     value) const { return (this->vector4_     == value); }
-        inline bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }
-        inline bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }
-        inline bool operator==(const orxonox::Radian&      value) const { return (this->radian_      == value); }
-        inline bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }
-        bool operator==(const MultiTypeMath& mtm) const;
-        bool operator==(const MultiTypeString& mts) const;
-        bool operator==(const MultiTypePrimitive& mtp) const;
-
-        using MultiTypeString::operator!=;
-        inline bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }
-        inline bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }
-        inline bool operator!=(const orxonox::Vector4&     value) const { return (this->vector4_     != value); }
-        inline bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }
-        inline bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }
-        inline bool operator!=(const orxonox::Radian&      value) const { return (this->radian_      != value); }
-        inline bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }
-        bool operator!=(const MultiTypeMath& mtm) const;
-        bool operator!=(const MultiTypeString& mts) const;
-        bool operator!=(const MultiTypePrimitive& mtp) const;
-
-        virtual operator void*()                const;
-        virtual operator int()                  const;
-        virtual operator unsigned int()         const;
-        virtual operator char()                 const;
-        virtual operator unsigned char()        const;
-        virtual operator short()                const;
-        virtual operator unsigned short()       const;
-        virtual operator long()                 const;
-        virtual operator unsigned long()        const;
-        virtual operator float ()               const;
-        virtual operator double ()              const;
-        virtual operator long double()          const;
-        virtual operator bool()                 const;
-        virtual operator std::string()          const;
-        virtual operator const char*()          const;
-        virtual operator orxonox::Vector2()     const;
-        virtual operator orxonox::Vector3()     const;
-        virtual operator orxonox::Vector4()     const;
-        virtual operator orxonox::ColourValue() const;
-        virtual operator orxonox::Quaternion()  const;
-        virtual operator orxonox::Radian()      const;
-        virtual operator orxonox::Degree()      const;
-
-        using MultiTypeString::setValue;
-        inline void setValue(const orxonox::Vector2&     value) { this->type_ = MT_vector2;     this->vector2_     = value; }
-        inline void setValue(const orxonox::Vector3&     value) { this->type_ = MT_vector3;     this->vector3_     = value; }
-        inline void setValue(const orxonox::Vector4&     value) { this->type_ = MT_vector4;     this->vector4_     = value; }
-        inline void setValue(const orxonox::ColourValue& value) { this->type_ = MT_colourvalue; this->colourvalue_ = value; }
-        inline void setValue(const orxonox::Quaternion&  value) { this->type_ = MT_quaternion;  this->quaternion_  = value; }
-        inline void setValue(const orxonox::Radian&      value) { this->type_ = MT_radian;      this->radian_      = value; }
-        inline void setValue(const orxonox::Degree&      value) { this->type_ = MT_degree;      this->degree_      = value; }
-        void setValue(const MultiTypeMath& mtm);
-        void setValue(const MultiTypeString& mts);
-        void setValue(const MultiTypePrimitive& mtp);
-
-        inline orxonox::Vector2     getVector2()     const { return this->vector2_;     }
-        inline orxonox::Vector3     getVector3()     const { return this->vector3_;     }
-        inline orxonox::Vector4     getVector4()     const { return this->vector4_;     }
-        inline orxonox::ColourValue getColourValue() const { return this->colourvalue_; }
-        inline orxonox::Quaternion  getQuaternion()  const { return this->quaternion_;  }
-        inline orxonox::Radian      getRadian()      const { return this->radian_;      }
-        inline orxonox::Degree      getDegree()      const { return this->degree_;      }
-
-        inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
-        inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }
-        inline orxonox::Vector4&     getVector4()     { return this->vector4_;     }
-        inline orxonox::ColourValue& getColourValue() { return this->colourvalue_; }
-        inline orxonox::Quaternion&  getQuaternion()  { return this->quaternion_;  }
-        inline orxonox::Radian&      getRadian()      { return this->radian_;      }
-        inline orxonox::Degree&      getDegree()      { return this->degree_;      }
-
-        using MultiTypeString::getValue;
-        inline void getValue(orxonox::Vector2*     variable) const { (*variable) = orxonox::Vector2     (this->vector2_);     }
-        inline void getValue(orxonox::Vector3*     variable) const { (*variable) = orxonox::Vector3     (this->vector3_);     }
-        inline void getValue(orxonox::Vector4*     variable) const { (*variable) = orxonox::Vector4     (this->vector4_);     }
-        inline void getValue(orxonox::ColourValue* variable) const { (*variable) = orxonox::ColourValue (this->colourvalue_); }
-        inline void getValue(orxonox::Quaternion*  variable) const { (*variable) = orxonox::Quaternion  (this->quaternion_);  }
-        inline void getValue(orxonox::Radian*      variable) const { (*variable) = orxonox::Radian      (this->radian_);      }
-        inline void getValue(orxonox::Degree*      variable) const { (*variable) = orxonox::Degree      (this->degree_);      }
-
-        virtual std::string getTypename() const;
-
-        virtual std::string toString() const;
-        virtual bool fromString(const std::string value);
-
-        virtual bool assimilate(const MultiTypeMath& mtm, const MultiTypeMath& defvalue = MultiTypeMath());
-
-    protected:
-        orxonox::Vector2      vector2_;
-        orxonox::Vector3      vector3_;
-        orxonox::Vector4      vector4_;
-        orxonox::ColourValue  colourvalue_;
-        orxonox::Quaternion   quaternion_;
-        orxonox::Radian       radian_;
-        orxonox::Degree       degree_;
-};
-
-_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);
-
-#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
-#pragma warning(pop)
-#endif
-
-#endif /* _MultiTypeMath_H__ */
Index: code/trunk/src/util/MultiTypePrimitive.cc
===================================================================
--- code/trunk/src/util/MultiTypePrimitive.cc	(revision 1740)
+++ 	(revision )
@@ -1,305 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- *   Inspiration: MultiType by Benjamin Grauer
- */
-
-#include "MultiTypePrimitive.h"
-#include "Convert.h"
-
-MultiTypePrimitive::MultiTypePrimitive(MultiType type)
-{
-    this->type_ = type;
-
-    if (type == MT_void)
-        this->value_.void_ = 0;
-    else if (type == MT_int)
-        this->value_.int_ = 0;
-    else if (type == MT_uint)
-        this->value_.uint_ = 0;
-    else if (type == MT_char)
-        this->value_.char_ = 0;
-    else if (type == MT_uchar)
-        this->value_.uchar_ = 0;
-    else if (type == MT_short)
-        this->value_.short_ = 0;
-    else if (type == MT_ushort)
-        this->value_.ushort_ = 0;
-    else if (type == MT_long)
-        this->value_.long_ = 0;
-    else if (type == MT_ulong)
-        this->value_.ulong_ = 0;
-    else if (type == MT_float)
-        this->value_.float_ = 0.0;
-    else if (type == MT_double)
-        this->value_.double_ = 0.0;
-    else if (type == MT_longdouble)
-        this->value_.longdouble_ = 0.0;
-    else if (type == MT_bool)
-        this->value_.bool_ = false;
-    else
-        this->value_.void_ = 0;
-}
-
-bool MultiTypePrimitive::operator==(const MultiTypePrimitive& mtp) const
-{
-    if (this->type_ == mtp.type_)
-    {
-        if (this->type_ == MT_void)
-            return (this->value_.void_ == mtp.value_.void_);
-        else if (this->type_ == MT_int)
-            return (this->value_.int_ == mtp.value_.int_);
-        else if (this->type_ == MT_uint)
-            return (this->value_.uint_ == mtp.value_.uint_);
-        else if (this->type_ == MT_char)
-            return (this->value_.char_ == mtp.value_.char_);
-        else if (this->type_ == MT_uchar)
-            return (this->value_.uchar_ == mtp.value_.uchar_);
-        else if (this->type_ == MT_short)
-            return (this->value_.short_ == mtp.value_.short_);
-        else if (this->type_ == MT_ushort)
-            return (this->value_.ushort_ == mtp.value_.ushort_);
-        else if (this->type_ == MT_long)
-            return (this->value_.long_ == mtp.value_.long_);
-        else if (this->type_ == MT_ulong)
-            return (this->value_.ulong_ == mtp.value_.ulong_);
-        else if (this->type_ == MT_float)
-            return (this->value_.float_ == mtp.value_.float_);
-        else if (this->type_ == MT_double)
-            return (this->value_.double_ == mtp.value_.double_);
-        else if (this->type_ == MT_longdouble)
-            return (this->value_.longdouble_ == mtp.value_.longdouble_);
-        else if (this->type_ == MT_bool)
-            return (this->value_.bool_ == mtp.value_.bool_);
-    }
-
-    return false;
-}
-
-bool MultiTypePrimitive::operator!=(const MultiTypePrimitive& mtp) const
-{
-    if (this->type_ == mtp.type_)
-    {
-        if (this->type_ == MT_void)
-            return (this->value_.void_ != mtp.value_.void_);
-        else if (this->type_ == MT_int)
-            return (this->value_.int_ != mtp.value_.int_);
-        else if (this->type_ == MT_uint)
-            return (this->value_.uint_ != mtp.value_.uint_);
-        else if (this->type_ == MT_char)
-            return (this->value_.char_ != mtp.value_.char_);
-        else if (this->type_ == MT_uchar)
-            return (this->value_.uchar_ != mtp.value_.uchar_);
-        else if (this->type_ == MT_short)
-            return (this->value_.short_ != mtp.value_.short_);
-        else if (this->type_ == MT_ushort)
-            return (this->value_.ushort_ != mtp.value_.ushort_);
-        else if (this->type_ == MT_long)
-            return (this->value_.long_ != mtp.value_.long_);
-        else if (this->type_ == MT_ulong)
-            return (this->value_.ulong_ != mtp.value_.ulong_);
-        else if (this->type_ == MT_float)
-            return (this->value_.float_ != mtp.value_.float_);
-        else if (this->type_ == MT_double)
-            return (this->value_.double_ != mtp.value_.double_);
-        else if (this->type_ == MT_longdouble)
-            return (this->value_.longdouble_ != mtp.value_.longdouble_);
-        else if (this->type_ == MT_bool)
-            return (this->value_.bool_ != mtp.value_.bool_);
-    }
-
-    return true;
-}
-
-MultiTypePrimitive::operator void*() const
-{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypePrimitive, void*>(*this, 0); }
-MultiTypePrimitive::operator int() const
-{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypePrimitive, int>(*this, 0); }
-MultiTypePrimitive::operator unsigned int() const
-{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypePrimitive, unsigned int>(*this, 0); }
-MultiTypePrimitive::operator char() const
-{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypePrimitive, char>(*this, 0); }
-MultiTypePrimitive::operator unsigned char() const
-{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypePrimitive, unsigned char>(*this, 0); }
-MultiTypePrimitive::operator short() const
-{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypePrimitive, short>(*this, 0); }
-MultiTypePrimitive::operator unsigned short() const
-{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypePrimitive, unsigned short>(*this, 0); }
-MultiTypePrimitive::operator long() const
-{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypePrimitive, long>(*this, 0); }
-MultiTypePrimitive::operator unsigned long() const
-{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypePrimitive, unsigned long>(*this, 0); }
-MultiTypePrimitive::operator float() const
-{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypePrimitive, float>(*this, 0); }
-MultiTypePrimitive::operator double() const
-{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypePrimitive, double>(*this, 0); }
-MultiTypePrimitive::operator long double() const
-{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypePrimitive, long double>(*this, 0); }
-MultiTypePrimitive::operator bool() const
-{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypePrimitive, bool>(*this, 0); }
-
-void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
-{
-    this->type_ = mtp.type_;
-    this->value_ = mtp.value_;
-}
-
-std::string MultiTypePrimitive::getTypename() const
-{
-    if (this->type_ == MT_void)
-        return "pointer";
-    else if (this->type_ == MT_int)
-        return "int";
-    else if (this->type_ == MT_uint)
-        return "unsigned int";
-    else if (this->type_ == MT_char)
-        return "char";
-    else if (this->type_ == MT_uchar)
-        return "unsigned char";
-    else if (this->type_ == MT_short)
-        return "short";
-    else if (this->type_ == MT_ushort)
-        return "unsigned short";
-    else if (this->type_ == MT_long)
-        return "long";
-    else if (this->type_ == MT_ulong)
-        return "unsigned long";
-    else if (this->type_ == MT_float)
-        return "float";
-    else if (this->type_ == MT_double)
-        return "double";
-    else if (this->type_ == MT_longdouble)
-        return "long double";
-    else if (this->type_ == MT_bool)
-        return "bool";
-    else
-        return "unknown";
-}
-
-std::string MultiTypePrimitive::toString() const
-{
-    std::string output;
-
-    if (this->type_ == MT_void)
-        ConvertValue(&output, this->value_.void_);
-    else if (this->type_ == MT_int)
-        ConvertValue(&output, this->value_.int_);
-    else if (this->type_ == MT_uint)
-        ConvertValue(&output, this->value_.uint_);
-    else if (this->type_ == MT_char)
-        ConvertValue(&output, this->value_.char_);
-    else if (this->type_ == MT_uchar)
-        ConvertValue(&output, this->value_.uchar_);
-    else if (this->type_ == MT_short)
-        ConvertValue(&output, this->value_.short_);
-    else if (this->type_ == MT_ushort)
-        ConvertValue(&output, this->value_.ushort_);
-    else if (this->type_ == MT_long)
-        ConvertValue(&output, this->value_.long_);
-    else if (this->type_ == MT_ulong)
-        ConvertValue(&output, this->value_.ulong_);
-    else if (this->type_ == MT_float)
-        ConvertValue(&output, this->value_.float_);
-    else if (this->type_ == MT_double)
-        ConvertValue(&output, this->value_.double_);
-    else if (this->type_ == MT_longdouble)
-        ConvertValue(&output, this->value_.longdouble_);
-    else if (this->type_ == MT_bool)
-        ConvertValue(&output, this->value_.bool_);
-
-    return output;
-}
-
-bool MultiTypePrimitive::fromString(const std::string value)
-{
-    if (this->type_ == MT_void)
-        return ConvertValue(&this->value_.void_, value, (void*)0);
-    else if (this->type_ == MT_int)
-        return ConvertValue(&this->value_.int_, value, (int)0);
-    else if (this->type_ == MT_uint)
-        return ConvertValue(&this->value_.uint_, value, (unsigned int)0);
-    else if (this->type_ == MT_char)
-        return ConvertValue(&this->value_.char_, value, (char)0);
-    else if (this->type_ == MT_uchar)
-        return ConvertValue(&this->value_.uchar_, value, (unsigned char)0);
-    else if (this->type_ == MT_short)
-        return ConvertValue(&this->value_.short_, value, (short)0);
-    else if (this->type_ == MT_ushort)
-        return ConvertValue(&this->value_.ushort_, value, (unsigned short)0);
-    else if (this->type_ == MT_long)
-        return ConvertValue(&this->value_.long_, value, (long)0);
-    else if (this->type_ == MT_ulong)
-        return ConvertValue(&this->value_.ulong_, value, (unsigned long)0);
-    else if (this->type_ == MT_float)
-        return ConvertValue(&this->value_.float_, value, (float)0.0);
-    else if (this->type_ == MT_double)
-        return ConvertValue(&this->value_.double_, value, (double)0.0);
-    else if (this->type_ == MT_longdouble)
-        return ConvertValue(&this->value_.longdouble_, value, (long double)0.0);
-    else if (this->type_ == MT_bool)
-        return ConvertValue(&this->value_.bool_, value, false);
-    else
-        return false;
-}
-
-bool MultiTypePrimitive::assimilate(const MultiTypePrimitive& mtp, const MultiTypePrimitive& defvalue)
-{
-    if (this->type_ == MT_void)
-        return ConvertValue(&this->value_.void_, mtp, defvalue.value_.void_);
-    else if (this->type_ == MT_int)
-        return ConvertValue(&this->value_.int_, mtp, defvalue.value_.int_);
-    else if (this->type_ == MT_uint)
-        return ConvertValue(&this->value_.uint_, mtp, defvalue.value_.uint_);
-    else if (this->type_ == MT_char)
-        return ConvertValue(&this->value_.char_, mtp, defvalue.value_.char_);
-    else if (this->type_ == MT_uchar)
-        return ConvertValue(&this->value_.uchar_, mtp, defvalue.value_.uchar_);
-    else if (this->type_ == MT_short)
-        return ConvertValue(&this->value_.short_, mtp, defvalue.value_.short_);
-    else if (this->type_ == MT_ushort)
-        return ConvertValue(&this->value_.ushort_, mtp, defvalue.value_.ushort_);
-    else if (this->type_ == MT_long)
-        return ConvertValue(&this->value_.long_, mtp, defvalue.value_.long_);
-    else if (this->type_ == MT_ulong)
-        return ConvertValue(&this->value_.ulong_, mtp, defvalue.value_.ulong_);
-    else if (this->type_ == MT_float)
-        return ConvertValue(&this->value_.float_, mtp, defvalue.value_.float_);
-    else if (this->type_ == MT_double)
-        return ConvertValue(&this->value_.double_, mtp, defvalue.value_.double_);
-    else if (this->type_ == MT_longdouble)
-        return ConvertValue(&this->value_.longdouble_, mtp, defvalue.value_.longdouble_);
-    else if (this->type_ == MT_bool)
-        return ConvertValue(&this->value_.bool_, mtp, defvalue.value_.bool_);
-    else
-        return false;
-
-}
-
-std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp)
-{
-    out << mtp.toString();
-    return out;
-}
Index: code/trunk/src/util/MultiTypePrimitive.h
===================================================================
--- code/trunk/src/util/MultiTypePrimitive.h	(revision 1740)
+++ 	(revision )
@@ -1,198 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- *   Inspiration: MultiType by Benjamin Grauer
- */
-
-#ifndef _MultiTypePrimitive_H__
-#define _MultiTypePrimitive_H__
-
-#include "UtilPrereqs.h"
-
-#include <ostream>
-
-#include "MultiType.h"
-
-namespace orxonox
-{
-    class BaseObject;
-}
-class _UtilExport MultiTypePrimitive
-{
-    public:
-        MultiTypePrimitive(MultiType type = MT_null);
-        inline MultiTypePrimitive(void*          value) { this->setValue(value); }
-        inline MultiTypePrimitive(int            value) { this->setValue(value); }
-        inline MultiTypePrimitive(unsigned int   value) { this->setValue(value); }
-        inline MultiTypePrimitive(char           value) { this->setValue(value); }
-        inline MultiTypePrimitive(unsigned char  value) { this->setValue(value); }
-        inline MultiTypePrimitive(short          value) { this->setValue(value); }
-        inline MultiTypePrimitive(unsigned short value) { this->setValue(value); }
-        inline MultiTypePrimitive(long           value) { this->setValue(value); }
-        inline MultiTypePrimitive(unsigned long  value) { this->setValue(value); }
-        inline MultiTypePrimitive(float          value) { this->setValue(value); }
-        inline MultiTypePrimitive(double         value) { this->setValue(value); }
-        inline MultiTypePrimitive(long double    value) { this->setValue(value); }
-        inline MultiTypePrimitive(bool           value) { this->setValue(value); }
-        inline MultiTypePrimitive(const MultiTypePrimitive& mtp) { this->setValue(mtp); }
-        virtual inline ~MultiTypePrimitive() {}
-
-        inline MultiTypePrimitive& operator=(MultiType      value) { this->type_ = MT_null; return *this; }
-        inline MultiTypePrimitive& operator=(void*          value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(int            value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(unsigned int   value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(char           value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(unsigned char  value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(short          value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(unsigned short value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(long           value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(unsigned long  value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(float          value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(double         value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(long double    value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(bool           value) { this->setValue(value); return *this; }
-        inline MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp); return *this; }
-
-        inline bool operator==(void*          value) const { return (this->value_.void_       == value); }
-        inline bool operator==(int            value) const { return (this->value_.int_        == value); }
-        inline bool operator==(unsigned int   value) const { return (this->value_.uint_       == value); }
-        inline bool operator==(char           value) const { return (this->value_.char_       == value); }
-        inline bool operator==(unsigned char  value) const { return (this->value_.uchar_      == value); }
-        inline bool operator==(short          value) const { return (this->value_.short_      == value); }
-        inline bool operator==(unsigned short value) const { return (this->value_.ushort_     == value); }
-        inline bool operator==(long           value) const { return (this->value_.long_       == value); }
-        inline bool operator==(unsigned long  value) const { return (this->value_.ulong_      == value); }
-        inline bool operator==(float          value) const { return (this->value_.float_      == value); }
-        inline bool operator==(double         value) const { return (this->value_.double_     == value); }
-        inline bool operator==(long double    value) const { return (this->value_.longdouble_ == value); }
-        inline bool operator==(bool           value) const { return (this->value_.bool_       == value); }
-        bool operator==(const MultiTypePrimitive& mtp) const;
-
-        inline bool operator!=(void*          value) const { return (this->value_.void_       != value); }
-        inline bool operator!=(unsigned int   value) const { return (this->value_.uint_       != value); }
-        inline bool operator!=(char           value) const { return (this->value_.char_       != value); }
-        inline bool operator!=(unsigned char  value) const { return (this->value_.uchar_      != value); }
-        inline bool operator!=(short          value) const { return (this->value_.short_      != value); }
-        inline bool operator!=(unsigned short value) const { return (this->value_.ushort_     != value); }
-        inline bool operator!=(long           value) const { return (this->value_.long_       != value); }
-        inline bool operator!=(unsigned long  value) const { return (this->value_.ulong_      != value); }
-        inline bool operator!=(float          value) const { return (this->value_.float_      != value); }
-        inline bool operator!=(double         value) const { return (this->value_.double_     != value); }
-        inline bool operator!=(long double    value) const { return (this->value_.longdouble_ != value); }
-        inline bool operator!=(bool           value) const { return (this->value_.bool_       != value); }
-        bool operator!=(const MultiTypePrimitive& mtp) const;
-
-        template <class T>
-        operator T*()                     const
-        { return ((T*)this->value_.void_); }
-        virtual operator void*()          const;
-        virtual operator int()            const;
-        virtual operator unsigned int()   const;
-        virtual operator char()           const;
-        virtual operator unsigned char()  const;
-        virtual operator short()          const;
-        virtual operator unsigned short() const;
-        virtual operator long()           const;
-        virtual operator unsigned long()  const;
-        virtual operator float ()         const;
-        virtual operator double ()        const;
-        virtual operator long double()    const;
-        virtual operator bool()           const;
-
-        inline void setValue(void*          value) { this->type_ = MT_void;       this->value_.void_       = value; }
-        inline void setValue(int            value) { this->type_ = MT_int;        this->value_.int_        = value; }
-        inline void setValue(unsigned int   value) { this->type_ = MT_uint;       this->value_.uint_       = value; }
-        inline void setValue(char           value) { this->type_ = MT_char;       this->value_.char_       = value; }
-        inline void setValue(unsigned char  value) { this->type_ = MT_uchar;      this->value_.uchar_      = value; }
-        inline void setValue(short          value) { this->type_ = MT_short;      this->value_.short_      = value; }
-        inline void setValue(unsigned short value) { this->type_ = MT_ushort;     this->value_.ushort_     = value; }
-        inline void setValue(long           value) { this->type_ = MT_long;       this->value_.long_       = value; }
-        inline void setValue(unsigned long  value) { this->type_ = MT_ulong;      this->value_.ulong_      = value; }
-        inline void setValue(float          value) { this->type_ = MT_float;      this->value_.float_      = value; }
-        inline void setValue(double         value) { this->type_ = MT_double;     this->value_.double_     = value; }
-        inline void setValue(long double    value) { this->type_ = MT_longdouble; this->value_.longdouble_ = value; }
-        inline void setValue(bool           value) { this->type_ = MT_bool;       this->value_.bool_       = value; }
-        void setValue(const MultiTypePrimitive& mtp);
-
-        inline void*          getVoid()          const { return this->value_.void_;       }
-        inline int            getInt()           const { return this->value_.int_;        }
-        inline unsigned int   getUnsignedInt()   const { return this->value_.uint_;       }
-        inline char           getChar()          const { return this->value_.char_;       }
-        inline unsigned char  getUnsignedChar()  const { return this->value_.uchar_;      }
-        inline short          getShort()         const { return this->value_.short_;      }
-        inline unsigned short getUnsignedShort() const { return this->value_.ushort_;     }
-        inline long           getLong()          const { return this->value_.long_;       }
-        inline unsigned long  getUnsignedLong()  const { return this->value_.ulong_;      }
-        inline float          getFloat()         const { return this->value_.float_;      }
-        inline double         getDouble()        const { return this->value_.double_;     }
-        inline long double    getLongDouble()    const { return this->value_.longdouble_; }
-        inline bool           getBool()          const { return this->value_.bool_;       }
-
-        inline int&            getInt()           { return this->value_.int_;        }
-        inline unsigned int&   getUnsignedInt()   { return this->value_.uint_;       }
-        inline char&           getChar()          { return this->value_.char_;       }
-        inline unsigned char&  getUnsignedChar()  { return this->value_.uchar_;      }
-        inline short&          getShort()         { return this->value_.short_;      }
-        inline unsigned short& getUnsignedShort() { return this->value_.ushort_;     }
-        inline long&           getLong()          { return this->value_.long_;       }
-        inline unsigned long&  getUnsignedLong()  { return this->value_.ulong_;      }
-        inline float&          getFloat()         { return this->value_.float_;      }
-        inline double&         getDouble()        { return this->value_.double_;     }
-        inline long double&    getLongDouble()    { return this->value_.longdouble_; }
-        inline bool&           getBool()          { return this->value_.bool_;       }
-
-        inline void getValue(void*           variable) const { variable    = this->value_.void_;       }
-        inline void getValue(int*            variable) const { (*variable) = this->value_.int_;        }
-        inline void getValue(unsigned int*   variable) const { (*variable) = this->value_.uint_;       }
-        inline void getValue(char*           variable) const { (*variable) = this->value_.char_;       }
-        inline void getValue(unsigned char*  variable) const { (*variable) = this->value_.uchar_;      }
-        inline void getValue(short*          variable) const { (*variable) = this->value_.short_;      }
-        inline void getValue(unsigned short* variable) const { (*variable) = this->value_.ushort_;     }
-        inline void getValue(long*           variable) const { (*variable) = this->value_.long_;       }
-        inline void getValue(unsigned long*  variable) const { (*variable) = this->value_.ulong_;      }
-        inline void getValue(float*          variable) const { (*variable) = this->value_.float_;      }
-        inline void getValue(double*         variable) const { (*variable) = this->value_.double_;     }
-        inline void getValue(long double*    variable) const { (*variable) = this->value_.longdouble_; }
-        inline void getValue(bool*           variable) const { (*variable) = this->value_.bool_;       }
-
-        inline MultiType getType()           const { return this->type_; }
-        inline bool      isA(MultiType type) const { return (this->type_ == type); }
-
-        virtual std::string getTypename() const;
-
-        virtual std::string toString() const;
-        virtual bool fromString(const std::string value);
-
-        virtual bool assimilate(const MultiTypePrimitive& mtp, const MultiTypePrimitive& defvalue = MultiTypePrimitive());
-
-    protected:
-        MultiTypeValue  value_;
-        MultiType       type_;
-};
-
-_UtilExport std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp);
-
-#endif /* _MultiTypePrimitive_H__ */
Index: code/trunk/src/util/MultiTypeString.cc
===================================================================
--- code/trunk/src/util/MultiTypeString.cc	(revision 1740)
+++ 	(revision )
@@ -1,193 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- *   Inspiration: MultiType by Benjamin Grauer
- */
-
-#include "MultiTypeString.h"
-#include "Convert.h"
-
-MultiTypeString::MultiTypeString(MultiType type) : MultiTypePrimitive(type)
-{
-    // Nothing to do for string
-}
-
-bool MultiTypeString::operator==(const MultiTypeString& mts) const
-{
-    if (!MultiTypePrimitive::operator==(mts) && this->type_ == mts.type_)
-    {
-        if (this->type_ == MT_constchar)
-            return (this->string_ == mts.string_);
-        else if (this->type_ == MT_string)
-            return (this->string_ == mts.string_);
-    }
-
-    return false;
-}
-
-bool MultiTypeString::operator==(const MultiTypePrimitive& mtp) const
-{
-    return MultiTypePrimitive::operator==(mtp);
-}
-
-bool MultiTypeString::operator!=(const MultiTypeString& mts) const
-{
-    if (MultiTypePrimitive::operator==(mts) && this->type_ == mts.type_)
-    {
-        if (this->type_ == MT_constchar)
-            return (this->string_ != mts.string_);
-        else if (this->type_ == MT_string)
-            return (this->string_ != mts.string_);
-    }
-
-    return true;
-}
-
-bool MultiTypeString::operator!=(const MultiTypePrimitive& mtp) const
-{
-    return MultiTypePrimitive::operator!=(mtp);
-}
-
-MultiTypeString::operator void*() const
-{ return (this->type_ == MT_void) ? this->value_.void_ : getConvertedValue<MultiTypeString, void*>(*this, 0); }
-MultiTypeString::operator int() const
-{ return (this->type_ == MT_int) ? this->value_.int_ : getConvertedValue<MultiTypeString, int>(*this, 0); }
-MultiTypeString::operator unsigned int() const
-{ return (this->type_ == MT_uint) ? this->value_.uint_ : getConvertedValue<MultiTypeString, unsigned int>(*this, 0); }
-MultiTypeString::operator char() const
-{ return (this->type_ == MT_char) ? this->value_.char_ : getConvertedValue<MultiTypeString, char>(*this, 0); }
-MultiTypeString::operator unsigned char() const
-{ return (this->type_ == MT_uchar) ? this->value_.uchar_ : getConvertedValue<MultiTypeString, unsigned char>(*this, 0); }
-MultiTypeString::operator short() const
-{ return (this->type_ == MT_short) ? this->value_.short_ : getConvertedValue<MultiTypeString, short>(*this, 0); }
-MultiTypeString::operator unsigned short() const
-{ return (this->type_ == MT_ushort) ? this->value_.ushort_ : getConvertedValue<MultiTypeString, unsigned short>(*this, 0); }
-MultiTypeString::operator long() const
-{ return (this->type_ == MT_long) ? this->value_.long_ : getConvertedValue<MultiTypeString, long>(*this, 0); }
-MultiTypeString::operator unsigned long() const
-{ return (this->type_ == MT_ulong) ? this->value_.ulong_ : getConvertedValue<MultiTypeString, unsigned long>(*this, 0); }
-MultiTypeString::operator float() const
-{ return (this->type_ == MT_float) ? this->value_.float_ : getConvertedValue<MultiTypeString, float>(*this, 0); }
-MultiTypeString::operator double() const
-{ return (this->type_ == MT_double) ? this->value_.double_ : getConvertedValue<MultiTypeString, double>(*this, 0); }
-MultiTypeString::operator long double() const
-{ return (this->type_ == MT_longdouble) ? this->value_.longdouble_ : getConvertedValue<MultiTypeString, long double>(*this, 0); }
-MultiTypeString::operator bool() const
-{ return (this->type_ == MT_bool) ? this->value_.bool_ : getConvertedValue<MultiTypeString, bool>(*this, 0); }
-MultiTypeString::operator std::string() const
-{ return (this->type_ == MT_string) ? this->string_ : getConvertedValue<MultiTypeString, std::string>(*this); }
-MultiTypeString::operator const char*() const
-{ return ((this->type_ == MT_constchar) ? this->string_ : getConvertedValue<MultiTypeString, std::string>(*this)).c_str(); }
-
-void MultiTypeString::setValue(const MultiTypeString& mts)
-{
-    MultiTypePrimitive::setValue(mts);
-    this->string_ = mts.string_;
-}
-
-void MultiTypeString::setValue(const MultiTypePrimitive& mtp)
-{
-    MultiTypePrimitive::setValue(mtp);
-}
-
-std::string MultiTypeString::getTypename() const
-{
-    if (this->type_ == MT_constchar)
-        return "string";
-    else if (this->type_ == MT_string)
-        return "string";
-    else
-        return MultiTypePrimitive::getTypename();
-}
-
-std::string MultiTypeString::toString() const
-{
-    std::string output;
-
-    if (this->type_ == MT_constchar)
-        return this->string_;
-    else if (this->type_ == MT_string)
-        return this->string_;
-    else
-        return MultiTypePrimitive::toString();
-
-    // FIXME: unreachable code
-    // return output;
-}
-
-bool MultiTypeString::fromString(const std::string value)
-{
-    if (this->type_ == MT_constchar)
-        this->string_ = value;
-    else if (this->type_ == MT_string)
-        this->string_ = value;
-    else
-        return MultiTypePrimitive::fromString(value);
-
-    return true;
-}
-
-bool MultiTypeString::assimilate(const MultiTypeString& mts, const MultiTypeString& defvalue)
-{
-    if (this->type_ == MT_void)
-        return ConvertValue(&this->value_.void_, mts, defvalue.value_.void_);
-    else if (this->type_ == MT_int)
-        return ConvertValue(&this->value_.int_, mts, defvalue.value_.int_);
-    else if (this->type_ == MT_uint)
-        return ConvertValue(&this->value_.uint_, mts, defvalue.value_.uint_);
-    else if (this->type_ == MT_char)
-        return ConvertValue(&this->value_.char_, mts, defvalue.value_.char_);
-    else if (this->type_ == MT_uchar)
-        return ConvertValue(&this->value_.uchar_, mts, defvalue.value_.uchar_);
-    else if (this->type_ == MT_short)
-        return ConvertValue(&this->value_.short_, mts, defvalue.value_.short_);
-    else if (this->type_ == MT_ushort)
-        return ConvertValue(&this->value_.ushort_, mts, defvalue.value_.ushort_);
-    else if (this->type_ == MT_long)
-        return ConvertValue(&this->value_.long_, mts, defvalue.value_.long_);
-    else if (this->type_ == MT_ulong)
-        return ConvertValue(&this->value_.ulong_, mts, defvalue.value_.ulong_);
-    else if (this->type_ == MT_float)
-        return ConvertValue(&this->value_.float_, mts, defvalue.value_.float_);
-    else if (this->type_ == MT_double)
-        return ConvertValue(&this->value_.double_, mts, defvalue.value_.double_);
-    else if (this->type_ == MT_longdouble)
-        return ConvertValue(&this->value_.longdouble_, mts, defvalue.value_.longdouble_);
-    else if (this->type_ == MT_bool)
-        return ConvertValue(&this->value_.bool_, mts, defvalue.value_.bool_);
-    else if (this->type_ == MT_constchar)
-        return ConvertValue(&this->string_, mts, defvalue.string_);
-    else if (this->type_ == MT_string)
-        return ConvertValue(&this->string_, mts, defvalue.string_);
-    else
-        return false;
-}
-
-std::ostream& operator<<(std::ostream& out, MultiTypeString& mts)
-{
-    out << mts.toString();
-    return out;
-}
Index: code/trunk/src/util/MultiTypeString.h
===================================================================
--- code/trunk/src/util/MultiTypeString.h	(revision 1740)
+++ 	(revision )
@@ -1,136 +1,0 @@
-/*
- *   ORXONOX - the hottest 3D action shooter ever to exist
- *                    > www.orxonox.net <
- *
- *
- *   License notice:
- *
- *   This program is free software; you can redistribute it and/or
- *   modify it under the terms of the GNU General Public License
- *   as published by the Free Software Foundation; either version 2
- *   of the License, or (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- *   Author:
- *      Fabian 'x3n' Landau
- *   Co-authors:
- *      ...
- *
- *   Inspiration: MultiType by Benjamin Grauer
- */
-
-#ifndef _MultiTypeString_H__
-#define _MultiTypeString_H__
-
-#include "UtilPrereqs.h"
-
-#include <string>
-#include <iostream>
-
-#include "MultiTypePrimitive.h"
-
-// disable annoying warning about multiple assignment operators
-#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
-#pragma warning(push)
-#pragma warning(disable:4522)
-#endif
-
-class _UtilExport MultiTypeString : public MultiTypePrimitive
-{
-    public:
-        MultiTypeString(MultiType type = MT_null);
-        inline MultiTypeString(void*          value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(int            value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(char           value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(unsigned char  value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(short          value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(unsigned short value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(long           value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(unsigned long  value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(float          value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(double         value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
-        inline MultiTypeString(const char*             value) { this->setValue(value); }
-        inline MultiTypeString(const std::string&      value) { this->setValue(value); }
-        inline MultiTypeString(const MultiTypeString&    mts)  { this->setValue(mts);   }
-        inline MultiTypeString(const MultiTypePrimitive& mtp)  { this->setValue(mtp);   }
-        virtual inline ~MultiTypeString() {}
-
-        using MultiTypePrimitive::operator=;
-        inline MultiTypeString& operator=(const char*             value) { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const std::string&      value) { this->setValue(value); return *this; }
-        inline MultiTypeString& operator=(const MultiTypeString&    mts) { this->setValue(mts);   return *this; }
-        inline MultiTypeString& operator=(const MultiTypePrimitive& mtp) { this->setValue(mtp);   return *this; }
-
-        using MultiTypePrimitive::operator==;
-        inline bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
-        inline bool operator==(const std::string& value) const { return (this->string_ == value);              }
-        bool operator==(const MultiTypeString&    mts) const;
-        bool operator==(const MultiTypePrimitive& mtp) const;
-
-        using MultiTypePrimitive::operator!=;
-        inline bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
-        inline bool operator!=(const std::string& value) const { return (this->string_ != value);              }
-        bool operator!=(const MultiTypeString&    mts) const;
-        bool operator!=(const MultiTypePrimitive& mtp) const;
-
-        virtual operator void*()          const;
-        virtual operator int()            const;
-        virtual operator unsigned int()   const;
-        virtual operator char()           const;
-        virtual operator unsigned char()  const;
-        virtual operator short()          const;
-        virtual operator unsigned short() const;
-        virtual operator long()           const;
-        virtual operator unsigned long()  const;
-        virtual operator float ()         const;
-        virtual operator double ()        const;
-        virtual operator long double()    const;
-        virtual operator bool()           const;
-        virtual operator std::string()    const;
-        virtual operator const char*()    const;
-
-        using MultiTypePrimitive::setValue;
-        inline void setValue(const char*        value) { this->type_ = MT_string; this->string_ = std::string(value); }
-        inline void setValue(const std::string& value) { this->type_ = MT_string; this->string_ = value;              }
-        void setValue(const MultiTypeString&    mts);
-        void setValue(const MultiTypePrimitive& mtp);
-
-        inline std::string getString()     const { return this->string_;         }
-        inline const char*  getConstChar() const { return this->string_.c_str(); }
-
-        inline std::string& getString()    { return this->string_;         }
-        inline const char*  getConstChar() { return this->string_.c_str(); }
-
-        using MultiTypePrimitive::getValue;
-        inline void getValue(std::string* variable) const { (*variable) = this->string_;         }
-        inline void getValue(const char** variable) const { (*variable) = this->string_.c_str(); }
-
-        virtual std::string getTypename() const;
-
-        virtual std::string toString() const;
-        virtual bool fromString(const std::string value);
-
-        virtual bool assimilate(const MultiTypeString& mts, const MultiTypeString& defvalue = MultiTypeString());
-
-    protected:
-        std::string      string_;
-};
-
-_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeString& mts);
-
-#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
-#pragma warning(pop)
-#endif
-
-#endif /* _MultiTypeString_H__ */
Index: code/trunk/src/util/MultiTypeValue.h
===================================================================
--- code/trunk/src/util/MultiTypeValue.h	(revision 1747)
+++ code/trunk/src/util/MultiTypeValue.h	(revision 1747)
@@ -0,0 +1,98 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _MultiTypeValue_H__
+#define _MultiTypeValue_H__
+
+#include "UtilPrereqs.h"
+#include "Convert.h"
+#include "MultiType.h"
+
+template <typename T>
+struct MT_Value : public MultiType::MT_ValueBase
+{
+    MT_Value(const T& value, MT_Type type) : MT_ValueBase(type), value_(value) {}
+
+    inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
+    inline void reset() { this->value_ = T(); }
+    inline void assimilate(const MultiType& other) { if (other.value_) { T temp; other.getValue(&temp); this->value_ = temp; } else { this->value_ = T(); } }
+
+    inline void setValue(const char& value)                 { this->value_ = getConvertedValue<char,                 T>(value); }
+    inline void setValue(const unsigned char& value)        { this->value_ = getConvertedValue<unsigned char,        T>(value); }
+    inline void setValue(const short& value)                { this->value_ = getConvertedValue<short,                T>(value); }
+    inline void setValue(const unsigned short& value)       { this->value_ = getConvertedValue<unsigned short,       T>(value); }
+    inline void setValue(const int& value)                  { this->value_ = getConvertedValue<int,                  T>(value); }
+    inline void setValue(const unsigned int& value)         { this->value_ = getConvertedValue<unsigned int,         T>(value); }
+    inline void setValue(const long& value)                 { this->value_ = getConvertedValue<long,                 T>(value); }
+    inline void setValue(const unsigned long& value)        { this->value_ = getConvertedValue<unsigned long,        T>(value); }
+    inline void setValue(const long long& value)            { this->value_ = getConvertedValue<long long,            T>(value); }
+    inline void setValue(const unsigned long long& value)   { this->value_ = getConvertedValue<unsigned long long,   T>(value); }
+    inline void setValue(const float& value)                { this->value_ = getConvertedValue<float,                T>(value); }
+    inline void setValue(const double& value)               { this->value_ = getConvertedValue<double,               T>(value); }
+    inline void setValue(const long double& value)          { this->value_ = getConvertedValue<long double,          T>(value); }
+    inline void setValue(const bool& value)                 { this->value_ = getConvertedValue<bool,                 T>(value); }
+    inline void setValue(      void* const& value)          { this->value_ = getConvertedValue<void*,                T>(value); }
+    inline void setValue(const std::string& value)          { this->value_ = getConvertedValue<std::string,          T>(value); }
+    inline void setValue(const orxonox::Vector2& value)     { this->value_ = getConvertedValue<orxonox::Vector2,     T>(value); }
+    inline void setValue(const orxonox::Vector3& value)     { this->value_ = getConvertedValue<orxonox::Vector3,     T>(value); }
+    inline void setValue(const orxonox::Vector4& value)     { this->value_ = getConvertedValue<orxonox::Vector4,     T>(value); }
+    inline void setValue(const orxonox::ColourValue& value) { this->value_ = getConvertedValue<orxonox::ColourValue, T>(value); }
+    inline void setValue(const orxonox::Quaternion& value)  { this->value_ = getConvertedValue<orxonox::Quaternion,  T>(value); }
+    inline void setValue(const orxonox::Radian& value)      { this->value_ = getConvertedValue<orxonox::Radian,      T>(value); }
+    inline void setValue(const orxonox::Degree& value)      { this->value_ = getConvertedValue<orxonox::Degree,      T>(value); }
+
+    inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }
+    inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }
+    inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }
+    inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }
+    inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }
+    inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }
+    inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }
+    inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }
+    inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }
+    inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }
+    inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }
+    inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }
+    inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }
+    inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, false); }
+    inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }
+    inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_); }
+    inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_); }
+    inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_); }
+    inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_); }
+    inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_); }
+    inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_); }
+    inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_); }
+    inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_); }
+
+    inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+
+    T value_;
+};
+
+#endif /* _MultiTypeValue_H__ */
Index: code/trunk/src/util/OutputBuffer.cc
===================================================================
--- code/trunk/src/util/OutputBuffer.cc	(revision 1747)
+++ code/trunk/src/util/OutputBuffer.cc	(revision 1747)
@@ -0,0 +1,96 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OutputBuffer.h"
+
+#define OUTPUTBUFFER_MAX_LINE_LENGTH 16384
+
+namespace orxonox
+{
+    void OutputBuffer::registerListener(OutputBufferListener* listener)
+    {
+        this->listeners_.insert(this->listeners_.end(), listener);
+    }
+
+    void OutputBuffer::unregisterListener(OutputBufferListener* listener)
+    {
+        for (std::list<OutputBufferListener*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); )
+        {
+            if ((*it) == listener)
+                this->listeners_.erase(it++);
+            else
+                ++it;
+        }
+    }
+
+    OutputBuffer& OutputBuffer::operator<<(std::ostream& (*manipulator)(std::ostream&))
+    {
+                this->stream_ << manipulator;
+                this->callListeners();
+                return *this;
+    }
+
+    OutputBuffer& OutputBuffer::operator<<(std::ios& (*manipulator)(std::ios&))
+    {
+                this->stream_ << manipulator;
+                this->callListeners();
+                return *this;
+    }
+
+    OutputBuffer& OutputBuffer::operator<<(std::ios_base& (*manipulator)(std::ios_base&))
+    {
+                this->stream_ << manipulator;
+                this->callListeners();
+                return *this;
+    }
+
+    bool OutputBuffer::getLine(std::string* output)
+    {
+        char line[OUTPUTBUFFER_MAX_LINE_LENGTH];
+
+        this->stream_.getline(line, OUTPUTBUFFER_MAX_LINE_LENGTH);
+        (*output) = std::string(line);
+
+        bool eof = this->stream_.eof();
+        bool fail = this->stream_.fail();
+
+        if (eof)
+            this->stream_.flush();
+
+        if (eof || fail)
+            this->stream_.clear();
+
+        return (!eof && !fail);
+    }
+
+    void OutputBuffer::callListeners()
+    {
+        for (std::list<OutputBufferListener*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
+            (*it)->outputChanged();
+    }
+}
Index: code/trunk/src/util/OutputBuffer.h
===================================================================
--- code/trunk/src/util/OutputBuffer.h	(revision 1747)
+++ code/trunk/src/util/OutputBuffer.h	(revision 1747)
@@ -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:
+ *      ...
+ *
+ */
+
+#ifndef _OutputBuffer_H__
+#define _OutputBuffer_H__
+
+#include <list>
+#include <sstream>
+#include <iostream>
+
+#include "UtilPrereqs.h"
+
+namespace orxonox
+{
+    class _UtilExport OutputBufferListener
+    {
+        friend class OutputBuffer;
+
+        public:
+            virtual ~OutputBufferListener() {}
+
+        private:
+            virtual void outputChanged() = 0;
+    };
+
+    class _UtilExport OutputBuffer
+    {
+        public:
+            OutputBuffer() {}
+            ~OutputBuffer() {}
+
+            template <class T>
+            inline OutputBuffer& operator<<(T object)
+            {
+                this->stream_ << object;
+                this->callListeners();
+                return *this;
+            }
+
+            template <const OutputBuffer&>
+            inline OutputBuffer& operator<<(const OutputBuffer& object)
+            {
+                this->stream_ << object.stream_.rdbuf();
+                this->callListeners();
+                return *this;
+            }
+
+            OutputBuffer& operator<<(std::ostream& (*manipulator)(std::ostream&));
+            OutputBuffer& operator<<(std::ios& (*manipulator)(std::ios&));
+            OutputBuffer& operator<<(std::ios_base& (*manipulator)(std::ios_base&));
+
+            template <class T>
+            inline void add(T object)
+            {
+                this->stream_ << object;
+                this->callListeners();
+            }
+
+            template <class T>
+            inline void addLine(T object)
+            {
+                this->stream_ << object << std::endl;
+                this->callListeners();
+            }
+
+            inline void newline()
+            {
+                this->stream_ << std::endl;
+                this->callListeners();
+            }
+
+            inline void flush()
+            {
+                this->stream_.flush();
+            }
+
+            bool getLine(std::string* output);
+
+            void registerListener(OutputBufferListener* listener);
+            void unregisterListener(OutputBufferListener* listener);
+
+            inline std::stringstream& getStream()
+                { return this->stream_; }
+
+        private:
+            void callListeners();
+
+            std::stringstream stream_;
+            std::list<OutputBufferListener*> listeners_;
+    };
+}
+
+#endif /* _OutputBuffer_H__ */
Index: code/trunk/src/util/OutputHandler.cc
===================================================================
--- code/trunk/src/util/OutputHandler.cc	(revision 1747)
+++ code/trunk/src/util/OutputHandler.cc	(revision 1747)
@@ -0,0 +1,188 @@
+/*
+ *   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 OutputHandler.cc
+    @brief Implementation of the OutputHandler class.
+*/
+
+#include "OutputHandler.h"
+
+namespace orxonox
+{
+    /**
+        @brief Constructor: Opens the logfile and writes the first line.
+        @param logfilename The name of the logfile
+    */
+    OutputHandler::OutputHandler(const std::string& logfilename)
+    {
+        this->outputBuffer_ = &this->fallbackBuffer_;
+        this->softDebugLevel_[0] = this->softDebugLevel_[1] = this->softDebugLevel_[2] = this->softDebugLevel_[3] = 2;
+        this->logfilename_ = logfilename;
+        this->logfile_.open(this->logfilename_.c_str(), std::fstream::out);
+        this->logfile_ << "Started log at yyyy/mm/dd hh:mm:ss" << std::endl;
+        this->logfile_.flush();
+    }
+
+    /**
+        @brief Destructor: Writes the last line to the logfile and closes it.
+    */
+    OutputHandler::~OutputHandler()
+    {
+        this->logfile_ << "Closed log" << std::endl;
+        this->logfile_.close();
+    }
+
+    /**
+        @brief Returns a reference to the only existing instance of the OutputHandler class.
+        @return The instance
+    */
+    OutputHandler& OutputHandler::getOutStream()
+    {
+        static OutputHandler orxout("orxonox.log");
+        return orxout;
+    }
+
+    /**
+        @brief Sets the soft debug level for a given output device.
+        @param device The output device
+        @param level The debug level
+    */
+    void OutputHandler::setSoftDebugLevel(OutputHandler::OutputDevice device, int level)
+    {
+        OutputHandler::getOutStream().softDebugLevel_[(unsigned int)device] = level;
+    }
+
+    /**
+        @brief Returns the soft debug level for a given output device.
+        @param device The output device
+        @return The debug level
+    */
+    int OutputHandler::getSoftDebugLevel(OutputHandler::OutputDevice device)
+    {
+        return OutputHandler::getOutStream().softDebugLevel_[(unsigned int)device];
+    }
+
+    /**
+        @brief Sets the OutputBuffer, representing the third output stream.
+        @param buffer The OutputBuffer
+    */
+    void OutputHandler::setOutputBuffer(OutputBuffer& buffer)
+    {
+        buffer.getStream() >> this->outputBuffer_->getStream().rdbuf();
+        this->outputBuffer_ = &buffer;
+    }
+
+    /**
+        @brief Overloaded << operator, redirects the output to the console and the logfile.
+        @param sb The streambuffer that should be shown in the console
+        @return A reference to the OutputHandler itself
+    */
+    OutputHandler& OutputHandler::operator<<(std::streambuf* sb)
+    {
+        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
+            std::cout << sb;
+
+        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
+        {
+            this->logfile_ << sb;
+            this->logfile_.flush();
+        }
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
+            (*this->outputBuffer_) << sb;
+
+        return *this;
+    }
+
+    /**
+        @brief Overloaded << operator, redirects the output to the console and the logfile.
+        @param manipulator A function, manipulating the outstream.
+        @return A reference to the OutputHandler itself
+    */
+    OutputHandler& OutputHandler::operator<<(std::ostream& (*manipulator)(std::ostream&))
+    {
+        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
+            manipulator(std::cout);
+
+        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
+        {
+            manipulator(this->logfile_);
+            this->logfile_.flush();
+        }
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
+            (*this->outputBuffer_) << manipulator;
+
+        return *this;
+    }
+
+    /**
+        @brief Overloaded << operator, redirects the output to the console and the logfile.
+        @param manipulator A function, manipulating the outstream.
+        @return A reference to the OutputHandler itself
+    */
+    OutputHandler& OutputHandler::operator<<(std::ios& (*manipulator)(std::ios&))
+    {
+        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
+            manipulator(std::cout);
+
+        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
+        {
+            manipulator(this->logfile_);
+            this->logfile_.flush();
+        }
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
+            (*this->outputBuffer_) << manipulator;
+
+        return *this;
+    }
+
+    /**
+        @brief Overloaded << operator, redirects the output to the console and the logfile.
+        @param manipulator A function, manipulating the outstream.
+        @return A reference to the OutputHandler itself
+    */
+    OutputHandler& OutputHandler::operator<<(std::ios_base& (*manipulator)(std::ios_base&))
+    {
+        if (getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
+            manipulator(std::cout);
+
+        if (getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
+        {
+            manipulator(this->logfile_);
+            this->logfile_.flush();
+        }
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
+            (*this->outputBuffer_) << manipulator;
+
+        return *this;
+    }
+}
Index: code/trunk/src/util/OutputHandler.h
===================================================================
--- code/trunk/src/util/OutputHandler.h	(revision 1747)
+++ code/trunk/src/util/OutputHandler.h	(revision 1747)
@@ -0,0 +1,204 @@
+/*
+ *   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 OutputHandler.h
+    @brief Definition of the OutputHandler class.
+
+    The OutputHandler acts like std::cout, but output isn't only shown in the console,
+    but also written to the logfile.
+*/
+
+#ifndef _OutputHandler_H__
+#define _OutputHandler_H__
+
+#include "UtilPrereqs.h"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+
+#include "OutputBuffer.h"
+
+namespace orxonox
+{
+    //! The OutputHandler acts like std::cout, but redirects output to the console AND the logfile.
+    class _UtilExport OutputHandler
+    {
+        public:
+            enum OutputDevice
+            {
+                LD_All = 0,
+                LD_Console = 1,
+                LD_Logfile = 2,
+                LD_Shell = 3
+            };
+
+            static OutputHandler& getOutStream();
+
+            /** @brief Puts some text on the outstream. @param text The text */
+            static inline std::string log(const std::string& text)
+                { OutputHandler::getOutStream().setOutputLevel(0); OutputHandler::getOutStream().output(text + "\n"); return text; }
+
+            /** @brief Puts an error on the outstream. @param text The text */
+            static inline std::string error(const std::string& text)
+                { OutputHandler::getOutStream().setOutputLevel(1); OutputHandler::getOutStream().output(text + "\n"); return text; }
+
+            /** @brief Puts a warning on the outstream. @param text The text */
+            static inline std::string warning(const std::string& text)
+                { OutputHandler::getOutStream().setOutputLevel(2); OutputHandler::getOutStream().output(text + "\n"); return text; }
+
+            /** @brief Puts an info on the outstream. @param text The text */
+            static inline std::string info(const std::string& text)
+                { OutputHandler::getOutStream().setOutputLevel(3); OutputHandler::getOutStream().output(text + "\n"); return text; }
+
+            /** @brief Puts some debug output on the outstream. @param text The text */
+            static inline std::string debug(const std::string& text)
+                { OutputHandler::getOutStream().setOutputLevel(4); OutputHandler::getOutStream().output(text + "\n"); return text; }
+
+            /** @brief Returns a reference to the logfile. @return The logfile */
+            inline std::ofstream& getLogfile()
+                { return this->logfile_; }
+
+            /** @brief Returns a pointer to the OutputBuffer. @return The OutputBuffer */
+            inline OutputBuffer* getOutputBuffer()
+                { return this->outputBuffer_; }
+
+            /** @brief Sets the level of the incoming output. @param level The level of the incoming output @return The OutputHandler itself */
+            inline OutputHandler& setOutputLevel(int level)
+                { this->outputLevel_ = level; return *this; }
+
+            /** @brief Returns the level of the incoming output. @return The level */
+            inline int getOutputLevel() const
+                { return this->outputLevel_; }
+
+            static void setSoftDebugLevel(OutputHandler::OutputDevice device, int level);
+            static int getSoftDebugLevel(OutputHandler::OutputDevice device = OutputHandler::LD_All);
+
+            void setOutputBuffer(OutputBuffer& buffer);
+
+            template <class T>
+            OutputHandler& output(const T& output);
+
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(unsigned char val)      { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(short val)              { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(unsigned short val)     { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(int val)                { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(unsigned int val)       { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(long val)               { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(unsigned long val)      { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(long long val)          { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(unsigned long long val) { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(float val)              { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(double val)             { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(long double val)        { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(const void* val)        { return this->output(val); }
+            /** @brief Overloaded << operator, redirects the output to the console and the logfile. @param val The value that should be shown in the console @return A reference to the OutputHandler itself */
+            inline OutputHandler& operator<<(bool val)               { return this->output(val); }
+
+            OutputHandler& operator<<(std::streambuf* sb);
+
+            OutputHandler& operator<<(std::ostream& (*manipulator)(std::ostream&));
+            OutputHandler& operator<<(std::ios& (*manipulator)(std::ios&));
+            OutputHandler& operator<<(std::ios_base& (*manipulator)(std::ios_base&));
+
+        private:
+            explicit OutputHandler(const std::string& logfilename);
+            OutputHandler(const OutputHandler& oh);  // don't copy
+            virtual ~OutputHandler();
+
+            std::ofstream logfile_;              //!< The logfile where the output is logged
+            std::string logfilename_;            //!< The name of the logfile
+            OutputBuffer fallbackBuffer_;        //!< The OutputBuffer that gets used if there is no other OutputBuffer
+            OutputBuffer* outputBuffer_;         //!< The OutputBuffer to put output in (usually used by the Shell)
+            int outputLevel_;                    //!< The level of the incoming output
+            int softDebugLevel_[4];              //!< The soft debug level for each OutputDevice - the configurable maximal output level
+    };
+
+    /**
+        @brief Redirects the output to the console and the logfile.
+        @param output The value that should be shown in the console
+        @return A reference to the OutputHandler itself
+    */
+    template<class T>
+    OutputHandler& OutputHandler::output(const T& output)
+    {
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Console) >= this->outputLevel_)
+            std::cout << output;
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Logfile) >= this->outputLevel_)
+        {
+            this->logfile_ << output;
+            this->logfile_.flush();
+        }
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= this->outputLevel_)
+            (*this->outputBuffer_) << output;
+
+        return *this;
+    }
+
+    /**
+        @brief Overloading of the non-member << operator to redirect the output of classes with self defined '<< to std::ostream' operators to the console and the logfile.
+        @param out The OutputHandler itself
+        @param output The class that should be shown in the console
+        @return The OutputHandler itself
+    */
+    template<class T>
+    OutputHandler& operator<<(OutputHandler& out, const T& output)
+    {
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Console) >= out.getOutputLevel())
+            std::cout << output;
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Logfile) >= out.getOutputLevel())
+        {
+            out.getLogfile() << output;
+            out.getLogfile().flush();
+        }
+
+        if (OutputHandler::getSoftDebugLevel(OutputHandler::LD_Shell) >= out.getOutputLevel())
+            (*out.getOutputBuffer()) << output;
+
+        return out;
+    }
+}
+
+#endif /* _OutputHandler_H__ */
Index: code/trunk/src/util/UtilPrereqs.h
===================================================================
--- code/trunk/src/util/UtilPrereqs.h	(revision 1740)
+++ code/trunk/src/util/UtilPrereqs.h	(revision 1747)
@@ -62,9 +62,14 @@
 class ArgReader;
 class Convert;
-class MultiTypePrimitive;
-class MultiTypeString;
-class MultiTypeMath;
-template <class T>
-class String2Number;
+class ExprParser;
+class MultiType;
 class SubString;
+namespace orxonox
+{
+    class OutputBuffer;
+    class OutputBufferListener;
+    class Error;
+    class OutputHandler;
+}
+
 #endif /* _UtilPrereqs_H__ */
