Index: code/branches/core2/src/orxonox/core/CommandExecutor.cc
===================================================================
--- code/branches/core2/src/orxonox/core/CommandExecutor.cc	(revision 955)
+++ code/branches/core2/src/orxonox/core/CommandExecutor.cc	(revision 957)
@@ -192,24 +192,28 @@
                 break;
             case CS_Shortcut_Params:
-                // not enough parameters but lets hope there are some additional parameters
-                if (evaluation.shortcut_ != 0)
-                    return evaluation.shortcut_->parse(tokens.subSet(1).join() + " " + evaluation.additionalParameter_);
-                break;
+                // not enough parameters but lets hope there are some additional parameters and go on
             case CS_Shortcut_Finished:
                 // call the shortcut
                 if (evaluation.shortcut_ != 0)
-                    return evaluation.shortcut_->parse(tokens.subSet(1).join() + " " + evaluation.additionalParameter_);
+                {
+                    if (tokens.size() >= 2)
+                        return evaluation.shortcut_->parse(tokens.subSet(1).join() + " " + evaluation.additionalParameter_);
+                    else
+                        return evaluation.shortcut_->parse(evaluation.additionalParameter_);
+                }
                 break;
             case CS_Function:
                 break;
             case CS_Function_Params:
-                // not enough parameters but lets hope there are some additional parameters
-                if (evaluation.function_ != 0)
-                    return evaluation.function_->parse(tokens.subSet(2).join() + " " + evaluation.additionalParameter_);
-                break;
+                // not enough parameters but lets hope there are some additional parameters and go on
             case CS_Function_Finished:
                 // call the shortcut
                 if (evaluation.function_ != 0)
-                    return evaluation.function_->parse(tokens.subSet(2).join() + " " + evaluation.additionalParameter_);
+                {
+                    if (tokens.size() >= 3)
+                        return evaluation.function_->parse(tokens.subSet(2).join() + " " + evaluation.additionalParameter_);
+                    else
+                        return evaluation.function_->parse(evaluation.additionalParameter_);
+                }
                 break;
             case CS_ConfigValueClass:
@@ -218,18 +222,29 @@
                 break;
             case CS_ConfigValueType:
-                // not enough parameters but lets hope there are some additional parameters
-                if (evaluation.configvalue_ != 0)
-                    return evaluation.configvalue_->parseString(tokens.subSet(3).join() + " " + evaluation.additionalParameter_);
-                break;
+                // not enough parameters but lets hope there are some additional parameters and go on
             case CS_ConfigValueFinished:
                 // set the config value
                 if (evaluation.configvalue_ != 0)
-                    return evaluation.configvalue_->parseString(tokens.subSet(3).join() + " " + evaluation.additionalParameter_);
+                {
+                    if ((tokens.size() >= 1) && (tokens[0] == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE))
+                    {
+                        if (tokens.size() >= 4)
+                            return evaluation.configvalue_->set(tokens.subSet(3).join() + " " + evaluation.additionalParameter_);
+                        else
+                            return evaluation.configvalue_->set(evaluation.additionalParameter_);
+                    }
+                    else if ((tokens.size() >= 1) && (tokens[0] == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE_TEMPORARY))
+                    {
+                        if (tokens.size() >= 4)
+                            return evaluation.configvalue_->tset(tokens.subSet(3).join() + " " + evaluation.additionalParameter_);
+                        else
+                            return evaluation.configvalue_->tset(evaluation.additionalParameter_);
+                    }
+                }
                 break;
             case CS_KeybindKey:
                 break;
             case CS_KeybindCommand:
-                // not enough parameters but lets hope there are some additional parameters
-                break;
+                // not enough parameters but lets hope there are some additional parameters and go on
             case CS_KeybindFinished:
                 // set the keybind
@@ -980,5 +995,5 @@
 
             if (executor->defaultValueSet(i))
-                output += "]";
+                output += "=" + executor->getDefaultValue(i).toString() + "]";
             else
                 output += "}";
@@ -989,5 +1004,6 @@
     std::string CommandExecutor::dump(const ConfigValueContainer* container)
     {
-        return container->getTypename();
+        AddLanguageEntry("CommandExecutor::oldvalue", "old value");
+        return "{" + container->getTypename() + "} (" + GetLocalisation("CommandExecutor::oldvalue") + ": " + container->toString() + ")";
     }
 
