Index: code/branches/core/src/orxonox/core/CMakeLists.txt
===================================================================
--- code/branches/core/src/orxonox/core/CMakeLists.txt	(revision 791)
+++ code/branches/core/src/orxonox/core/CMakeLists.txt	(revision 792)
@@ -13,4 +13,5 @@
   OutputHandler.cc
   Language.cc
+  Loader.cc
 )
 
Index: code/branches/core/src/orxonox/core/ConfigValueContainer.cc
===================================================================
--- code/branches/core/src/orxonox/core/ConfigValueContainer.cc	(revision 791)
+++ code/branches/core/src/orxonox/core/ConfigValueContainer.cc	(revision 792)
@@ -28,7 +28,7 @@
 #include <fstream>
 
+#include "ConfigValueContainer.h"
 #include "util/Tokenizer.h"
 #include "util/Convert.h"
-#include "ConfigValueContainer.h"
 
 #define CONFIGFILEPATH "orxonox.ini"
@@ -43,298 +43,129 @@
         @param defvalue The default-value
     */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, int defvalue)
+    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, MultiTypeMath defvalue)
     {
         this->bAddedDescription_ = false;
         this->classname_ = classname;
         this->varname_ = varname;
-        this->type_ = VT_Int;
-
-        ConvertValue(&this->defvalueString_, defvalue, std::string("0"));           // Try to convert the default-value to a string
+
+        this->valueToString(&this->defvalueString_, defvalue);                      // Try to convert the default-value to a string
         this->searchConfigFileLine();                                               // Search the entry in the config-file
 
         std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
+        if (!this->parseString(valueString, defvalue))                              // Try to convert the string to a value
             this->resetConfigFileEntry();                                           // The conversion failed
     }
 
     /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned int defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_uInt;
-
-        ConvertValue(&this->defvalueString_, defvalue, std::string("0"));           // Try to convert the default-value to a string
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, char defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_Char;
-
-        ConvertValue(&this->defvalueString_, (int)defvalue, std::string("0"));      // Try to convert the default-value to a string
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned char defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_uChar;
-
-        ConvertValue(&this->defvalueString_, (unsigned int)defvalue, std::string("0"));     // Try to convert the default-value to a string
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, float defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_Float;
-
-        ConvertValue(&this->defvalueString_, defvalue, std::string("0.000000"));    // Try to convert the default-value to a string
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, double defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_Double;
-
-        ConvertValue(&this->defvalueString_, defvalue, std::string("0.000000"));    // Try to convert the default-value to a string
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, long double defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_LongDouble;
-
-        ConvertValue(&this->defvalueString_, defvalue, std::string("0.000000"));    // Try to convert the default-value to a string
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, bool defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_Bool;
-
-        // Convert the default-value from bool to string
-        if (defvalue)
-            this->defvalueString_ = "true";
-        else
-            this->defvalueString_ = "false";
-
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, const std::string& defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_String;
-
-        this->defvalueString_ = "\"" + defvalue + "\"";                             // Convert the string to a "config-file-string" with quotes
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, const char* defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_ConstChar;
-
-        this->defvalueString_ = "\"" + std::string(defvalue) + "\"";                // Convert the string to a "config-file-string" with quotes
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString(false);                    // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, Vector2 defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_Vector2;
-
-        // Try to convert the default-value from Vector2 to string
-        std::ostringstream ostream;
-        if (ostream << "(" << defvalue.x << "," << defvalue.y << ")")
-            this->defvalueString_ = ostream.str();
-        else
-            this->defvalueString_ = "(0,0)";
-
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, Vector3 defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_Vector3;
-
-        // Try to convert the default-value from Vector3 to string
-        std::ostringstream ostream;
-        if (ostream << "(" << defvalue.x << "," << defvalue.y << "," << defvalue.z << ")")
-            this->defvalueString_ = ostream.str();
-        else
-            this->defvalueString_ = "(0,0,0)";
-
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
-    }
-
-    /**
-        @brief Constructor: Converts the default-value to a string, checks the config-file for a changed value, sets the intern value variable.
-        @param value This is only needed to determine the right type.
-        @param classname The name of the class the variable belongs to
-        @param varname The name of the variable
-        @param defvalue The default-value
-    */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, ColourValue defvalue)
-    {
-        this->bAddedDescription_ = false;
-        this->classname_ = classname;
-        this->varname_ = varname;
-        this->type_ = VT_ColourValue;
-
-        // Try to convert the default-value from ColourValue to string
-        std::ostringstream ostream;
-        if (ostream << "(" << defvalue.r << "," << defvalue.g << "," << defvalue.b << "," << defvalue.a << ")")
-            this->defvalueString_ = ostream.str();
-        else
-            this->defvalueString_ = "(0,0,0,0)";
-
-        this->searchConfigFileLine();                                               // Search the entry in the config-file
-        std::string valueString = this->parseValueString();                         // Parses the value string from the config-file-entry
-        if (!this->parseSting(valueString, defvalue))                               // Try to convert the string to a value
-            this->resetConfigFileEntry();                                           // The conversion failed
+        @brief Converts a value to a string.
+        @param output The string to write to
+        @param input The value to convert
+        @return True if the converson was successful
+    */
+    bool ConfigValueContainer::valueToString(std::string* output, MultiTypeMath& input)
+    {
+        if (this->value_.getType() == MT_int)
+            return ConvertValue(output, input.getInt(), std::string("0"));
+        else if (this->value_.getType() == MT_uint)
+            return ConvertValue(output, input.getUnsignedInt(), std::string("0"));
+        else if (this->value_.getType() == MT_char)
+            return ConvertValue(output, input.getChar(), std::string("0"));
+        else if (this->value_.getType() == MT_uchar)
+            return ConvertValue(output, input.getUnsignedChar(), std::string("0"));
+        else if (this->value_.getType() == MT_short)
+            return ConvertValue(output, input.getShort(), std::string("0"));
+        else if (this->value_.getType() == MT_ushort)
+            return ConvertValue(output, input.getUnsignedShort(), std::string("0"));
+        else if (this->value_.getType() == MT_long)
+            return ConvertValue(output, input.getLong(), std::string("0"));
+        else if (this->value_.getType() == MT_ulong)
+            return ConvertValue(output, input.getUnsignedLong(), std::string("0"));
+        else if (this->value_.getType() == MT_float)
+            return ConvertValue(output, input.getFloat(), std::string("0.000000"));
+        else if (this->value_.getType() == MT_double)
+            return ConvertValue(output, input.getDouble(), std::string("0.000000"));
+        else if (this->value_.getType() == MT_longdouble)
+            return ConvertValue(output, input.getChar(), std::string("0.000000"));
+        else if (this->value_.getType() == MT_bool)
+        {
+            if (input.getBool())
+                (*output) = "true";
+            else
+                (*output) = "false";
+
+            return true;
+        }
+        else if (this->value_.getType() == MT_constchar)
+        {
+            (*output) = "\"" + input.getString() + "\"";
+            return true;
+        }
+        else if (this->value_.getType() == MT_string)
+        {
+            (*output) = "\"" + input.getString() + "\"";
+            return true;
+        }
+        else if (this->value_.getType() == MT_vector2)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getVector2().x << "," << input.getVector2().y << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0)";
+                return false;
+            }
+        }
+        else if (this->value_.getType() == MT_vector3)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getVector3().x << "," << input.getVector3().y << "," << input.getVector3().z << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0,0)";
+                return false;
+            }
+        }
+        else if (this->value_.getType() == MT_colourvalue)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getColourValue().r << "," << input.getColourValue().g << "," << input.getColourValue().b << "," << input.getColourValue().a << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0,0,0)";
+                return false;
+            }
+        }
+        else if (this->value_.getType() == MT_quaternion)
+        {
+            std::ostringstream ostream;
+            if (ostream << "(" << input.getQuaternion().w << "," << input.getQuaternion().x << "," << input.getQuaternion().y << "," << input.getQuaternion().z << ")")
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            else
+            {
+                (*output) = "(0,0,0,0)";
+                return false;
+            }
+        }
+        else if (this->value_.getType() == MT_radian)
+            return ConvertValue(output, input.getRadian(), std::string("0.000000"));
+        else if (this->value_.getType() == MT_degree)
+            return ConvertValue(output, input.getDegree(), std::string("0.000000"));
+
+        return false;
     }
 
@@ -344,32 +175,46 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input)
-    {
-        if (this->type_ == ConfigValueContainer::VT_Int)
-            return this->parseSting(input, this->value_.value_int_);
-        else if (this->type_ == ConfigValueContainer::VT_uInt)
-            return this->parseSting(input, this->value_.value_uint_);
-        else if (this->type_ == ConfigValueContainer::VT_Char)
-            return this->parseSting(input, this->value_.value_char_);
-        else if (this->type_ == ConfigValueContainer::VT_uChar)
-            return this->parseSting(input, this->value_.value_uchar_);
-        else if (this->type_ == ConfigValueContainer::VT_Float)
-            return this->parseSting(input, this->value_.value_float_);
-        else if (this->type_ == ConfigValueContainer::VT_Double)
-            return this->parseSting(input, this->value_.value_double_);
-        else if (this->type_ == ConfigValueContainer::VT_LongDouble)
-            return this->parseSting(input, this->value_.value_long_double_);
-        else if (this->type_ == ConfigValueContainer::VT_Bool)
-            return this->parseSting(input, this->value_.value_bool_);
-        else if (this->type_ == ConfigValueContainer::VT_String)
-            return this->parseSting(input, this->value_string_);
-        else if (this->type_ == ConfigValueContainer::VT_ConstChar)
-            return this->parseSting(input, this->value_string_);
-        else if (this->type_ == ConfigValueContainer::VT_Vector2)
-            return this->parseSting(input, this->value_vector2_);
-        else if (this->type_ == ConfigValueContainer::VT_Vector3)
-            return this->parseSting(input, this->value_vector3_);
-        else if (this->type_ == ConfigValueContainer::VT_ColourValue)
-            return this->parseSting(input, this->value_colourvalue_);
+    bool ConfigValueContainer::parseString(const std::string& input, MultiTypeMath& defvalue)
+    {
+        if (this->value_.getType() == MT_int)
+            return this->parseString(input, defvalue.getInt());
+        else if (this->value_.getType() == MT_uint)
+            return this->parseString(input, defvalue.getUnsignedInt());
+        else if (this->value_.getType() == MT_char)
+            return this->parseString(input, defvalue.getChar());
+        else if (this->value_.getType() == MT_uchar)
+            return this->parseString(input, defvalue.getUnsignedChar());
+        else if (this->value_.getType() == MT_short)
+            return this->parseString(input, defvalue.getShort());
+        else if (this->value_.getType() == MT_ushort)
+            return this->parseString(input, defvalue.getUnsignedShort());
+        else if (this->value_.getType() == MT_long)
+            return this->parseString(input, defvalue.getLong());
+        else if (this->value_.getType() == MT_ulong)
+            return this->parseString(input, defvalue.getUnsignedLong());
+        else if (this->value_.getType() == MT_float)
+            return this->parseString(input, defvalue.getFloat());
+        else if (this->value_.getType() == MT_double)
+            return this->parseString(input, defvalue.getDouble());
+        else if (this->value_.getType() == MT_longdouble)
+            return this->parseString(input, defvalue.getLongDouble());
+        else if (this->value_.getType() == MT_bool)
+            return this->parseString(input, defvalue.getBool());
+        else if (this->value_.getType() == MT_constchar)
+            return this->parseString(input, defvalue.getString());
+        else if (this->value_.getType() == MT_string)
+            return this->parseString(input, defvalue.getString());
+        else if (this->value_.getType() == MT_vector2)
+            return this->parseString(input, defvalue.getVector2());
+        else if (this->value_.getType() == MT_vector3)
+            return this->parseString(input, defvalue.getVector3());
+        else if (this->value_.getType() == MT_colourvalue)
+            return this->parseString(input, defvalue.getColourValue());
+        else if (this->value_.getType() == MT_quaternion)
+            return this->parseString(input, defvalue.getQuaternion());
+        else if (this->value_.getType() == MT_radian)
+            return this->parseString(input, defvalue.getRadian());
+        else if (this->value_.getType() == MT_degree)
+            return this->parseString(input, defvalue.getDegree());
 
         return false;
@@ -382,7 +227,10 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, int defvalue)
-    {
-        return ConvertValue(&this->value_.value_int_, input, defvalue);
+    bool ConfigValueContainer::parseString(const std::string& input, int defvalue)
+    {
+        int temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
     }
 
@@ -393,7 +241,10 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, unsigned int defvalue)
-    {
-        return ConvertValue(&this->value_.value_uint_, input, defvalue);
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned int defvalue)
+    {
+        unsigned int temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
     }
 
@@ -404,8 +255,11 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, char defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, char defvalue)
     {
         // I used value_int_ instead of value_char_ to avoid number <-> char confusion in the config-file
-        return ConvertValue(&this->value_.value_int_, input, (int)defvalue);
+        int temp;
+        bool success = ConvertValue(&temp, input, (int)defvalue);
+        ((MultiTypePrimitive)this->value_).setValue((char)temp);
+        return success;
     }
 
@@ -416,8 +270,67 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, unsigned char defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned char defvalue)
     {
         // I used value_uint_ instead of value_uchar_ to avoid number <-> char confusion in the config-file
-        return ConvertValue(&this->value_.value_uint_, input, (unsigned int)defvalue);
+        unsigned int temp;
+        bool success = ConvertValue(&temp, input, (unsigned int)defvalue);
+        ((MultiTypePrimitive)this->value_).setValue((unsigned char)temp);
+        return success;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type short and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, short defvalue)
+    {
+        short temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type unsigned short and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned short defvalue)
+    {
+        unsigned short temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type long and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, long defvalue)
+    {
+        long temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type unsigned long and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, unsigned long defvalue)
+    {
+        unsigned long temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
     }
 
@@ -428,7 +341,10 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, float defvalue)
-    {
-        return ConvertValue(&this->value_.value_float_, input, defvalue);
+    bool ConfigValueContainer::parseString(const std::string& input, float defvalue)
+    {
+        float temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
     }
 
@@ -439,7 +355,10 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, double defvalue)
-    {
-        return ConvertValue(&this->value_.value_double_, input, defvalue);
+    bool ConfigValueContainer::parseString(const std::string& input, double defvalue)
+    {
+        double temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
     }
 
@@ -450,7 +369,10 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, long double defvalue)
-    {
-        return ConvertValue(&this->value_.value_long_double_, input, defvalue);
+    bool ConfigValueContainer::parseString(const std::string& input, long double defvalue)
+    {
+        long double temp;
+        bool success = ConvertValue(&temp, input, defvalue);
+        ((MultiTypePrimitive)this->value_).setValue(temp);
+        return success;
     }
 
@@ -461,5 +383,5 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, bool defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, bool defvalue)
     {
         // Try to parse the value-string - is it a word?
@@ -468,14 +390,17 @@
          || input.find("yes") < input.size()
          || input.find("Yes") < input.size())
-            this->value_.value_bool_ = true;
+            ((MultiTypePrimitive)this->value_).setValue(true);
         else if (input.find("false") < input.size()
               || input.find("False") < input.size()
               || input.find("no") < input.size()
               || input.find("No") < input.size())
-            this->value_.value_bool_ = false;
+            ((MultiTypePrimitive)this->value_).setValue(false);
         else
         {
             // Its not a known word - is it a number?
-            return ConvertValue(&this->value_.value_bool_, input, defvalue);
+            bool temp;
+            bool success = ConvertValue(&temp, input, defvalue);
+            ((MultiTypePrimitive)this->value_).setValue(temp);
+            return success;
         }
 
@@ -489,5 +414,5 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, const std::string& defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, const std::string& defvalue)
     {
         // Strip the quotes
@@ -499,10 +424,10 @@
         {
             // It was - get the string between the quotes
-            this->value_string_ = input.substr(pos1, pos2 - pos1);
+            this->value_.setValue(input.substr(pos1, pos2 - pos1));
             return true;
         }
 
         // It wasn't - use the default-value and restore the entry in the config-file.
-        this->value_string_ = defvalue;
+        this->value_.setValue(defvalue);
         return false;
     }
@@ -514,5 +439,5 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, const char* defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, const char* defvalue)
     {
         // Strip the quotes
@@ -524,10 +449,10 @@
         {
             // It was - get the string between the quotes
-            this->value_string_ = input.substr(pos1, pos2 - pos1);
+            this->value_.setValue(input.substr(pos1, pos2 - pos1));
             return true;
         }
 
         // It wasn't - use the default-value and restore the entry in the config-file.
-        this->value_string_ = defvalue;
+        this->value_.setValue(defvalue);
         return false;
     }