Index: code/branches/core2/src/orxonox/core/CommandExecutor.h
===================================================================
--- code/branches/core2/src/orxonox/core/CommandExecutor.h	(revision 955)
+++ code/branches/core2/src/orxonox/core/CommandExecutor.h	(revision 957)
@@ -68,4 +68,6 @@
     class _CoreExport CommandEvaluation
     {
+        friend class CommandExecutor;
+
         public:
             CommandEvaluation();
@@ -75,4 +77,5 @@
             bool isValid() const;
 
+        private:
             std::string processedCommand_;
             SubString tokens_;
Index: code/branches/core2/src/orxonox/core/ConfigValueContainer.cc
===================================================================
--- code/branches/core2/src/orxonox/core/ConfigValueContainer.cc	(revision 955)
+++ code/branches/core2/src/orxonox/core/ConfigValueContainer.cc	(revision 957)
@@ -34,7 +34,7 @@
 
 #include "ConfigValueContainer.h"
-#include "util/Tokenizer.h"
-#include "util/Convert.h"
 #include "Language.h"
+#include "Iterator.h"
+#include "BaseObject.h"
 
 #define CONFIGFILEPATH "orxonox.ini"
@@ -49,129 +49,48 @@
         @param defvalue The default-value
     */
-    ConfigValueContainer::ConfigValueContainer(const std::string& classname, const std::string& varname, MultiTypeMath defvalue)
+    ConfigValueContainer::ConfigValueContainer(Identifier* identifier, const std::string& varname, MultiTypeMath defvalue)
     {
         this->bAddedDescription_ = false;
-        this->classname_ = classname;
+        this->identifier_ = identifier;
         this->varname_ = varname;
 
-        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(!(defvalue.isA(MT_string) || defvalue.isA(MT_constchar)));     // Parses the value string from the config-file-entry
-        if (!this->parseString(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 (input.getType() == MT_int)
-            return ConvertValue(output, input.getInt(), std::string("0"));
-        else if (input.getType() == MT_uint)
-            return ConvertValue(output, input.getUnsignedInt(), std::string("0"));
-        else if (input.getType() == MT_char)
-            return ConvertValue(output, (int)input.getChar(), std::string("0"));
-        else if (input.getType() == MT_uchar)
-            return ConvertValue(output, (unsigned int)input.getUnsignedChar(), std::string("0"));
-        else if (input.getType() == MT_short)
-            return ConvertValue(output, input.getShort(), std::string("0"));
-        else if (input.getType() == MT_ushort)
-            return ConvertValue(output, input.getUnsignedShort(), std::string("0"));
-        else if (input.getType() == MT_long)
-            return ConvertValue(output, input.getLong(), std::string("0"));
-        else if (input.getType() == MT_ulong)
-            return ConvertValue(output, input.getUnsignedLong(), std::string("0"));
-        else if (input.getType() == MT_float)
-            return ConvertValue(output, input.getFloat(), std::string("0.000000"));
-        else if (input.getType() == MT_double)
-            return ConvertValue(output, input.getDouble(), std::string("0.000000"));
-        else if (input.getType() == MT_longdouble)
-            return ConvertValue(output, input.getChar(), std::string("0.000000"));
-        else if (input.getType() == MT_bool)
-        {
-            if (input.getBool())
-                (*output) = "true";
-            else
-                (*output) = "false";
-
-            return true;
-        }
-        else if (input.getType() == MT_constchar)
-        {
-            (*output) = "\"" + input.getString() + "\"";
-            return true;
-        }
-        else if (input.getType() == MT_string)
-        {
-            (*output) = "\"" + input.getString() + "\"";
-            return true;
-        }
-        else if (input.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 (input.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 (input.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 (input.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 (input.getType() == MT_radian)
-            return ConvertValue(output, input.getRadian(), std::string("0.000000"));
-        else if (input.getType() == MT_degree)
-            return ConvertValue(output, input.getDegree(), std::string("0.000000"));
-
-        return false;
+        this->defvalueString_ = defvalue.toString();                                // Convert the default-value to a string
+        this->searchLineInConfigFile();                                             // Search the entry in the config-file
+
+        std::string valueString = this->parseValueStringFromConfigFile(!(defvalue.isA(MT_string) || defvalue.isA(MT_constchar)));     // Parses the value string from the config-file-entry
+        if (!this->parse(valueString, defvalue))                                    // Try to convert the string to a value
+            this->resetLineInConfigFile();                                            // The conversion failed
+    }
+
+    /**
+        @brief Assigns a new value to the config-value of all objects and writes the change into the config-file.
+        @param input The new value
+        @return True if the new value was successfully assigned
+    */
+    bool ConfigValueContainer::set(const std::string& input)
+    {
+        bool success = this->tset(input);
+        this->setLineInConfigFile(input);
+        return success;
+    }
+
+    /**
+        @brief Assigns a new value to the config-value of all objects, but doesn't change the config-file (t stands for temporary).
+        @param input The new value
+        @return True if the new value was successfully assigned
+    */
+    bool ConfigValueContainer::tset(const std::string& input)
+    {
+        bool success = this->parse(input);
+        this->identifier_->updateConfigValues();
+        return success;
+    }
+
+    /**
+        @brief Sets the value of the variable back to the default value and resets the config-file entry.
+    */
+    bool ConfigValueContainer::reset()
+    {
+        return this->set(this->defvalueString_);
     }
 
@@ -181,468 +100,43 @@
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseString(const std::string& input, const MultiTypeMath& defvalue)
-    {
-        if (defvalue.getType() == MT_int)
-            return this->parseString(input, defvalue.getInt());
-        else if (defvalue.getType() == MT_uint)
-            return this->parseString(input, defvalue.getUnsignedInt());
-        else if (defvalue.getType() == MT_char)
-            return this->parseString(input, defvalue.getChar());
-        else if (defvalue.getType() == MT_uchar)
-            return this->parseString(input, defvalue.getUnsignedChar());
-        else if (defvalue.getType() == MT_short)
-            return this->parseString(input, defvalue.getShort());
-        else if (defvalue.getType() == MT_ushort)
-            return this->parseString(input, defvalue.getUnsignedShort());
-        else if (defvalue.getType() == MT_long)
-            return this->parseString(input, defvalue.getLong());
-        else if (defvalue.getType() == MT_ulong)
-            return this->parseString(input, defvalue.getUnsignedLong());
-        else if (defvalue.getType() == MT_float)
-            return this->parseString(input, defvalue.getFloat());
-        else if (defvalue.getType() == MT_double)
-            return this->parseString(input, defvalue.getDouble());
-        else if (defvalue.getType() == MT_longdouble)
-            return this->parseString(input, defvalue.getLongDouble());
-        else if (defvalue.getType() == MT_bool)
-            return this->parseString(input, defvalue.getBool());
-        else if (defvalue.getType() == MT_constchar)
-            return this->parseString(input, defvalue.getString());
-        else if (defvalue.getType() == MT_string)
-            return this->parseString(input, defvalue.getString());
-        else if (defvalue.getType() == MT_vector2)
-            return this->parseString(input, defvalue.getVector2());
-        else if (defvalue.getType() == MT_vector3)
-            return this->parseString(input, defvalue.getVector3());
-        else if (defvalue.getType() == MT_colourvalue)
-            return this->parseString(input, defvalue.getColourValue());
-        else if (defvalue.getType() == MT_quaternion)
-            return this->parseString(input, defvalue.getQuaternion());
-        else if (defvalue.getType() == MT_radian)
-            return this->parseString(input, defvalue.getRadian());
-        else if (defvalue.getType() == MT_degree)
-            return this->parseString(input, defvalue.getDegree());
-
+    bool ConfigValueContainer::parse(const std::string& input)
+    {
+        MultiTypeMath temp = this->value_;
+        if (temp.fromString(input))
+        {
+            this->value_ = temp;
+            return true;
+        }
         return false;
     }
 
     /**
-        @brief Parses a given std::string into a value of the type int and assigns it to the right variable. If the conversion failed, the default-value gets assigned.
+        @brief Parses a given std::string into a value of the type of the associated variable and assigns it.
         @param input The string to convert
-        @param defvalue The default-value
+        @param defvalue The default value to assign if the parsing fails
         @return True if the string was successfully parsed
     */
-    bool ConfigValueContainer::parseString(const std::string& input, int defvalue)
-    {
-        int temp;
-        bool success = ConvertValue(&temp, input, defvalue);
-        this->value_.setValue(temp);
-        return success;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type unsigned int 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 int defvalue)
-    {
-        unsigned int temp;
-        bool success = ConvertValue(&temp, input, defvalue);
-        this->value_.setValue(temp);
-        return success;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type char 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, char defvalue)
-    {
-        // I used value_int_ instead of value_char_ to avoid number <-> char confusion in the config-file
-        int temp;
-        bool success = ConvertValue(&temp, input, (int)defvalue);
-        this->value_.setValue((char)temp);
-        return success;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type unsigned char 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 char defvalue)
-    {
-        // I used value_uint_ instead of value_uchar_ to avoid number <-> char confusion in the config-file
-        unsigned int temp;
-        bool success = ConvertValue(&temp, input, (unsigned int)defvalue);
-        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);
-        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);
-        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);
-        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);
-        this->value_.setValue(temp);
-        return success;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type float 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, float defvalue)
-    {
-        float temp;
-        bool success = ConvertValue(&temp, input, defvalue);
-        this->value_.setValue(temp);
-        return success;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type 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, double defvalue)
-    {
-        double temp;
-        bool success = ConvertValue(&temp, input, defvalue);
-        this->value_.setValue(temp);
-        return success;
-    }
-
-    /**
-        @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, long double defvalue)
-    {
-        long double temp;
-        bool success = ConvertValue(&temp, input, defvalue);
-        this->value_.setValue(temp);
-        return success;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type bool 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, bool defvalue)
-    {
-        // Try to parse the value-string - is it a word?
-        if (input.find("true") < input.size()
-         || input.find("True") < input.size()
-         || input.find("yes") < input.size()
-         || input.find("Yes") < input.size())
-            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_.setValue(false);
+    bool ConfigValueContainer::parse(const std::string& input, const MultiTypeMath& defvalue)
+    {
+        MultiTypeMath temp = defvalue;
+        if (temp.fromString(input))
+        {
+            this->value_ = temp;
+            return true;
+        }
         else
         {
-            // Its not a known word - is it a number?
-            bool temp;
-            bool success = ConvertValue(&temp, input, defvalue);
-            this->value_.setValue(temp);
-            return success;
-        }
-
-        return true;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type std::string 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 std::string& defvalue)
-    {
-        // Strip the quotes
-        unsigned int pos1 = input.find("\"") + 1;
-        unsigned int pos2 = input.find("\"", pos1);
-
-        // Check if the entry was correctly quoted
-        if (pos1 < input.length() && pos2 < input.length() && !(input.find("\"", pos2 + 1) < input.length()))
-        {
-            // It was - get the string between the quotes
-            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_.setValue(defvalue);
-        return false;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type const char* 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 char* defvalue)
-    {
-        // Strip the quotes
-        unsigned int pos1 = input.find("\"") + 1;
-        unsigned int pos2 = input.find("\"", pos1);
-
-        // Check if the entry was correctly quoted
-        if (pos1 < input.length() && pos2 < input.length() && !(input.find("\"", pos2 + 1) < input.length()))
-        {
-            // It was - get the string between the quotes
-            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_.setValue(defvalue);
-        return false;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type _Vector2 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 Vector2& 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 Vector2
-        if (pos1 < input.length() && pos2 < input.length() && pos1 < pos2)
-        {
-            std::vector<std::string> tokens = tokenize(input.substr(pos1, pos2 - pos1), ",");
-            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;
-            }
-
-            return true;
-        }
-
-        this->value_.setValue(defvalue);
-        return false;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type Vector3 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 Vector3& 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_.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;
-            }
-
-            return true;
-        }
-
-        this->value_.setValue(defvalue);
-        return false;
-    }
-
-    /**
-        @brief Parses a given std::string into a value of the type ColourValue 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 ColourValue& 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_.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;
-            }
-
-            return true;
-        }
-
-        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);
+            this->value_ = defvalue;
+            return false;
+        }
+    }
+
+    /**
+        @brief Sets the corresponding entry in the config-file to a given value.
+    */
+    void ConfigValueContainer::setLineInConfigFile(const std::string& input)
+    {
+        (*this->configFileLine_) = this->varname_ + "=" + input;
+        ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
     }
 
@@ -650,17 +144,7 @@
         @brief Sets the corresponding entry in the config-file back to the default value.
     */
-    void ConfigValueContainer::resetConfigFileEntry()
-    {
-        (*this->configFileLine_) = this->varname_ + "=" + this->defvalueString_;
-        ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);
-    }
-
-    /**
-        @brief Sets the value of the variable back to the default value and resets the config-file entry.
-    */
-    void ConfigValueContainer::resetConfigValue()
-    {
-        this->parseString(this->defvalueString_, this->value_);
-        this->resetConfigFileEntry();
+    void ConfigValueContainer::resetLineInConfigFile()
+    {
+        this->setLineInConfigFile(this->defvalueString_);
     }
 
@@ -668,5 +152,5 @@
         @brief Searches the corresponding entry in the config-file and creates it, if there is no entry.
     */
-    void ConfigValueContainer::searchConfigFileLine()
+    void ConfigValueContainer::searchLineInConfigFile()
     {
         // Read the file if needed
@@ -677,5 +161,5 @@
         std::string section = "";
         section.append("[");
-        section.append(this->classname_);
+        section.append(this->identifier_->getName());
         section.append("]");
 
@@ -686,5 +170,5 @@
         {
             // Don't try to parse comments
-            if (this->isComment(*it1))
+            if (isComment(*it1))
                 continue;
 
@@ -700,5 +184,5 @@
                 {
                     // Don't try to parse comments
-                    if (this->isComment(*it2))
+                    if (isComment(*it2))
                         continue;
 
@@ -706,5 +190,5 @@
                     // section but in front of the following empty lines before the next section.
                     // (So this helps to keep a nice formatting with empty-lines between sections in the config-file)
-                    if (this->isEmpty(*it2))
+                    if (isEmpty(*it2))
                     {
                         if (!bLineIsEmpty)
@@ -760,59 +244,11 @@
         {
             // We obviously didn't found the right section, so we'll create it
-            this->getConfigFileLines().push_back("[" + this->classname_ + "]");                   // Create the section
+            this->getConfigFileLines().push_back("[" + this->identifier_->getName() + "]");                   // Create the section
             this->getConfigFileLines().push_back(this->varname_ + "=" + this->defvalueString_);   // Create the line
             this->configFileLine_ = --this->getConfigFileLines().end();                           // Set the pointer to the last element
             success = true;
-            this->getConfigFileLines().push_back("");                                             // Add an empty line - this is needed for the algorithm in the searchConfigFileLine-function
-            ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);                              // Save the changed config-file
-        }
-    }
-
-    /**
-        @brief Determines if a line in the config-file is a comment.
-        @param line The line to check
-        @return True = it's a comment
-    */
-    bool ConfigValueContainer::isComment(const std::string& line)
-    {
-        // Strip the line, whitespaces are disturbing
-        std::string teststring = getStrippedLine(line);
-
-        // 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 line in the config-file is empty (contains only whitespaces).
-        @param line The line to check
-        @return True = it's empty
-    */
-    bool ConfigValueContainer::isEmpty(const std::string& line)
-    {
-        return getStrippedLine(line) == "";
-    }
-
-    /**
-        @brief Removes all whitespaces from a line.
-        @param line The line to strip
-        @return The stripped line
-    */
-    std::string ConfigValueContainer::getStrippedLine(const std::string& line)
-    {
-        std::string output = line;
-        unsigned int pos;
-        while ((pos = output.find(" ")) < output.length())
-            output.erase(pos, 1);
-        while ((pos = output.find("\t")) < output.length())
-            output.erase(pos, 1);
-
-        return output;
+            this->getConfigFileLines().push_back("");                                             // Add an empty line - this is needed for the algorithm in the searchLineInConfigFile-function
+            ConfigValueContainer::writeConfigFile(CONFIGFILEPATH);                                // Save the changed config-file
+        }
     }
 
@@ -822,9 +258,9 @@
         @return The value-string
     */
-    std::string ConfigValueContainer::parseValueString(bool bStripped)
+    std::string ConfigValueContainer::parseValueStringFromConfigFile(bool bStripped)
     {
         std::string output;
         if (bStripped)
-            output = this->getStrippedLine(*this->configFileLine_);
+            output = getStripped(*this->configFileLine_);
         else
             output = *this->configFileLine_;
@@ -889,5 +325,4 @@
             file.getline(line, 1024);
             ConfigValueContainer::getConfigFileLines().push_back(line);
-//            std::cout << "### ->" << line << "<- : empty: " << isEmpty(line) << " comment: " << isComment(line) << std::endl;
         }
 
@@ -896,10 +331,7 @@
 
         // Add an empty line to the end of the file if needed
-        // this is needed for the algorithm in the searchConfigFileLine-function
+        // this is needed for the algorithm in the searchLineInConfigFile-function
         if ((ConfigValueContainer::getConfigFileLines().size() > 0) && !isEmpty(*ConfigValueContainer::getConfigFileLines().rbegin()))
-        {
-//            std::cout << "### newline added" << std::endl;
             ConfigValueContainer::getConfigFileLines().push_back("");
-        }
 
         file.close();
@@ -949,5 +381,5 @@
         if (!this->bAddedDescription_)
         {
-            this->description_ = std::string("ConfigValueDescription::" + this->classname_ + "::" + this->varname_);
+            this->description_ = std::string("ConfigValueDescription::" + this->identifier_->getName() + "::" + this->varname_);
             AddLanguageEntry(this->description_, description);
             this->bAddedDescription_ = true;
Index: code/branches/core2/src/orxonox/core/ConfigValueContainer.h
===================================================================
--- code/branches/core2/src/orxonox/core/ConfigValueContainer.h	(revision 955)
+++ code/branches/core2/src/orxonox/core/ConfigValueContainer.h	(revision 957)
@@ -72,77 +72,41 @@
     {
         public:
-            ConfigValueContainer(const std::string& classname, const std::string& varname, MultiTypeMath defvalue);
+            ConfigValueContainer(Identifier* identifier, const std::string& varname, MultiTypeMath defvalue);
 
             /** @brief Returns the configured value. @param value This is only needed to determine the right type. @return The value */
-/*            template <typename T>
-            inline ConfigValueContainer& getValue(T& value)                           { this->value_.getValue(value); return *this; }
-*/
-            inline ConfigValueContainer& getValue(int* value)            { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(unsigned int* value)   { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(char* value)           { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(unsigned char* value)  { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(short* value)          { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(unsigned short* value) { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(long* value)           { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(unsigned long* value)  { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(float* value)          { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(double* value)         { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(long double* value)    { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(bool* value)           { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(std::string* value)    { this->value_.getValue(value); return *this; }
-            inline ConfigValueContainer& getValue(const char** value)    { 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; }
+            template <typename T>
+            inline ConfigValueContainer& getValue(T* value)
+                { this->value_.getValue(value); return *this; }
 
             void description(const std::string& description);
             const std::string& getDescription() const;
 
-            bool parseString(const std::string& input, const MultiTypeMath& defvalue = MT_null);
-            bool valueToString(std::string* output, MultiTypeMath& input);
-            void resetConfigFileEntry();
-            void resetConfigValue();
+            bool set(const std::string& input);
+            bool tset(const std::string& input);
+            bool reset();
 
-            static std::string getStrippedLine(const std::string& line);
-            static bool isEmpty(const std::string& line);
-            static bool isComment(const std::string& line);
-
+            /** @brief Converts the config-value to a string. @return The string */
+            inline std::string toString() const
+                { return this->value_.toString(); }
+            /** @brief Returns the typename of the assigned config-value. @return The typename */
             inline std::string getTypename() const
                 { return this->value_.getTypename(); }
 
         private:
-            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 void readConfigFile(const std::string& filename);
+            static void writeConfigFile(const std::string& filename);
             static std::list<std::string>& getConfigFileLines();
             static bool finishedReadingConfigFile(bool finished = false);
-            void searchConfigFileLine();
-            std::string parseValueString(bool bStripped = true);
 
-            static void readConfigFile(const std::string& filename);
-            static void writeConfigFile(const std::string& filename);
+            bool parse(const std::string& input);
+            bool parse(const std::string& input, const MultiTypeMath& defvalue);
 
-            std::string         classname_;                     //!< The name of the class the variable belongs to
+            void setLineInConfigFile(const std::string& input);
+            void resetLineInConfigFile();
+            void searchLineInConfigFile();
+
+            std::string parseValueStringFromConfigFile(bool bStripped = true);
+
+            Identifier*         identifier_;                    //!< The name of the class the variable belongs to
             std::string         varname_;                       //!< The name of the variable
             std::string         defvalueString_;                //!< The string of the default-variable
Index: code/branches/core2/src/orxonox/core/CoreIncludes.h
===================================================================
--- code/branches/core2/src/orxonox/core/CoreIncludes.h	(revision 955)
+++ code/branches/core2/src/orxonox/core/CoreIncludes.h	(revision 957)
@@ -120,5 +120,5 @@
     if (!container##varname) \
     { \
-        container##varname = new orxonox::ConfigValueContainer(this->getIdentifier()->getName(), #varname, varname = defvalue); \
+        container##varname = new orxonox::ConfigValueContainer(this->getIdentifier(), #varname, varname = defvalue); \
         this->getIdentifier()->addConfigValueContainer(#varname, container##varname); \
     } \
@@ -133,5 +133,5 @@
     if (container##varname##reset) \
     { \
-        container##varname##reset->resetConfigValue(); \
+        container##varname##reset->reset(); \
         container##varname##reset->getValue(&varname); \
     } \
Index: code/branches/core2/src/orxonox/core/Executor.cc
===================================================================
--- code/branches/core2/src/orxonox/core/Executor.cc	(revision 955)
+++ code/branches/core2/src/orxonox/core/Executor.cc	(revision 957)
@@ -64,5 +64,5 @@
     }
 
-    void Executor::setDescription(const std::string& description)
+    Executor& Executor::setDescription(const std::string& description)
     {
         if (!this->bAddedDescription_)
@@ -72,4 +72,5 @@
             this->bAddedDescription_ = true;
         }
+        return (*this);
     }
 
@@ -79,5 +80,5 @@
     }
 
-    void Executor::setDescriptionParam(int param, const std::string& description)
+    Executor& Executor::setDescriptionParam(int param, const std::string& description)
     {
         if (param >= 0 && param < MAX_FUNCTOR_ARGUMENTS)
@@ -87,5 +88,5 @@
                 std::string paramnumber;
                 if (!Convert::ToString(&paramnumber, param))
-                    return;
+                    return (*this);
 
                 this->descriptionParam_[param] = std::string("ExecutorDescription::" + this->name_ + "::param" + paramnumber);
@@ -94,4 +95,5 @@
             }
         }
+        return (*this);
     }
 
@@ -104,5 +106,5 @@
     }
 
-    void Executor::setDescriptionReturnvalue(const std::string& description)
+    Executor& Executor::setDescriptionReturnvalue(const std::string& description)
     {
         if (!this->bAddedDescriptionReturnvalue_)
@@ -112,4 +114,5 @@
             this->bAddedDescriptionReturnvalue_ = true;
         }
+        return (*this);
     }
 
@@ -119,19 +122,23 @@
     }
 
-    void Executor::setDefaultValues(const MultiTypeMath& param1)
-    {
-        this->defaultValue_[0] = param1;
-        this->bAddedDefaultValue_[0] = true;
-    }
-
-    void Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
-    {
-        this->defaultValue_[0] = param1;
-        this->bAddedDefaultValue_[0] = true;
-        this->defaultValue_[1] = param2;
-        this->bAddedDefaultValue_[1] = true;
-    }
-
-    void Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+    {
+        this->defaultValue_[0] = param1;
+        this->bAddedDefaultValue_[0] = true;
+        this->defaultValue_[1] = param2;
+        this->bAddedDefaultValue_[1] = true;
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
     {
         this->defaultValue_[0] = param1;
@@ -141,7 +148,9 @@
         this->defaultValue_[2] = param3;
         this->bAddedDefaultValue_[2] = true;
-    }
-
-    void Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
     {
         this->defaultValue_[0] = param1;
@@ -153,7 +162,9 @@
         this->defaultValue_[3] = param4;
         this->bAddedDefaultValue_[3] = true;
-    }
-
-    void Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
     {
         this->defaultValue_[0] = param1;
@@ -167,7 +178,9 @@
         this->defaultValue_[4] = param5;
         this->bAddedDefaultValue_[4] = true;
-    }
-
-    void Executor::setDefaultValue(unsigned int index, const MultiTypeMath& param)
+
+        return (*this);
+    }
+
+    Executor& Executor::setDefaultValue(unsigned int index, const MultiTypeMath& param)
     {
         if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
@@ -176,4 +189,5 @@
             this->bAddedDefaultValue_[index] = true;
         }
+        return (*this);
     }
 
Index: code/branches/core2/src/orxonox/core/Executor.h
===================================================================
--- code/branches/core2/src/orxonox/core/Executor.h	(revision 955)
+++ code/branches/core2/src/orxonox/core/Executor.h	(revision 957)
@@ -165,11 +165,11 @@
             bool parse(const std::string& params, const std::string& delimiter = " ") const;
 
-            void setDescription(const std::string& description);
+            Executor& setDescription(const std::string& description);
             const std::string& getDescription() const;
 
-            void setDescriptionParam(int param, const std::string& description);
+            Executor& setDescriptionParam(int param, const std::string& description);
             const std::string& getDescriptionParam(int param) const;
 
-            void setDescriptionReturnvalue(const std::string& description);
+            Executor& setDescriptionReturnvalue(const std::string& description);
             const std::string& getDescriptionReturnvalue(int param) const;
 
@@ -197,10 +197,18 @@
                 { return this->accessLevel_; }
 
-            void setDefaultValues(const MultiTypeMath& param1);
-            void setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
-            void setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3);
-            void setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4);
-            void setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5);
-            void setDefaultValue(unsigned int index, const MultiTypeMath& param);
+            Executor& setDefaultValues(const MultiTypeMath& param1);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4);
+            Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5);
+            Executor& setDefaultValue(unsigned int index, const MultiTypeMath& param);
+
+            inline MultiTypeMath getDefaultValue(unsigned int index) const
+            {
+                if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+                    return this->defaultValue_[index];
+
+                return MT_null;
+            }
 
             bool allDefaultValuesSet() const;
Index: code/branches/core2/src/orxonox/core/Identifier.h
===================================================================
--- code/branches/core2/src/orxonox/core/Identifier.h	(revision 955)
+++ code/branches/core2/src/orxonox/core/Identifier.h	(revision 957)
@@ -109,4 +109,8 @@
             bool isDirectParentOf(const Identifier* identifier) const;
 
+            virtual const ObjectList<BaseObject>* getObjectList() const = 0;
+
+            virtual void updateConfigValues() const = 0;
+
             /** @brief Removes all objects of the corresponding class. */
             virtual void removeObjects() const = 0;
@@ -304,5 +308,10 @@
             void removeObjects() const;
             void setName(const std::string& name);
+            /** @brief Returns the list of all existing objects of this class. @return The list */
             inline const ObjectList<T>* getObjects() const { return this->objects_; }
+            /** @brief Returns a list of all existing objects of this class. @return The list */
+            inline const ObjectList<BaseObject>* getObjectList() const { return (ObjectList<BaseObject>*)this->objects_; }
+
+            void updateConfigValues() const;
 
             XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname);
@@ -395,4 +404,14 @@
         for (Iterator<T> it = this->objects_->start(); it;)
             delete *(it++);
+    }
+
+    /**
+        @brief Updates the config-values of all existing objects of this class by calling their setConfigValues() function.
+    */
+    template <class T>
+    void ClassIdentifier<T>::updateConfigValues() const
+    {
+        for (Iterator<T> it = this->objects_->start(); it; ++it)
+            ((T*)*it)->setConfigValues();
     }
 
Index: code/branches/core2/src/orxonox/objects/Ambient.cc
===================================================================
--- code/branches/core2/src/orxonox/objects/Ambient.cc	(revision 955)
+++ code/branches/core2/src/orxonox/objects/Ambient.cc	(revision 957)
@@ -47,5 +47,5 @@
 namespace orxonox
 {
-    ConsoleCommand(Ambient, setAmbientLightTest, AccessLevel::Offline, false);
+    ConsoleCommand(Ambient, setAmbientLightTest, AccessLevel::Offline, false).setDefaultValues(ColourValue(1, 1, 1, 1));
 
     CreateFactory(Ambient);
Index: code/branches/core2/src/orxonox/objects/Projectile.cc
===================================================================
--- code/branches/core2/src/orxonox/objects/Projectile.cc	(revision 955)
+++ code/branches/core2/src/orxonox/objects/Projectile.cc	(revision 957)
@@ -71,4 +71,6 @@
         SetConfigValue(lifetime_, 10.0).description("The time in seconds a projectile stays alive");
         SetConfigValue(speed_, 2000.0).description("The speed of a projectile in units per second");
+
+        this->setVelocity(Vector3(1, 0, 0) * this->speed_);
     }
 
Index: code/branches/core2/src/orxonox/tools/Timer.h
===================================================================
--- code/branches/core2/src/orxonox/tools/Timer.h	(revision 955)
+++ code/branches/core2/src/orxonox/tools/Timer.h	(revision 957)
@@ -83,4 +83,8 @@
             /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */
             inline bool isActive() const { return this->bActive_; }
+            /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
+            inline void addTime(float time) { this->time_ += time; }
+            /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
+            inline void removeTime(float time) { this->time_ -= time; }
 
         protected:
Index: code/branches/core2/src/util/String.cc
===================================================================
--- code/branches/core2/src/util/String.cc	(revision 955)
+++ code/branches/core2/src/util/String.cc	(revision 957)
@@ -72,6 +72,14 @@
     //  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;
+    if (teststring.size() >= 2)
+    {
+        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[1] == '/'))
+            return true;
+    }
+    else if (teststring.size() == 1)
+    {
+        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';')
+            return true;
+    }
 
     return false;