@@ -539,5 +464,5 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, const Vector2& defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, const Vector2& defvalue)
     {
         // Strip the value-string
@@ -549,12 +474,12 @@
         {
             std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
-            if (!ConvertValue(&this->value_vector2_.x, tokens[0]))
-            {
-                this->value_vector2_ = defvalue;
-                return false;
-            }
-            if (!ConvertValue(&this->value_vector2_.y, tokens[1]))
-            {
-                this->value_vector2_ = defvalue;
+            if (!ConvertValue(&this->value_.getVector2().x, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getVector2().y, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
                 return false;
             }
@@ -563,5 +488,5 @@
         }
 
-        this->value_vector2_ = defvalue;
+        this->value_.setValue(defvalue);
         return false;
     }
@@ -573,5 +498,5 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, const Vector3& defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, const Vector3& defvalue)
     {
         // Strip the value-string
@@ -583,17 +508,17 @@
         {
             std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
-            if (!ConvertValue(&this->value_vector3_.x, tokens[0]))
-            {
-                this->value_vector3_ = defvalue;
-                return false;
-            }
-            if (!ConvertValue(&this->value_vector3_.y, tokens[1]))
-            {
-                this->value_vector3_ = defvalue;
-                return false;
-            }
-            if (!ConvertValue(&this->value_vector3_.z, tokens[2]))
-            {
-                this->value_vector3_ = defvalue;
+            if (!ConvertValue(&this->value_.getVector3().x, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getVector3().y, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getVector3().z, tokens[2]))
+            {
+                this->value_.setValue(defvalue);
                 return false;
             }
@@ -602,5 +527,5 @@
         }
 
-        this->value_vector3_ = defvalue;
+        this->value_.setValue(defvalue);
         return false;
     }
@@ -612,5 +537,5 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseSting(const std::string& input, const ColourValue& defvalue)
+    bool ConfigValueContainer::parseString(const std::string& input, const ColourValue& defvalue)
     {
         // Strip the value-string
@@ -622,22 +547,22 @@
         {
             std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
-            if (!ConvertValue(&this->value_colourvalue_.r, tokens[0]))
-            {
-                this->value_colourvalue_ = defvalue;
-                return false;
-            }
-            if (!ConvertValue(&this->value_colourvalue_.g, tokens[1]))
-            {
-                this->value_colourvalue_ = defvalue;
-                return false;
-            }
-            if (!ConvertValue(&this->value_colourvalue_.b, tokens[2]))
-            {
-                this->value_colourvalue_ = defvalue;
-                return false;
-            }
-            if (!ConvertValue(&this->value_colourvalue_.a, tokens[3]))
-            {
-                this->value_colourvalue_ = defvalue;
+            if (!ConvertValue(&this->value_.getColourValue().r, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getColourValue().g, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getColourValue().b, tokens[2]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getColourValue().a, tokens[3]))
+            {
+                this->value_.setValue(defvalue);
                 return false;
             }
@@ -646,6 +571,72 @@
         }
 
-        this->value_colourvalue_ = defvalue;
+        this->value_.setValue(defvalue);
         return false;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type Quaternion and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Quaternion& defvalue)
+    {
+        // Strip the value-string
+        unsigned int pos1 = input.find("(") + 1;
+        unsigned int pos2 = input.find(")", pos1);
+
+        // Try to convert the stripped value-string to Vector3
+        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
+        {
+            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
+            if (!ConvertValue(&this->value_.getQuaternion().w, tokens[0]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getQuaternion().x, tokens[1]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getQuaternion().y, tokens[2]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+            if (!ConvertValue(&this->value_.getQuaternion().z, tokens[3]))
+            {
+                this->value_.setValue(defvalue);
+                return false;
+            }
+
+            return true;
+        }
+
+        this->value_.setValue(defvalue);
+        return false;
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type long double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Radian& defvalue)
+    {
+        return ConvertValue(&this->value_.getRadian(), input, defvalue);
+    }
+
+    /**
+        @brief Parses a given std::string into a value of the type long double and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @param input The string to convert
+        @param defvalue The default-value
+        @return True if the string was successfully parsed
+    */
+    bool ConfigValueContainer::parseString(const std::string& input, const Degree& defvalue)
+    {
+        return ConvertValue(&this->value_.getDegree(), input, defvalue);
     }
 
@@ -664,5 +655,5 @@
     void ConfigValueContainer::resetConfigValue()
     {
-        this->parseSting(this->defvalueString_);
+        this->parseString(this->defvalueString_, this->value_);
         this->resetConfigFileEntry();
     }
Index: code/branches/core/src/orxonox/core/ConfigValueContainer.h
===================================================================
--- code/branches/core/src/orxonox/core/ConfigValueContainer.h	(revision 791)
+++ code/branches/core/src/orxonox/core/ConfigValueContainer.h	(revision 792)
@@ -49,4 +49,5 @@
 
 #include "util/Math.h"
+#include "util/MultiTypeMath.h"
 #include "Language.h"
 
@@ -72,65 +73,34 @@
     {
         public:
-            enum VariableType
-            {
-                VT_Int,
-                VT_uInt,
-                VT_Char,
-                VT_uChar,
-                VT_Float,
-                VT_Double,
-                VT_LongDouble,
-                VT_Bool,
-                VT_ConstChar,
-                VT_String,
-                VT_Vector2,
-                VT_Vector3,
-                VT_ColourValue
-            };
-
-            ConfigValueContainer(const std::string& classname, const std::string& varname, int defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned int defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, char defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, unsigned char defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, float defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, double defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, long double defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, bool defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, const std::string& defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, const char* defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, Vector2 defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, Vector3 defvalue);
-            ConfigValueContainer(const std::string& classname, const std::string& varname, ColourValue defvalue);
+            ConfigValueContainer(const std::string& classname, const std::string& varname, MultiTypeMath defvalue);
 
             /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(int& value)                           { value = this->value_.value_int_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(unsigned int& value)                  { value = this->value_.value_uint_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(char& value)                          { value = this->value_.value_char_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(unsigned char& value)                 { value = this->value_.value_uchar_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(float& value)                         { value = this->value_.value_float_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(double& value)                        { value = this->value_.value_double_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(long double& value)                   { value = this->value_.value_long_double_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(bool& value)                          { value = this->value_.value_bool_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(std::string& value)                   { value = this->value_string_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(const char* value)                    { value = this->value_string_.c_str(); return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(Vector2& value)                       { value = this->value_vector2_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(Vector3& value)                       { value = this->value_vector3_; return *this; }
-            /** @returns the value. @param value This is only needed to determine the right type. */
-            inline ConfigValueContainer& getValue(ColourValue& value)                   { value = this->value_colourvalue_; return *this; }
+/*            template <typename T>
+            inline ConfigValueContainer& getValue(T& value)                           { this->value_.getValue(value); return *this; }
+*/
+            inline ConfigValueContainer& getValue(int* value)            { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned int* value)   { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(char* value)           { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned char* value)  { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(short* value)          { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned short* value) { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(long* value)           { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(unsigned long* value)  { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(float* value)          { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(double* value)         { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(long double* value)    { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(bool* value)           { ((MultiTypePrimitive)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(std::string* value)    { ((MultiTypeString)this->value_).getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Vector2* value)        { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Vector3* value)        { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(ColourValue* value)    { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Quaternion* value)     { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Radian* value)         { this->value_.getValue(value); return *this; }
+            inline ConfigValueContainer& getValue(Degree* value)         { this->value_.getValue(value); return *this; }
 
             void description(const std::string& description);
 
-            bool parseSting(const std::string& input);
+            bool parseString(const std::string& input, MultiTypeMath& defvalue = MT_null);
+            bool valueToString(std::string* output, MultiTypeMath& input);
             void resetConfigFileEntry();
             void resetConfigValue();
@@ -141,17 +111,24 @@
 
         private:
-            bool parseSting(const std::string& input, int defvalue);
-            bool parseSting(const std::string& input, unsigned int defvalue);
-            bool parseSting(const std::string& input, char defvalue);
-            bool parseSting(const std::string& input, unsigned char defvalue);
-            bool parseSting(const std::string& input, float defvalue);
-            bool parseSting(const std::string& input, double defvalue);
-            bool parseSting(const std::string& input, long double defvalue);
-            bool parseSting(const std::string& input, bool defvalue);
-            bool parseSting(const std::string& input, const std::string& defvalue);
-            bool parseSting(const std::string& input, const char* defvalue);
-            bool parseSting(const std::string& input, const Vector2& defvalue);
-            bool parseSting(const std::string& input, const Vector3& defvalue);
-            bool parseSting(const std::string& input, const ColourValue& defvalue);
+            bool parseString(const std::string& input, int defvalue);
+            bool parseString(const std::string& input, unsigned int defvalue);
+            bool parseString(const std::string& input, char defvalue);
+            bool parseString(const std::string& input, unsigned char defvalue);
+            bool parseString(const std::string& input, short defvalue);
+            bool parseString(const std::string& input, unsigned short defvalue);
+            bool parseString(const std::string& input, long defvalue);
+            bool parseString(const std::string& input, unsigned long defvalue);
+            bool parseString(const std::string& input, float defvalue);
+            bool parseString(const std::string& input, double defvalue);
+            bool parseString(const std::string& input, long double defvalue);
+            bool parseString(const std::string& input, bool defvalue);
+            bool parseString(const std::string& input, const std::string& defvalue);
+            bool parseString(const std::string& input, const char* defvalue);
+            bool parseString(const std::string& input, const Vector2& defvalue);
+            bool parseString(const std::string& input, const Vector3& defvalue);
+            bool parseString(const std::string& input, const ColourValue& defvalue);
+            bool parseString(const std::string& input, const Quaternion& defvalue);
+            bool parseString(const std::string& input, const Radian& defvalue);
+            bool parseString(const std::string& input, const Degree& defvalue);
 
             static std::list<std::string>& getConfigFileLines();
@@ -167,24 +144,8 @@
             std::string         defvalueString_;                //!< The string of the default-variable
 
-            union MultiType
-            {
-                int                 value_int_;                 //!< The value, if the variable is of the type int
-                unsigned int        value_uint_;                //!< The value, if the variable is of the type unsigned int
-                char                value_char_;                //!< The value, if the variable is of the type char
-                unsigned char       value_uchar_;               //!< The value, if the variable is of the type unsigned char
-                float               value_float_;               //!< The value, if the variable is of the type float
-                double              value_double_;              //!< The value, if the variable is of the type double
-                long double         value_long_double_;         //!< The value, if the variable is of the type long double
-                bool                value_bool_;                //!< The value, if the variable is of the type bool
-            } value_;                                           //!< The value of the variable
-
-            std::string         value_string_;                  //!< The value, if the variable is of the type string
-            Vector2             value_vector2_;                 //!< The value, if the variable is of the type Vector2
-            Vector3             value_vector3_;                 //!< The value, if the variable is of the type Vector3
-            ColourValue         value_colourvalue_;             //!< The value, if the variable is of the type ColourValue
+            MultiTypeMath       value_;                         //!< The value
 
             std::list<std::string>::iterator configFileLine_;   //!< An iterator, pointing to the entry of the variable in the config-file
 
-            VariableType type_;                                 //!< The type of the variable
             bool bAddedDescription_;                            //!< True if a description was added
             LanguageEntryName description_;                     //!< The description
Index: code/branches/core/src/orxonox/core/CoreIncludes.h
===================================================================
--- code/branches/core/src/orxonox/core/CoreIncludes.h	(revision 791)
+++ code/branches/core/src/orxonox/core/CoreIncludes.h	(revision 792)
@@ -139,5 +139,5 @@
         this->getIdentifier()->setConfigValueContainer(#varname, container##varname); \
     } \
-    container##varname->getValue(varname)
+    container##varname->getValue(&varname)
 
 /**
@@ -150,5 +150,5 @@
     { \
         container##varname##reset->resetConfigValue(); \
-        container##varname##reset->getValue(varname); \
+        container##varname##reset->getValue(&varname); \
     } \
     else \
Index: code/branches/core/src/orxonox/core/CorePrereqs.h
===================================================================
--- code/branches/core/src/orxonox/core/CorePrereqs.h	(revision 791)
+++ code/branches/core/src/orxonox/core/CorePrereqs.h	(revision 792)
@@ -27,5 +27,5 @@
 
 /**
- @file  OrxonoxPrereq.h
+ @file  CorePrereq.h
  @brief Contains all the necessary forward declarations for all classes, structs and enums.
  */
Index: code/branches/core/src/orxonox/core/Loader.cc
===================================================================
--- code/branches/core/src/orxonox/core/Loader.cc	(revision 792)
+++ code/branches/core/src/orxonox/core/Loader.cc	(revision 792)
@@ -0,0 +1,378 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 "Loader.h"
+#include "Identifier.h"
+#include "Iterator.h"
+#include "BaseObject.h"
+#include "util/tinyxml/tinyxml.h"
+
+namespace orxonox
+{
+    std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > Loader::files_s;
+
+    // ###############################
+    // ###          open           ###
+    // ###############################
+    // Single file
+    bool Loader::open(const std::string& file)
+    {
+        return Loader::open(file, ClassIdentifier<BaseObject>::getIdentifier());
+    }
+
+    bool Loader::open(const std::string& file, const Identifier* subclassInclude)
+    {
+        return Loader::open(file, subclassInclude, 0);
+    }
+
+    bool Loader::open(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude)
+    {
+        return Loader::open(file, subclassInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::open(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude)
+    {
+        return Loader::open(file, std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
+    }
+
+    bool Loader::open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude)
+    {
+        return Loader::open(file, subclassesInclude, 0);
+    }
+
+    bool Loader::open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
+    {
+        return Loader::open(file, subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude)
+    {
+        return Loader::open(std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >(1, std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(file, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(subclassesInclude, subclassesExclude))));
+    }
+
+
+    // Multiple files with common conditions
+    bool Loader::open(const std::vector<std::string>& files)
+    {
+        return Loader::open(files, ClassIdentifier<BaseObject>::getIdentifier());
+    }
+
+    bool Loader::open(const std::vector<std::string>& files, const Identifier* subclassInclude)
+    {
+        return Loader::open(files, subclassInclude, 0);
+    }
+
+    bool Loader::open(const std::vector<std::string>& files, const Identifier* subclassInclude, const Identifier* subclassExclude)
+    {
+        return Loader::open(files, subclassInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::open(const std::vector<std::string>& files, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude)
+    {
+        return Loader::open(files, std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
+    }
+
+    bool Loader::open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude)
+    {
+        return Loader::open(files, subclassesInclude, 0);
+    }
+
+    bool Loader::open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
+    {
+        return Loader::open(files, subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude)
+    {
+        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
+        for (std::vector<std::string>::const_iterator it = files.begin(); it < files.end(); ++it)
+            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(*it, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(subclassesInclude, subclassesExclude)));
+
+        return Loader::open(temp);
+    }
+
+
+    // Multiple files with individual conditions
+    bool Loader::open(const std::vector<std::pair<std::string, const Identifier*> >& files)
+    {
+        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
+        for (std::vector<std::pair<std::string, const Identifier*> >::const_iterator it = files.begin(); it < files.end(); ++it)
+            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(std::vector<const Identifier*>(1, it->second), std::vector<const Identifier*>(1, (const Identifier*)0))));
+
+        return Loader::open(temp);
+    }
+
+    bool Loader::open(const std::vector<std::pair<std::string, std::pair<const Identifier*, const Identifier*> > >& files)
+    {
+        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
+        for (std::vector<std::pair<std::string, std::pair<const Identifier*, const Identifier*> > >::const_iterator it = files.begin(); it < files.end(); ++it)
+            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(std::vector<const Identifier*>(1, it->second.first), std::vector<const Identifier*>(1, it->second.second))));
+
+        return Loader::open(temp);
+    }
+
+    bool Loader::open(const std::vector<std::pair<std::string, std::pair<const Identifier*, std::vector<const Identifier*> > > >& files)
+    {
+        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
+        for (std::vector<std::pair<std::string, std::pair<const Identifier*, std::vector<const Identifier*> > > >::const_iterator it = files.begin(); it < files.end(); ++it)
+            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(std::vector<const Identifier*>(1, it->second.first), it->second.second)));
+
+        return Loader::open(temp);
+    }
+
+    bool Loader::open(const std::vector<std::pair<std::string, std::vector<const Identifier*> > >& files)
+    {
+        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
+        for (std::vector<std::pair<std::string, std::vector<const Identifier*> > >::const_iterator it = files.begin(); it < files.end(); ++it)
+            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(it->second, std::vector<const Identifier*>(1, (const Identifier*)0))));
+
+        return Loader::open(temp);
+    }
+
+    bool Loader::open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, const Identifier*> > >& files)
+    {
+        std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > temp;
+        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, const Identifier*> > >::const_iterator it = files.begin(); it < files.end(); ++it)
+            temp.insert(temp.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(it->first, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(it->second.first, std::vector<const Identifier*>(1, it->second.second))));
+
+        return Loader::open(temp);
+    }
+
+    bool Loader::open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files)
+    {
+        Loader::files_s = files;
+        Loader::unload();
+        return Loader::load(Loader::files_s);
+    }
+
+    // ###############################
+    // ###           add           ###
+    // ###############################
+    bool Loader::add(const std::string& file)
+    {
+        return Loader::add(file, ClassIdentifier<BaseObject>::getIdentifier());
+    }
+
+    bool Loader::add(const std::string& file, const Identifier* subclassInclude)
+    {
+        return Loader::add(file, subclassInclude, 0);
+    }
+
+    bool Loader::add(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude)
+    {
+        return Loader::add(file, std::vector<const Identifier*>(1, subclassInclude), std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::add(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude)
+    {
+        return Loader::add(file, std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
+    }
+
+    bool Loader::add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude)
+    {
+        return Loader::add(file, subclassesInclude, 0);
+    }
+
+    bool Loader::add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
+    {
+        return Loader::add(file, subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude)
+    {
+        Loader::files_s.insert(Loader::files_s.end(), std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > >(file, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> >(subclassesInclude, subclassesExclude)));
+        return Loader::load(file, subclassesInclude, subclassesExclude);
+    }
+
+    // ###############################
+    // ###         remove          ###
+    // ###############################
+    void Loader::remove()
+    {
+        Loader::files_s.clear();
+    }
+
+    void Loader::remove(const std::vector<std::string>& files)
+    {
+        for (std::vector<std::string>::const_iterator it = files.begin(); it < files.end(); ++it)
+            Loader::remove(*it);
+    }
+
+    void Loader::remove(const std::string& file)
+    {
+        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >::iterator it = Loader::files_s.begin(); it < Loader::files_s.end(); ++it)
+            if (it->first.compare(file) == 0)
+                Loader::files_s.erase(it);
+    }
+
+    // ###############################
+    // ###         reload          ###
+    // ###############################
+    bool Loader::reload()
+    {
+        return Loader::reload(ClassIdentifier<BaseObject>::getIdentifier());
+    }
+
+    bool Loader::reload(const Identifier* subclassInclude)
+    {
+        return Loader::reload(subclassInclude, 0);
+    }
+
+    bool Loader::reload(const Identifier* subclassInclude, const Identifier* subclassExclude)
+    {
+        return Loader::reload(std::vector<const Identifier*>(1, subclassInclude), std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::reload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        return Loader::reload(std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
+    }
+
+    bool Loader::reload(const std::vector<const Identifier*>& subclassesInclude)
+    {
+        return Loader::reload(subclassesInclude, 0);
+    }
+
+    bool Loader::reload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
+    {
+        return Loader::reload(subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    bool Loader::reload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        Loader::unload(subclassesInclude, subclassesExclude);
+        return Loader::load(Loader::files_s, subclassesInclude, subclassesExclude);
+    }
+
+    // ###############################
+    // ###         unload          ###
+    // ###############################
+    void Loader::unload()
+    {
+        Loader::unload(ClassIdentifier<BaseObject>::getIdentifier());
+    }
+
+    void Loader::unload(const Identifier* subclassInclude)
+    {
+        Loader::unload(subclassInclude, 0);
+    }
+
+    void Loader::unload(const Identifier* subclassInclude, const Identifier* subclassExclude)
+    {
+        Loader::unload(std::vector<const Identifier*>(1, subclassInclude), std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    void Loader::unload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        Loader::unload(std::vector<const Identifier*>(1, subclassInclude), subclassesExclude);
+    }
+
+    void Loader::unload(const std::vector<const Identifier*>& subclassesInclude)
+    {
+        Loader::unload(subclassesInclude, 0);
+    }
+
+    void Loader::unload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude)
+    {
+        Loader::unload(subclassesInclude, std::vector<const Identifier*>(1, subclassExclude));
+    }
+
+    void Loader::unload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        for (Iterator<BaseObject> it = ObjectList<BaseObject>::start(); it; )
+        {
+            bool isIncluded = false;
+            for (std::vector<const Identifier*>::const_iterator it_in = subclassesInclude.begin(); it_in < subclassesInclude.end(); ++it_in)
+            {
+                if (it->isA(*it_in))
+                {
+                    isIncluded = true;
+                    break;
+                }
+            }
+
+            if (isIncluded)
+            {
+                bool isExcluded = false;
+                for (std::vector<const Identifier*>::const_iterator it_ex = subclassesInclude.begin(); it_ex < subclassesInclude.end(); ++it_ex)
+                {
+                    if (it->isA(*it_ex))
+                    {
+                        isExcluded = true;
+                        break;
+                    }
+                }
+
+                if (!isExcluded)
+                {
+                    delete *(it++);
+                    continue;
+                }
+            }
+
+            ++it;
+        }
+    }
+
+    // ###############################
+    // ###          load           ###
+    // ###############################
+    bool Loader::load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files)
+    {
+        bool success = true;
+        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >::const_iterator it = files.begin(); it < files.end(); ++it)
+            if (!Loader::load(it->first, it->second.first, it->second.second))
+                success = false;
+
+        return success;
+    }
+
+    bool Loader::load(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        bool success = true;
+        for (std::vector<std::string>::const_iterator it = files.begin(); it < files.end(); ++it)
+            if (!Loader::load(*it, subclassesInclude, subclassesExclude))
+                success = false;
+
+        return success;
+    }
+
+    bool Loader::load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        bool success = true;
+        for (std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >::const_iterator it = files.begin(); it < files.end(); ++it)
+            if (!Loader::load(it->first, subclassesInclude, subclassesExclude))
+                success = false;
+
+        return success;
+    }
+
+    bool Loader::load(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude)
+    {
+        // ...load... //
+    }
+}
Index: code/branches/core/src/orxonox/core/Loader.h
===================================================================
--- code/branches/core/src/orxonox/core/Loader.h	(revision 792)
+++ code/branches/core/src/orxonox/core/Loader.h	(revision 792)
@@ -0,0 +1,107 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 _Loader_H__
+#define _Loader_H__
+
+#include <string>
+#include <vector>
+
+#include "CorePrereqs.h"
+
+namespace orxonox
+{
+    class Loader
+    {
+        public:
+            static bool open(const std::string& file);
+            static bool open(const std::string& file, const Identifier* subclassInclude);
+            static bool open(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude);
+            static bool open(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude);
+            static bool open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude);
+            static bool open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
+            static bool open(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude);
+
+            static bool open(const std::vector<std::string>& files);
+            static bool open(const std::vector<std::string>& files, const Identifier* subclassInclude);
+            static bool open(const std::vector<std::string>& files, const Identifier* subclassInclude, const Identifier* subclassExclude);
+            static bool open(const std::vector<std::string>& files, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude);
+            static bool open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude);
+            static bool open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
+            static bool open(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude);
+
+            static bool open(const std::vector<std::pair<std::string, const Identifier*> >& files);
+            static bool open(const std::vector<std::pair<std::string, std::pair<const Identifier*, const Identifier*> > >& files);
+            static bool open(const std::vector<std::pair<std::string, std::pair<const Identifier*, std::vector<const Identifier*> > > >& files);
+            static bool open(const std::vector<std::pair<std::string, std::vector<const Identifier*> > >& files);
+            static bool open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, const Identifier*> > >& files);
+            static bool open(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files);
+
+
+            static bool add(const std::string& file);
+            static bool add(const std::string& file, const Identifier* subclassInclude);
+            static bool add(const std::string& file, const Identifier* subclassInclude, const Identifier* subclassExclude);
+            static bool add(const std::string& file, const Identifier* subclassInclude, std::vector<const Identifier*> subclassesExclude);
+            static bool add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude);
+            static bool add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
+            static bool add(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, std::vector<const Identifier*> subclassesExclude);
+
+
+            static void remove();
+            static void remove(const std::vector<std::string>& files);
+            static void remove(const std::string& file);
+
+
+            static bool reload();
+            static bool reload(const Identifier* subclassInclude);
+            static bool reload(const Identifier* subclassInclude, const Identifier* subclassExclude);
+            static bool reload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude);
+            static bool reload(const std::vector<const Identifier*>& subclassesInclude);
+            static bool reload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
+            static bool reload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
+
+
+            static void unload();
+            static void unload(const Identifier* subclassInclude);
+            static void unload(const Identifier* subclassInclude, const Identifier* subclassExclude);
+            static void unload(const Identifier* subclassInclude, const std::vector<const Identifier*>& subclassesExclude);
+            static void unload(const std::vector<const Identifier*>& subclassesInclude);
+            static void unload(const std::vector<const Identifier*>& subclassesInclude, const Identifier* subclassExclude);
+            static void unload(const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
+
+        private:
+            static bool load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files);
+            static bool load(const std::vector<std::string>& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
+            static bool load(const std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > >& files, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
+            static bool load(const std::string& file, const std::vector<const Identifier*>& subclassesInclude, const std::vector<const Identifier*>& subclassesExclude);
+
+
+            static std::vector<std::pair<std::string, std::pair<std::vector<const Identifier*>, std::vector<const Identifier*> > > > files_s;
+    };
+}
+
+#endif /* _Loader_H__ */
Index: code/branches/core/src/orxonox/core/OrxonoxClass.h
===================================================================
--- code/branches/core/src/orxonox/core/OrxonoxClass.h	(revision 791)
+++ code/branches/core/src/orxonox/core/OrxonoxClass.h	(revision 792)
@@ -47,5 +47,5 @@
     //! The class all objects and interfaces of the game-logic (not the engine) are derived from.
     /**
-        The BaseObject and Interaces are derived with 'virtual public OrxonoxClass' from OrxonoxClass.
+        The BaseObject and Interfaces are derived with 'virtual public OrxonoxClass' from OrxonoxClass.
         OrxonoxClass is needed to create the class-hierarchy at startup and to store the Identifier and the MetaObjectList.
     */
Index: code/branches/core/src/util/CMakeLists.txt
===================================================================
--- code/branches/core/src/util/CMakeLists.txt	(revision 791)
+++ code/branches/core/src/util/CMakeLists.txt	(revision 792)
@@ -5,16 +5,20 @@
 SET (UTIL_SRC_FILES
   ${TINYXML_SRC_FILES}
+  Math.cc
+  String.cc
   substring.cc
+  MultiTypePrimitive.cc
+  MultiTypeString.cc
+  MultiTypeMath.cc
 )
 
-IF(WIN32)
-  ADD_LIBRARY( util ${UTIL_SRC_FILES} )
-ELSE(WIN32)
-  ADD_LIBRARY( util SHARED ${UTIL_SRC_FILES} )
-ENDIF(WIN32)
+ADD_LIBRARY( util SHARED ${UTIL_SRC_FILES} )
 SET_TARGET_PROPERTIES( util PROPERTIES LINK_FLAGS "--no-undefined" )
-
 
 IF(TESTING_ENABLED)
   ADD_SUBDIRECTORY(testing)
 ENDIF(TESTING_ENABLED)
+
+TARGET_LINK_LIBRARIES( util
+  ${OGRE_LIBRARIES}
+)
Index: code/branches/core/src/util/Convert.h
===================================================================
--- code/branches/core/src/util/Convert.h	(revision 791)
+++ code/branches/core/src/util/Convert.h	(revision 792)
@@ -36,8 +36,9 @@
 #include <sstream>
 
+#include "UtilPrereqs.h"
 
 // DEFAULT CLASS
 template <typename FromType, typename ToType>
-class Converter
+class _UtilExport Converter
 {
  public:
@@ -50,5 +51,5 @@
 // PARTIAL SPECIALIZATION TO CONVERT TO STRINGS
 template<typename FromType>
-class Converter<FromType, std::string>
+class _UtilExport Converter<FromType, std::string>
 {
  public:
@@ -68,5 +69,5 @@
 // PARTIAL SPECIALIZATION TO CONVERT FROM STRING
 template<typename ToType>
-class Converter<std::string, ToType>
+class _UtilExport Converter<std::string, ToType>
 {
  public:
@@ -83,5 +84,5 @@
 // FUNCTION SO WE DO NOT HAVE TO TELL THE COMPILER ABOUT THE TYPE
 template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input)
+static _UtilExport bool ConvertValue(ToType* output, const FromType& input)
 {
   Converter<FromType, ToType> converter;
@@ -91,5 +92,5 @@
 // THE SAME, BUT WITH DEFAULT VALUE
 template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+static _UtilExport bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
 {
   Converter<FromType, ToType> converter;
Index: code/branches/core/src/util/Math.cc
===================================================================
--- code/branches/core/src/util/Math.cc	(revision 792)
+++ code/branches/core/src/util/Math.cc	(revision 792)
@@ -0,0 +1,68 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 "Math.h"
+
+/**
+    @brief Function for writing to a stream.
+*/
+std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
+{
+    out << radian.valueRadians();
+    return out;
+}
+
+/**
+    @brief Function for reading from a stream.
+*/
+std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
+{
+    float temp;
+    in >> temp;
+    radian = temp;
+    return in;
+}
+
+/**
+    @brief Function for writing to a stream.
+*/
+std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
+{
+    out << degree.valueDegrees();
+    return out;
+}
+
+/**
+    @brief Function for reading from a stream.
+*/
+std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
+{
+    float temp;
+    in >> temp;
+    degree = temp;
+    return in;
+}
Index: code/branches/core/src/util/Math.h
===================================================================
--- code/branches/core/src/util/Math.h	(revision 791)
+++ code/branches/core/src/util/Math.h	(revision 792)
@@ -1,2 +1,36 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 _Math_H__
+#define _Math_H__
+
+#include <ostream>
+
+#include "UtilPrereqs.h"
+
 #include <OgreMath.h>
 #include <OgreVector2.h>
@@ -18,2 +52,97 @@
   typedef Ogre::ColourValue ColourValue;
 }
+
+_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
+_UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
+_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
+_UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
+
+template <typename T>
+inline _UtilExport T sgn(T x)
+{
+    return (x >= 0) ? 1 : -1;
+}
+
+template <typename T>
+inline _UtilExport T min(T a, T b)
+{
+    return (a <= b) ? a : b;
+}
+
+template <typename T>
+inline _UtilExport T max(T a, T b)
+{
+    return (a >= b) ? a : b;
+}
+
+template <typename T>
+inline _UtilExport T clamp(T x, T min, T max)
+{
+    if (x < min)
+        return min;
+
+    if (x > max)
+        return max;
+
+    return x;
+}
+
+template <typename T>
+inline _UtilExport T square(T x)
+{
+    return x*x;
+}
+
+template <typename T>
+inline _UtilExport T cube(T x)
+{
+    return x*x*x;
+}
+
+template <typename T>
+inline _UtilExport int floor(T x)
+{
+    return (int)(x);
+}
+
+template <typename T>
+inline _UtilExport int ceil(T x)
+{
+    int temp = floor(x);
+    return (temp != x) ? (temp + 1) : temp;
+}
+
+template <typename T>
+inline _UtilExport int round(T x)
+{
+    return (int)(x + 0.5);
+}
+
+template <typename T>
+_UtilExport T interpolate(float time, const T& start, const T& end)
+{
+    return time * (end - start) + start;
+}
+
+template <typename T>
+_UtilExport T interpolateSmooth(float time, const T& start, const T& end)
+{
+    return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
+}
+
+inline _UtilExport float rnd()
+{
+    return ((float)rand() / RAND_MAX);
+}
+
+inline _UtilExport float rnd(float max)
+{
+    return rnd() * max;
+}
+
+inline _UtilExport float rnd(float min, float max)
+{
+    return rnd(max - min) + min;
+}
+
+#endif /* _Math_H__ */
Index: code/branches/core/src/util/MultiType.h
===================================================================
--- code/branches/core/src/util/MultiType.h	(revision 792)
+++ code/branches/core/src/util/MultiType.h	(revision 792)
@@ -0,0 +1,75 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 _MultiType_H__
+#define _MultiType_H__
+
+#include "UtilPrereqs.h"
+
+enum _UtilExport MultiType
+{
+    MT_null,
+    MT_int,
+    MT_uint,
+    MT_char,
+    MT_uchar,
+    MT_short,
+    MT_ushort,
+    MT_long,
+    MT_ulong,
+    MT_float,
+    MT_double,
+    MT_longdouble,
+    MT_bool,
+    MT_constchar,
+    MT_string,
+    MT_vector2,
+    MT_vector3,
+    MT_colourvalue,
+    MT_quaternion,
+    MT_degree,
+    MT_radian
+};
+
+union _UtilExport MultiTypeValue
+{
+    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_;
+};
+
+#endif /* _MultiType_H__ */
Index: code/branches/core/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/core/src/util/MultiTypeMath.cc	(revision 792)
+++ code/branches/core/src/util/MultiTypeMath.cc	(revision 792)
@@ -0,0 +1,106 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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"
+
+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_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);
+}
+
+MultiTypeMath::MultiTypeMath(const MultiTypeMath& mtm)
+{
+    this->type_ = mtm.type_;
+    this->value_ = mtm.value_;
+}
+
+MultiTypeMath& MultiTypeMath::operator=(const MultiTypeMath& mtm)
+{
+    this->type_ = mtm.type_;
+    this->value_ = mtm.value_;
+    return *this;
+}
+
+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_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 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_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;
+}
+
+void MultiTypeMath::setValue(const MultiTypeMath& mtm)
+{
+    this->type_ = mtm.type_;
+    this->value_ = mtm.value_;
+}
Index: code/branches/core/src/util/MultiTypeMath.h
===================================================================
--- code/branches/core/src/util/MultiTypeMath.h	(revision 792)
+++ code/branches/core/src/util/MultiTypeMath.h	(revision 792)
@@ -0,0 +1,118 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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"
+
+class _UtilExport MultiTypeMath : public MultiTypeString
+{
+    public:
+        MultiTypeMath(MultiType      type = MT_null);
+        MultiTypeMath(int            value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned int   value) : MultiTypeString(value) {}
+        MultiTypeMath(char           value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned char  value) : MultiTypeString(value) {}
+        MultiTypeMath(short          value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned short value) : MultiTypeString(value) {}
+        MultiTypeMath(long           value) : MultiTypeString(value) {}
+        MultiTypeMath(unsigned long  value) : MultiTypeString(value) {}
+        MultiTypeMath(float          value) : MultiTypeString(value) {}
+        MultiTypeMath(double         value) : MultiTypeString(value) {}
+        MultiTypeMath(long double    value) : MultiTypeString(value) {}
+        MultiTypeMath(bool           value) : MultiTypeString(value) {}
+        MultiTypeMath(const char*        value) : MultiTypeString(value) {}
+        MultiTypeMath(const std::string& value) : MultiTypeString(value) {}
+        MultiTypeMath(const orxonox::Vector2&     value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Vector3&     value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::ColourValue& value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Quaternion&  value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Radian&      value) { this->setValue(value); }
+        MultiTypeMath(const orxonox::Degree&      value) { this->setValue(value); }
+        MultiTypeMath(const MultiTypeMath& mtm);
+
+        MultiTypeMath& operator=(const orxonox::Vector2&     value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Vector3&     value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::ColourValue& value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Quaternion&  value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Radian&      value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const orxonox::Degree&      value) { this->setValue(value); return *this; }
+        MultiTypeMath& operator=(const MultiTypeMath& mtm);
+
+        bool operator==(const orxonox::Vector2&     value) const { return (this->vector2_     == value); }
+        bool operator==(const orxonox::Vector3&     value) const { return (this->vector3_     == value); }
+        bool operator==(const orxonox::ColourValue& value) const { return (this->colourvalue_ == value); }
+        bool operator==(const orxonox::Quaternion&  value) const { return (this->quaternion_  == value); }
+        bool operator==(const orxonox::Radian&      value) const { return (this->radian_      == value); }
+        bool operator==(const orxonox::Degree&      value) const { return (this->degree_      == value); }
+        bool operator==(const MultiTypeMath& mtm) const;
+
+        bool operator!=(const orxonox::Vector2&     value) const { return (this->vector2_     != value); }
+        bool operator!=(const orxonox::Vector3&     value) const { return (this->vector3_     != value); }
+        bool operator!=(const orxonox::ColourValue& value) const { return (this->colourvalue_ != value); }
+        bool operator!=(const orxonox::Quaternion&  value) const { return (this->quaternion_  != value); }
+        bool operator!=(const orxonox::Radian&      value) const { return (this->radian_      != value); }
+        bool operator!=(const orxonox::Degree&      value) const { return (this->degree_      != value); }
+        bool operator!=(const MultiTypeMath& mtm) const;
+
+        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::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);
+
+        inline orxonox::Vector2&     getVector2()     { return this->vector2_;     }
+        inline orxonox::Vector3&     getVector3()     { return this->vector3_;     }
+        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_;      }
+
+        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::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_);      }
+
+    protected:
+        orxonox::Vector2      vector2_;
+        orxonox::Vector3      vector3_;
+        orxonox::ColourValue  colourvalue_;
+        orxonox::Quaternion   quaternion_;
+        orxonox::Radian       radian_;
+        orxonox::Degree       degree_;
+};
+
+#endif /* _MultiTypeMath_H__ */
Index: code/branches/core/src/util/MultiTypePrimitive.cc
===================================================================
--- code/branches/core/src/util/MultiTypePrimitive.cc	(revision 792)
+++ code/branches/core/src/util/MultiTypePrimitive.cc	(revision 792)
@@ -0,0 +1,146 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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"
+
+MultiTypePrimitive::MultiTypePrimitive(MultiType type)
+{
+    this->type_ = type;
+
+    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_.int_ = 0;
+}
+
+MultiTypePrimitive::MultiTypePrimitive(const MultiTypePrimitive& mtp)
+{
+    this->type_ = mtp.type_;
+    this->value_ = mtp.value_;
+}
+
+MultiTypePrimitive& MultiTypePrimitive::operator=(const MultiTypePrimitive& mtp)
+{
+    this->type_ = mtp.type_;
+    this->value_ = mtp.value_;
+    return *this;
+}
+
+bool MultiTypePrimitive::operator==(const MultiTypePrimitive& mtp) const
+{
+    if (this->type_ == mtp.type_)
+    {
+        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_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;
+}
+
+void MultiTypePrimitive::setValue(const MultiTypePrimitive& mtp)
+{
+    this->type_ = mtp.type_;
+    this->value_ = mtp.value_;
+}
Index: code/branches/core/src/util/MultiTypePrimitive.h
===================================================================
--- code/branches/core/src/util/MultiTypePrimitive.h	(revision 792)
+++ code/branches/core/src/util/MultiTypePrimitive.h	(revision 792)
@@ -0,0 +1,144 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 "MultiType.h"
+
+class _UtilExport MultiTypePrimitive
+{
+    public:
+        MultiTypePrimitive(MultiType      type = MT_null);
+        MultiTypePrimitive(int            value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned int   value) { this->setValue(value); }
+        MultiTypePrimitive(char           value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned char  value) { this->setValue(value); }
+        MultiTypePrimitive(short          value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned short value) { this->setValue(value); }
+        MultiTypePrimitive(long           value) { this->setValue(value); }
+        MultiTypePrimitive(unsigned long  value) { this->setValue(value); }
+        MultiTypePrimitive(float          value) { this->setValue(value); }
+        MultiTypePrimitive(double         value) { this->setValue(value); }
+        MultiTypePrimitive(long double    value) { this->setValue(value); }
+        MultiTypePrimitive(bool           value) { this->setValue(value); }
+        MultiTypePrimitive(const MultiTypePrimitive& mtp);
+
+        MultiTypePrimitive& operator=(int            value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned int   value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(char           value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned char  value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(short          value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned short value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(long           value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(unsigned long  value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(float          value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(double         value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(long double    value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(bool           value) { this->setValue(value); return *this; }
+        MultiTypePrimitive& operator=(const MultiTypePrimitive& mtp);
+
+        bool operator==(int            value) const { return (this->value_.int_        == value); }
+        bool operator==(unsigned int   value) const { return (this->value_.uint_       == value); }
+        bool operator==(char           value) const { return (this->value_.char_       == value); }
+        bool operator==(unsigned char  value) const { return (this->value_.uchar_      == value); }
+        bool operator==(short          value) const { return (this->value_.short_      == value); }
+        bool operator==(unsigned short value) const { return (this->value_.ushort_     == value); }
+        bool operator==(long           value) const { return (this->value_.long_       == value); }
+        bool operator==(unsigned long  value) const { return (this->value_.ulong_      == value); }
+        bool operator==(float          value) const { return (this->value_.float_      == value); }
+        bool operator==(double         value) const { return (this->value_.double_     == value); }
+        bool operator==(long double    value) const { return (this->value_.longdouble_ == value); }
+        bool operator==(bool           value) const { return (this->value_.bool_       == value); }
+        bool operator==(const MultiTypePrimitive& mtp) const;
+
+        bool operator!=(int            value) const { return (this->value_.int_        != value); }
+        bool operator!=(unsigned int   value) const { return (this->value_.uint_       != value); }
+        bool operator!=(char           value) const { return (this->value_.char_       != value); }
+        bool operator!=(unsigned char  value) const { return (this->value_.uchar_      != value); }
+        bool operator!=(short          value) const { return (this->value_.short_      != value); }
+        bool operator!=(unsigned short value) const { return (this->value_.ushort_     != value); }
+        bool operator!=(long           value) const { return (this->value_.long_       != value); }
+        bool operator!=(unsigned long  value) const { return (this->value_.ulong_      != value); }
+        bool operator!=(float          value) const { return (this->value_.float_      != value); }
+        bool operator!=(double         value) const { return (this->value_.double_     != value); }
+        bool operator!=(long double    value) const { return (this->value_.longdouble_ != value); }
+        bool operator!=(bool           value) const { return (this->value_.bool_       != value); }
+        bool operator!=(const MultiTypePrimitive& mtp) const;
+
+        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 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 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); }
+
+    protected:
+        MultiTypeValue  value_;
+        MultiType       type_;
+};
+
+#endif /* _MultiTypePrimitive_H__ */
Index: code/branches/core/src/util/MultiTypeString.cc
===================================================================
--- code/branches/core/src/util/MultiTypeString.cc	(revision 792)
+++ code/branches/core/src/util/MultiTypeString.cc	(revision 792)
@@ -0,0 +1,82 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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"
+
+MultiTypeString::MultiTypeString(MultiType type) : MultiTypePrimitive(type)
+{
+    if (type == MT_constchar)
+        this->string_ = std::string("");
+    else if (type == MT_string)
+        this->string_ = std::string("");
+}
+
+MultiTypeString::MultiTypeString(const MultiTypeString& mts)
+{
+    this->type_ = mts.type_;
+    this->value_ = mts.value_;
+}
+
+MultiTypeString& MultiTypeString::operator=(const MultiTypeString& mts)
+{
+    this->type_ = mts.type_;
+    this->value_ = mts.value_;
+    return *this;
+}
+
+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 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;
+}
+
+void MultiTypeString::setValue(const MultiTypeString& mts)
+{
+    this->type_ = mts.type_;
+    this->value_ = mts.value_;
+}
Index: code/branches/core/src/util/MultiTypeString.h
===================================================================
--- code/branches/core/src/util/MultiTypeString.h	(revision 792)
+++ code/branches/core/src/util/MultiTypeString.h	(revision 792)
@@ -0,0 +1,82 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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 <string>
+
+#include "UtilPrereqs.h"
+
+#include "MultiTypePrimitive.h"
+
+class _UtilExport MultiTypeString : public MultiTypePrimitive
+{
+    public:
+        MultiTypeString(MultiType      type = MT_null);
+        MultiTypeString(int            value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned int   value) : MultiTypePrimitive(value) {}
+        MultiTypeString(char           value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned char  value) : MultiTypePrimitive(value) {}
+        MultiTypeString(short          value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned short value) : MultiTypePrimitive(value) {}
+        MultiTypeString(long           value) : MultiTypePrimitive(value) {}
+        MultiTypeString(unsigned long  value) : MultiTypePrimitive(value) {}
+        MultiTypeString(float          value) : MultiTypePrimitive(value) {}
+        MultiTypeString(double         value) : MultiTypePrimitive(value) {}
+        MultiTypeString(long double    value) : MultiTypePrimitive(value) {}
+        MultiTypeString(bool           value) : MultiTypePrimitive(value) {}
+        MultiTypeString(const char*        value) { this->setValue(value); }
+        MultiTypeString(const std::string& value) { this->setValue(value); }
+        MultiTypeString(const MultiTypeString& mtp);
+
+        MultiTypeString& operator=(const char*        value) { this->setValue(value); return *this; }
+        MultiTypeString& operator=(const std::string& value) { this->setValue(value); return *this; }
+        MultiTypeString& operator=(const MultiTypeString& mtp);
+
+        bool operator==(const char*        value) const { return (this->string_ == std::string(value)); }
+        bool operator==(const std::string& value) const { return (this->string_ == value); }
+        bool operator==(const MultiTypeString& mtp) const;
+
+        bool operator!=(const char*        value) const { return (this->string_ != std::string(value)); }
+        bool operator!=(const std::string& value) const { return (this->string_ != value); }
+        bool operator!=(const MultiTypeString& mtp) const;
+
+        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& mtp);
+
+        inline std::string& getString() { return this->string_; }
+
+        inline void getValue(std::string* variable) const { (*variable) = std::string(this->string_); }
+
+    protected:
+        std::string string_;
+};
+
+#endif /* _MultiTypeString_H__ */
Index: code/branches/core/src/util/String.cc
===================================================================
--- code/branches/core/src/util/String.cc	(revision 792)
+++ code/branches/core/src/util/String.cc	(revision 792)
@@ -0,0 +1,213 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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:
+ *      Benjamin Grauer
+ *
+ */
+
+#include "String.h"
+
+/**
+    @brief Removes all whitespaces from a string.
+    @param str The string to strip
+*/
+void strip(std::string* str)
+{
+    unsigned int pos;
+    while ((pos = (*str).find(" ")) < (*str).length())
+        (*str).erase(pos, 1);
+    while ((pos = (*str).find("\t")) < (*str).length())
+        (*str).erase(pos, 1);
+}
+
+/**
+    @brief Returns a copy of a string without whitespaces.
+    @param str The string to strip
+    @return The stripped line
+*/
+std::string getStripped(const std::string& str)
+{
+    std::string output = std::string(str);
+    strip(&output);
+    return output;
+}
+
+/**
+    @brief Determines if a string in is a comment.
+    @param str The string to check
+    @return True = it's a comment
+
+    A comment is defined by a leading '#', '%', ';' or '//'.
+*/
+bool isComment(const std::string& str)
+{
+    // Strip the line, whitespaces are disturbing
+    std::string teststring = getStripped(str);
+
+    // There are four possible comment-symbols:
+    //  1) #comment in script-language style
+    //  2) %comment in matlab style
+    //  3) ;comment in unreal tournament config-file style
+    //  4) //comment in code style
+    if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[0] == '/'))
+        return true;
+
+    return false;
+}
+
+/**
+    @brief Determines if a string is empty (contains only whitespaces).
+    @param str The string to check
+    @return True = it's empty
+*/
+bool isEmpty(const std::string& str)
+{
+    return getStripped(str) == "";
+}
+
+/**
+    @brief Determines if a string contains only numbers and maximal one '.'.
+    @param str The string to check
+    @return True = it's a number
+*/
+bool isNumeric(const std::string& str)
+{
+    bool foundPoint = false;
+
+    for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    {
+        if (((*it) < '0' || (*it) > '9'))
+        {
+            if ((*it) != '.' && !foundPoint)
+                foundPoint = true;
+            else
+                return false;
+        }
+    }
+
+    return true;
+}
+
+/**
+    @brief Replaces each char between A and Z with its lowercase equivalent.
+    @param str The string to convert
+*/
+void lowercase(std::string* str)
+{
+    static unsigned const char difference_between_A_and_a = 'A' - 'a';
+
+    for (std::string::iterator it = (*str).begin(); it != (*str).end(); ++it)
+        if ((*it) >= 'A' && (*it) <= 'Z')
+            (*it) -= difference_between_A_and_a;
+}
+
+/**
+    @brief Returns a copy of the given string without uppercase chars.
+    @param str The string
+    @return The copy
+*/
+std::string getLowercase(const std::string& str)
+{
+    std::string output = std::string(str);
+    lowercase(&output);
+    return output;
+}
+
+/**
+    @brief Replaces each char between a and z with its uppercase equivalent.
+    @param str The string to convert
+*/
+void uppercase(std::string* str)
+{
+    static unsigned const char difference_between_A_and_a = 'A' - 'a';
+
+    for (std::string::iterator it = (*str).begin(); it != (*str).end(); ++it)
+        if ((*it) >= 'a' && (*it) <= 'z')
+            (*it) += difference_between_A_and_a;
+}
+
+/**
+    @brief Returns a copy of the given string without lowercase chars.
+    @param str The string
+    @return The copy
+*/
+std::string getUppercase(const std::string& str)
+{
+    std::string output = std::string(str);
+    uppercase(&output);
+    return output;
+}
+
+/**
+ * @brief compares two strings without ignoring the case
+ * @param s1 first string
+ * @param s2 second string
+ */
+int nocaseCmp(const std::string& s1, const std::string& s2)
+{
+    std::string::const_iterator it1=s1.begin();
+    std::string::const_iterator it2=s2.begin();
+
+    //stop when either string's end has been reached
+    while ( (it1!=s1.end()) && (it2!=s2.end()) )
+    {
+        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+            // return -1 to indicate smaller than, 1 otherwise
+            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+        //proceed to the next character in each string
+        ++it1;
+        ++it2;
+    }
+    size_t size1=s1.size(), size2=s2.size();// cache lengths
+    //return -1,0 or 1 according to strings' lengths
+    if (size1==size2)
+        return 0;
+    return (size1<size2) ? -1 : 1;
+}
+
+
+/**
+ * @brief compares two strings without ignoring the case
+ * @param s1 first string
+ * @param s2 second string
+ * @param len how far from the beginning to start.
+ */
+int nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len)
+{
+    if (len == 0)
+        return 0;
+    std::string::const_iterator it1=s1.begin();
+    std::string::const_iterator it2=s2.begin();
+
+    //stop when either string's end has been reached
+    while ( (it1!=s1.end()) && (it2!=s2.end()) && len-- > 0)
+    {
+        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+            // return -1 to indicate smaller than, 1 otherwise
+            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+        //proceed to the next character in each string
+        ++it1;
+        ++it2;
+    }
+    return 0;
+}
Index: code/branches/core/src/util/String.h
===================================================================
--- code/branches/core/src/util/String.h	(revision 792)
+++ code/branches/core/src/util/String.h	(revision 792)
@@ -0,0 +1,146 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   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:
+ *      Benjamin Grauer
+ *
+ */
+
+#ifndef _String_H__
+#define _String_H__
+
+#include <string>
+#include <sstream>
+
+#include "UtilPrereqs.h"
+
+_UtilExport void        strip(std::string* str);
+_UtilExport std::string getStripped(const std::string& str);
+
+_UtilExport bool        isEmpty(const std::string& str);
+_UtilExport bool        isComment(const std::string& str);
+_UtilExport bool        isNumeric(const std::string& str);
+
+_UtilExport void        lowercase(std::string* str);
+_UtilExport std::string getLowercase(const std::string& str);
+
+_UtilExport void        uppercase(std::string* str);
+_UtilExport std::string getUppercase(const std::string& str);
+
+_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
+_UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, unsigned int len);
+
+//! The Convert class has some static member functions to convert strings to values and values to strings.
+class _UtilExport Convert
+{
+    public:
+        /**
+            @brief Converts a value of any type to a string.
+            @param output The string to write the result in
+            @param input The variable to convert
+            @return True if the conversion succeded
+
+            @example
+            float f = 3.14;
+            std::string output;
+            bool success = Convert::ToString(output, f);
+        */
+        template <typename T>
+        static bool ToString(std::string* output, T input)
+        {
+            std::ostringstream oss;
+            if (oss << input)
+            {
+                (*output) = oss.str();
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+            @brief Converts a value of any type to a string and assigns a defaultvalue if the conversion fails.
+            @param output The string to write the result in
+            @param input The variable to convert
+            @param fallbackString The assigned string if the conversion fails.
+            @return True if the conversion succeeded
+
+            @example
+            float f = 3.14;
+            std::string output;
+            bool success = Convert::ToString(output, f, "0.000000");
+        */
+        template <typename T>
+        static bool ToString(std::string* output, T input, const std::string& fallbackString)
+        {
+            if (Convert::ToString(output, input))
+                return true;
+
+            (*output) = fallbackString;
+            return false;
+        }
+
+        /**
+            @brief Converts a string to a value of any type.
+            @param output The variable to assign the result to
+            @param input The string to convert
+            @return True if the conversion succeeded
+
+            @example
+            std::string input = "3.14";
+            float f;
+            bool success = string2Number(f, input);
+        */
+        template <typename T>
+        static bool FromString(T* output, const std::string& input)
+        {
+            std::istringstream iss(input);
+            if (iss >> (*output))
+                return true;
+
+            return false;
+        }
+
+        /**
+            @brief Converts a string to a value of any type.
+            @param output The variable to assign the result to
+            @param input The string to convert
+            @param fallbackValue The assigned value if the conversion fails
+            @return True if the conversion succeeded
+
+            @example
+            std::string input = "3.14";
+            float f;
+            bool success = string2Number(f, input, 0.000000);
+        */
+        template <typename T>
+        static bool FromString(T* output, const std::string& input, T fallbackValue)
+        {
+            if (Convert::FromString(output, input))
+                return true;
+
+            (*output) = fallbackValue;
+            return false;
+        }
+};
+
+#endif /* _String_H__ */
Index: code/branches/core/src/util/String2Number.h
===================================================================
--- code/branches/core/src/util/String2Number.h	(revision 791)
+++ code/branches/core/src/util/String2Number.h	(revision 792)
@@ -7,4 +7,5 @@
 
 #include "core/Debug.h"
+#include "UtilPrereqs.h"
 
 /**
@@ -23,5 +24,5 @@
 
 template <class T>
-class String2Number
+class _UtilExport String2Number
 {
   private:
Index: code/branches/core/src/util/UtilPrereqs.h
===================================================================
--- code/branches/core/src/util/UtilPrereqs.h	(revision 792)
+++ code/branches/core/src/util/UtilPrereqs.h	(revision 792)
@@ -0,0 +1,71 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      Fabian 'x3n' Landau
+ *
+ */
+
+/**
+ @file  UtilPrereq.h
+ @brief Contains all the necessary forward declarations for all classes, structs and enums.
+ */
+
+#ifndef _UtilPrereqs_H__
+#define _UtilPrereqs_H__
+
+#include "orxonox/OrxonoxPlatform.h"
+
+//-----------------------------------------------------------------------
+// Shared library settings
+//-----------------------------------------------------------------------
+#if (ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32) && !defined( UTIL_STATIC_BUILD )
+#  ifdef UTIL_SHARED_BUILD
+#    define _UtilExport __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define _UtilExport
+#    else
+#      define _UtilExport __declspec(dllimport)
+#    endif
+#  endif
+#elif defined ( ORXONOX_GCC_VISIBILITY )
+#  define _UtilExport  __attribute__ ((visibility("default")))
+#else
+#  define _UtilExport
+#endif
+
+
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+class Convert;
+template <typename FromType, typename ToType>
+class Converter;
+class MultiTypePrimitive;
+class MultiTypeString;
+class MultiTypeMath;
+template <class T>
+class String2Number;
+class SubString;
+
+#endif /* _UtilPrereqs_H__ */
Index: code/branches/core/src/util/substring.h
===================================================================
--- code/branches/core/src/util/substring.h	(revision 791)
+++ code/branches/core/src/util/substring.h	(revision 792)
@@ -59,4 +59,5 @@
 #include <string>
 
+#include "UtilPrereqs.h"
 
 //! A class that can load one string and split it in multipe ones
@@ -65,5 +66,5 @@
  * It can be used, to Split strings append them and join them again.
  */
-class SubString
+class _UtilExport SubString
 {
 public:
