Index: code/branches/core2/src/orxonox/core/CommandExecutor.cc
===================================================================
--- code/branches/core2/src/orxonox/core/CommandExecutor.cc	(revision 948)
+++ code/branches/core2/src/orxonox/core/CommandExecutor.cc	(revision 949)
@@ -29,5 +29,4 @@
 #include "ConsoleCommand.h"
 #include "util/String.h"
-#include "util/SubString.h"
 #include "Identifier.h"
 #include "Language.h"
@@ -46,31 +45,14 @@
     ConsoleCommandShortcutGeneric(keyword3, createExecutor((FunctorStatic*)0, "bind", AccessLevel::User));
 
-    SubString CommandExecutor::tokens_s;
-    std::string CommandExecutor::lastProcessedCommand_s;
-
-    std::list<const std::string*> CommandExecutor::listOfPossibleFunctionClasses_s;
-    std::list<const std::string*> CommandExecutor::listOfPossibleShortcuts_s;
-    std::list<const std::string*> CommandExecutor::listOfPossibleFunctions_s;
-    std::list<const std::string*> CommandExecutor::listOfPossibleConfigValueClasses_s;
-    std::list<const std::string*> CommandExecutor::listOfPossibleConfigValues_s;
-    std::list<const std::string*> CommandExecutor::listOfPossibleKeys_s;
-
-    Identifier* CommandExecutor::functionclass_s;
-    Identifier* CommandExecutor::configvalueclass_s;
-    ExecutorStatic* CommandExecutor::shortcut_s;
-    ExecutorStatic* CommandExecutor::function_s;
-    ConfigValueContainer* CommandExecutor::configvalue_s;
-    ConfigValueContainer* CommandExecutor::key_s;
-
-    std::string CommandExecutor::errorMessage_s;
-    CommandExecutor::CommandState CommandExecutor::state_s;
-
-    std::map<std::string, ExecutorStatic*> CommandExecutor::consoleCommandShortcuts_s;
-    std::map<std::string, ExecutorStatic*> CommandExecutor::consoleCommandShortcuts_LC_s;
+    CommandExecutor& CommandExecutor::getInstance()
+    {
+        static CommandExecutor instance;
+        return instance;
+    }
 
     bool CommandExecutor::addConsoleCommandShortcut(ExecutorStatic* executor)
     {
-        CommandExecutor::consoleCommandShortcuts_s[executor->getName()] = executor;
-        CommandExecutor::consoleCommandShortcuts_LC_s[getLowercase(executor->getName())] = executor;
+        CommandExecutor::getInstance().consoleCommandShortcuts_s[executor->getName()] = executor;
+        CommandExecutor::getInstance().consoleCommandShortcuts_LC_s[getLowercase(executor->getName())] = executor;
         return true;
     }
@@ -83,6 +65,6 @@
     ExecutorStatic* CommandExecutor::getConsoleCommandShortcut(const std::string& name)
     {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::consoleCommandShortcuts_s.find(name);
-        if (it != CommandExecutor::consoleCommandShortcuts_s.end())
+        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_s.find(name);
+        if (it != CommandExecutor::getInstance().consoleCommandShortcuts_s.end())
             return (*it).second;
         else
@@ -97,6 +79,6 @@
     ExecutorStatic* CommandExecutor::getLowercaseConsoleCommandShortcut(const std::string& name)
     {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::consoleCommandShortcuts_LC_s.find(name);
-        if (it != CommandExecutor::consoleCommandShortcuts_LC_s.end())
+        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_LC_s.find(name);
+        if (it != CommandExecutor::getInstance().consoleCommandShortcuts_LC_s.end())
             return (*it).second;
         else
@@ -106,10 +88,10 @@
     bool CommandExecutor::execute(const std::string& command)
     {
-        if (CommandExecutor::lastProcessedCommand_s != command)
+        if (CommandExecutor::getInstance().lastProcessedCommand_s != command)
             CommandExecutor::parse(command);
 
-        CommandExecutor::tokens_s.split(command, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
-
-        switch (CommandExecutor::state_s)
+        CommandExecutor::getInstance().tokens_s.split(command, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+        switch (CommandExecutor::getInstance().state_s)
         {
             case CS_Empty:
@@ -122,6 +104,6 @@
             case CS_Shortcut_Finished:
                 // call the shortcut
-                if (CommandExecutor::shortcut_s != 0)
-                    return CommandExecutor::shortcut_s->parse(CommandExecutor::tokens_s.subSet(1).join());
+                if (CommandExecutor::getInstance().shortcut_s != 0)
+                    return CommandExecutor::getInstance().shortcut_s->parse(CommandExecutor::getInstance().tokens_s.subSet(1).join());
                 break;
             case CS_Function:
@@ -132,6 +114,6 @@
             case CS_Function_Finished:
                 // call the shortcut
-                if (CommandExecutor::function_s != 0)
-                    return CommandExecutor::function_s->parse(CommandExecutor::tokens_s.subSet(2).join());
+                if (CommandExecutor::getInstance().function_s != 0)
+                    return CommandExecutor::getInstance().function_s->parse(CommandExecutor::getInstance().tokens_s.subSet(2).join());
                 break;
             case CS_ConfigValueClass:
@@ -144,6 +126,6 @@
             case CS_ConfigValueFinished:
                 // set the config value
-                if (CommandExecutor::configvalue_s != 0)
-                    return CommandExecutor::configvalue_s->parseString(CommandExecutor::tokens_s.subSet(3).join());
+                if (CommandExecutor::getInstance().configvalue_s != 0)
+                    return CommandExecutor::getInstance().configvalue_s->parseString(CommandExecutor::getInstance().tokens_s.subSet(3).join());
                 break;
             case CS_KeybindKey:
@@ -165,20 +147,20 @@
     std::string CommandExecutor::complete(const std::string& command)
     {
-        if (CommandExecutor::lastProcessedCommand_s != command)
+        if (CommandExecutor::getInstance().lastProcessedCommand_s != command)
             CommandExecutor::parse(command);
 
-        CommandExecutor::tokens_s.split(command, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+        CommandExecutor::getInstance().tokens_s.split(command, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
 
         std::list<const std::string*> temp;
-        if (CommandExecutor::state_s == CS_Empty)
-        {
-            temp.insert(temp.end(), CommandExecutor::listOfPossibleShortcuts_s.begin(), CommandExecutor::listOfPossibleShortcuts_s.end());
-            temp.insert(temp.end(), CommandExecutor::listOfPossibleFunctionClasses_s.begin(), CommandExecutor::listOfPossibleFunctionClasses_s.end());
-        }
-
-        switch (CommandExecutor::state_s)
+        if (CommandExecutor::getInstance().state_s == CS_Empty)
+        {
+            temp.insert(temp.end(), CommandExecutor::getInstance().listOfPossibleShortcuts_s.begin(), CommandExecutor::getInstance().listOfPossibleShortcuts_s.end());
+            temp.insert(temp.end(), CommandExecutor::getInstance().listOfPossibleFunctionClasses_s.begin(), CommandExecutor::getInstance().listOfPossibleFunctionClasses_s.end());
+        }
+
+        switch (CommandExecutor::getInstance().state_s)
         {
             case CS_Empty:
-                return (CommandExecutor::tokens_s.subSet(0, CommandExecutor::tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(temp));
+                return (CommandExecutor::getInstance().tokens_s.subSet(0, CommandExecutor::getInstance().tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(temp));
                 break;
             case CS_FunctionClass_Or_Shortcut_Or_Keyword:
@@ -191,5 +173,5 @@
                 break;
             case CS_Function:
-                return (CommandExecutor::tokens_s.subSet(0, CommandExecutor::tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::listOfPossibleFunctions_s));
+                return (CommandExecutor::getInstance().tokens_s.subSet(0, CommandExecutor::getInstance().tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::getInstance().listOfPossibleFunctions_s));
                 break;
             case CS_Function_Params:
@@ -200,8 +182,8 @@
                 break;
             case CS_ConfigValueClass:
-                return (CommandExecutor::tokens_s.subSet(0, CommandExecutor::tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::listOfPossibleConfigValueClasses_s));
+                return (CommandExecutor::getInstance().tokens_s.subSet(0, CommandExecutor::getInstance().tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::getInstance().listOfPossibleConfigValueClasses_s));
                 break;
             case CS_ConfigValue:
-                return (CommandExecutor::tokens_s.subSet(0, CommandExecutor::tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::listOfPossibleConfigValues_s));
+                return (CommandExecutor::getInstance().tokens_s.subSet(0, CommandExecutor::getInstance().tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::getInstance().listOfPossibleConfigValues_s));
                 break;
             case CS_ConfigValueType:
@@ -212,5 +194,5 @@
                 break;
             case CS_KeybindKey:
-                return (CommandExecutor::tokens_s.subSet(0, CommandExecutor::tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::listOfPossibleKeys_s));
+                return (CommandExecutor::getInstance().tokens_s.subSet(0, CommandExecutor::getInstance().tokens_s.size() - 1).join() + " " + CommandExecutor::getCommonBegin(CommandExecutor::getInstance().listOfPossibleKeys_s));
                 break;
             case CS_KeybindCommand:
@@ -224,56 +206,64 @@
         }
 
-        return CommandExecutor::lastProcessedCommand_s;
+        return CommandExecutor::getInstance().lastProcessedCommand_s;
     }
 
     std::string CommandExecutor::hint(const std::string& command)
     {
-        if (CommandExecutor::lastProcessedCommand_s != command)
+        if (CommandExecutor::getInstance().lastProcessedCommand_s != command)
             CommandExecutor::parse(command);
 
-        CommandExecutor::tokens_s.split(command, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
-
-        switch (CommandExecutor::state_s)
+        CommandExecutor::getInstance().tokens_s.split(command, " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+
+        switch (CommandExecutor::getInstance().state_s)
         {
             case CS_Empty:
-                return (CommandExecutor::dump(CommandExecutor::listOfPossibleShortcuts_s) + "\n" + CommandExecutor::dump(CommandExecutor::listOfPossibleFunctionClasses_s));
+                return (CommandExecutor::dump(CommandExecutor::getInstance().listOfPossibleShortcuts_s) + "\n" + CommandExecutor::dump(CommandExecutor::getInstance().listOfPossibleFunctionClasses_s));
                 break;
             case CS_FunctionClass_Or_Shortcut_Or_Keyword:
                 break;
             case CS_Shortcut_Params:
-                if (CommandExecutor::shortcut_s != 0)
-                    return CommandExecutor::dump(CommandExecutor::shortcut_s);
+                if (CommandExecutor::getInstance().shortcut_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().shortcut_s);
                 break;
             case CS_Shortcut_Finished:
+                if (CommandExecutor::getInstance().shortcut_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().shortcut_s);
                 break;
             case CS_Function:
-                return CommandExecutor::dump(CommandExecutor::listOfPossibleFunctions_s);
+                return CommandExecutor::dump(CommandExecutor::getInstance().listOfPossibleFunctions_s);
                 break;
             case CS_Function_Params:
-                if (CommandExecutor::function_s != 0)
-                    return CommandExecutor::dump(CommandExecutor::function_s);
+                if (CommandExecutor::getInstance().function_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().function_s);
                 break;
             case CS_Function_Finished:
+                if (CommandExecutor::getInstance().function_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().function_s);
                 break;
             case CS_ConfigValueClass:
-                return CommandExecutor::dump(CommandExecutor::listOfPossibleConfigValueClasses_s);
+                return CommandExecutor::dump(CommandExecutor::getInstance().listOfPossibleConfigValueClasses_s);
                 break;
             case CS_ConfigValue:
-                return CommandExecutor::dump(CommandExecutor::listOfPossibleConfigValues_s);
+                return CommandExecutor::dump(CommandExecutor::getInstance().listOfPossibleConfigValues_s);
                 break;
             case CS_ConfigValueType:
-                if (CommandExecutor::configvalue_s != 0)
-                    CommandExecutor::dump(CommandExecutor::configvalue_s);
+                if (CommandExecutor::getInstance().configvalue_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().configvalue_s);
                 break;
             case CS_ConfigValueFinished:
+                if (CommandExecutor::getInstance().configvalue_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().configvalue_s);
                 break;
             case CS_KeybindKey:
-                return CommandExecutor::dump(CommandExecutor::listOfPossibleKeys_s);
+                return CommandExecutor::dump(CommandExecutor::getInstance().listOfPossibleKeys_s);
                 break;
             case CS_KeybindCommand:
-                if (CommandExecutor::key_s != 0)
-                    CommandExecutor::dump(CommandExecutor::key_s);
+                if (CommandExecutor::getInstance().key_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().key_s);
                 break;
             case CS_KeybindFinished:
+                if (CommandExecutor::getInstance().key_s != 0)
+                    return CommandExecutor::dump(CommandExecutor::getInstance().key_s);
                 break;
             case CS_Error:
@@ -287,11 +277,11 @@
     void CommandExecutor::parse(const std::string& command, bool bInitialize)
     {
-        CommandExecutor::tokens_s.split((command + CommandExecutor::cursor_s), " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
-        CommandExecutor::lastProcessedCommand_s = command;
+        CommandExecutor::getInstance().tokens_s.split((command + COMMAND_EXECUTOR_CURSOR), " ", SubString::WhiteSpaces, false, '\\', '"', '(', ')', '\0');
+        CommandExecutor::getInstance().lastProcessedCommand_s = command;
 
         if (bInitialize)
             CommandExecutor::initialize();
 
-        switch (CommandExecutor::state_s)
+        switch (CommandExecutor::getInstance().state_s)
         {
             case CS_Empty:
@@ -300,12 +290,12 @@
                     // We want a hint for the first token
                     // Check if there is already a perfect match
-                    CommandExecutor::functionclass_s = CommandExecutor::getIdentifierOfPossibleFunctionClass(CommandExecutor::getToken(0));
-                    CommandExecutor::shortcut_s = CommandExecutor::getExecutorOfPossibleShortcut(CommandExecutor::getToken(0));
-
-                    if ((CommandExecutor::functionclass_s != 0) || (CommandExecutor::shortcut_s != 0))
+                    CommandExecutor::getInstance().functionclass_s = CommandExecutor::getIdentifierOfPossibleFunctionClass(CommandExecutor::getToken(0));
+                    CommandExecutor::getInstance().shortcut_s = CommandExecutor::getExecutorOfPossibleShortcut(CommandExecutor::getToken(0));
+
+                    if ((CommandExecutor::getInstance().functionclass_s != 0) || (CommandExecutor::getInstance().shortcut_s != 0))
                     {
                         // Yes, there is a class or a shortcut with the searched name
                         // Add a whitespace and continue parsing
-                        CommandExecutor::state_s = CS_FunctionClass_Or_Shortcut_Or_Keyword;
+                        CommandExecutor::getInstance().state_s = CS_FunctionClass_Or_Shortcut_Or_Keyword;
                         CommandExecutor::parse(command + " ", false);
                         return;
@@ -315,5 +305,4 @@
                     CommandExecutor::createListOfPossibleFunctionClasses(CommandExecutor::getToken(0));
                     CommandExecutor::createListOfPossibleShortcuts(CommandExecutor::getToken(0));
-                    CommandExecutor::state_s = CS_Empty;
                     return;
                 }
@@ -321,5 +310,5 @@
                 {
                     // There is at least one argument: Check if it's a shortcut, a classname or a special keyword
-                    CommandExecutor::state_s = CS_FunctionClass_Or_Shortcut_Or_Keyword;
+                    CommandExecutor::getInstance().state_s = CS_FunctionClass_Or_Shortcut_Or_Keyword;
                     CommandExecutor::parse(command, false);
                     return;
@@ -332,5 +321,5 @@
                     {
                         // We want to set a config value
-                        CommandExecutor::state_s = CS_ConfigValueClass;
+                        CommandExecutor::getInstance().state_s = CS_ConfigValueClass;
                         CommandExecutor::parse(command, false);
                         return;
@@ -339,26 +328,26 @@
                     {
                         // We want to set a keybinding
-                        CommandExecutor::state_s = CS_KeybindKey;
+                        CommandExecutor::getInstance().state_s = CS_KeybindKey;
                         CommandExecutor::parse(command, false);
                         return;
                     }
 
-                    if (CommandExecutor::functionclass_s == 0)
-                        CommandExecutor::functionclass_s = CommandExecutor::getIdentifierOfPossibleFunctionClass(CommandExecutor::getToken(0));
-                    if (CommandExecutor::shortcut_s == 0)
-                        CommandExecutor::shortcut_s = CommandExecutor::getExecutorOfPossibleShortcut(CommandExecutor::getToken(0));
-
-                    if ((CommandExecutor::functionclass_s == 0) && (CommandExecutor::shortcut_s == 0))
+                    if (CommandExecutor::getInstance().functionclass_s == 0)
+                        CommandExecutor::getInstance().functionclass_s = CommandExecutor::getIdentifierOfPossibleFunctionClass(CommandExecutor::getToken(0));
+                    if (CommandExecutor::getInstance().shortcut_s == 0)
+                        CommandExecutor::getInstance().shortcut_s = CommandExecutor::getExecutorOfPossibleShortcut(CommandExecutor::getToken(0));
+
+                    if ((CommandExecutor::getInstance().functionclass_s == 0) && (CommandExecutor::getInstance().shortcut_s == 0))
                     {
                         // Argument 1 seems to be wrong
                         AddLanguageEntry("CommandExecutor::NoSuchCommandOrClassName", "No such command or classname");
-                        CommandExecutor::errorMessage_s = (CommandExecutor::getToken(0) + ": " + GetLocalisation("CommandExecutor::NoSuchCommandOrClassName"));
-                        CommandExecutor::state_s = CS_Error;
-                        return;
-                    }
-                    else if (CommandExecutor::shortcut_s != 0)
+                        CommandExecutor::getInstance().errorMessage_s = (CommandExecutor::getToken(0) + ": " + GetLocalisation("CommandExecutor::NoSuchCommandOrClassName"));
+                        CommandExecutor::getInstance().state_s = CS_Error;
+                        return;
+                    }
+                    else if (CommandExecutor::getInstance().shortcut_s != 0)
                     {
                         // Argument 1 is a shortcut: Return the needed parameter types
-                        CommandExecutor::state_s = CS_Shortcut_Params;
+                        CommandExecutor::getInstance().state_s = CS_Shortcut_Params;
                         CommandExecutor::parse(command, false);
                         return;
@@ -367,5 +356,5 @@
                     {
                         // Argument 1 is a classname: Return the possible functions
-                        CommandExecutor::state_s = CS_Function;
+                        CommandExecutor::getInstance().state_s = CS_Function;
                         CommandExecutor::parse(command, false);
                         return;
@@ -374,16 +363,16 @@
                 else
                 {
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
                 break;
             case CS_Shortcut_Params:
-                if (CommandExecutor::shortcut_s != 0)
+                if (CommandExecutor::getInstance().shortcut_s != 0)
                 {
                     // Valid command
                     // Check if there are enough parameters
-                    if (CommandExecutor::enoughParametersGiven(1, CommandExecutor::shortcut_s))
-                    {
-                        CommandExecutor::state_s = CS_Shortcut_Finished;
+                    if (CommandExecutor::enoughParametersGiven(1, CommandExecutor::getInstance().shortcut_s))
+                    {
+                        CommandExecutor::getInstance().state_s = CS_Shortcut_Finished;
                         return;
                     }
@@ -392,10 +381,10 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
                 break;
             case CS_Function:
-                if (CommandExecutor::functionclass_s != 0)
+                if (CommandExecutor::getInstance().functionclass_s != 0)
                 {
                     // We have a valid classname
@@ -404,11 +393,11 @@
                     {
                         // There is a second argument: Check if it's a valid functionname
-                        CommandExecutor::function_s = CommandExecutor::getExecutorOfPossibleFunction(CommandExecutor::getToken(1), CommandExecutor::functionclass_s);
-                        if (CommandExecutor::function_s == 0)
+                        CommandExecutor::getInstance().function_s = CommandExecutor::getExecutorOfPossibleFunction(CommandExecutor::getToken(1), CommandExecutor::getInstance().functionclass_s);
+                        if (CommandExecutor::getInstance().function_s == 0)
                         {
                             // Argument 2 seems to be wrong
                             AddLanguageEntry("CommandExecutor::NoSuchFunctionnameIn", "No such functionname in");
-                            CommandExecutor::errorMessage_s = (CommandExecutor::getToken(1) + ": " + GetLocalisation("CommandExecutor::NoSuchFunctionnameIn") + " " + CommandExecutor::functionclass_s->getName());
-                            CommandExecutor::state_s = CS_Error;
+                            CommandExecutor::getInstance().errorMessage_s = (CommandExecutor::getToken(1) + ": " + GetLocalisation("CommandExecutor::NoSuchFunctionnameIn") + " " + CommandExecutor::getInstance().functionclass_s->getName());
+                            CommandExecutor::getInstance().state_s = CS_Error;
                             return;
                         }
@@ -416,5 +405,5 @@
                         {
                             // Argument 2 seems to be a valid functionname: Get the parameters
-                            CommandExecutor::state_s = CS_Function_Params;
+                            CommandExecutor::getInstance().state_s = CS_Function_Params;
                             CommandExecutor::parse(command, false);
                             return;
@@ -425,11 +414,11 @@
                         // There is no finished second argument
                         // Check if there's already a perfect match
-                        if (CommandExecutor::tokens_s.size() >= 2)
-                        {
-                            CommandExecutor::function_s = CommandExecutor::getExecutorOfPossibleFunction(CommandExecutor::getToken(1), CommandExecutor::functionclass_s);
-                            if (CommandExecutor::function_s != 0)
+                        if (CommandExecutor::getInstance().tokens_s.size() >= 2)
+                        {
+                            CommandExecutor::getInstance().function_s = CommandExecutor::getExecutorOfPossibleFunction(CommandExecutor::getToken(1), CommandExecutor::getInstance().functionclass_s);
+                            if (CommandExecutor::getInstance().function_s != 0)
                             {
                                 // There is a perfect match: Add a whitespace and continue parsing
-                                CommandExecutor::state_s = CS_Function_Params;
+                                CommandExecutor::getInstance().state_s = CS_Function_Params;
                                 CommandExecutor::parse(command + " ", false);
                                 return;
@@ -438,6 +427,5 @@
 
                         // No perfect match: Create the list of all possible functions and return
-                        CommandExecutor::createListOfPossibleFunctions(CommandExecutor::getToken(1), CommandExecutor::functionclass_s);
-                        CommandExecutor::state_s = CS_Function;
+                        CommandExecutor::createListOfPossibleFunctions(CommandExecutor::getToken(1), CommandExecutor::getInstance().functionclass_s);
                         return;
                     }
@@ -445,16 +433,16 @@
                 else
                 {
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
                 break;
             case CS_Function_Params:
-                if ((CommandExecutor::functionclass_s != 0) && (CommandExecutor::function_s != 0))
+                if ((CommandExecutor::getInstance().functionclass_s != 0) && (CommandExecutor::getInstance().function_s != 0))
                 {
                     // Valid command
                     // Check if there are enough parameters
-                    if (CommandExecutor::enoughParametersGiven(2, CommandExecutor::function_s))
-                    {
-                        CommandExecutor::state_s = CS_Function_Finished;
+                    if (CommandExecutor::enoughParametersGiven(2, CommandExecutor::getInstance().function_s))
+                    {
+                        CommandExecutor::getInstance().state_s = CS_Function_Finished;
                         return;
                     }
@@ -463,5 +451,5 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
@@ -475,11 +463,11 @@
                     {
                         // There is a second argument: Check if it's a valid classname
-                        CommandExecutor::configvalueclass_s = CommandExecutor::getIdentifierOfPossibleConfigValueClass(CommandExecutor::getToken(1));
-                        if (CommandExecutor::configvalueclass_s == 0)
+                        CommandExecutor::getInstance().configvalueclass_s = CommandExecutor::getIdentifierOfPossibleConfigValueClass(CommandExecutor::getToken(1));
+                        if (CommandExecutor::getInstance().configvalueclass_s == 0)
                         {
                             // Argument 2 seems to be wrong
                             AddLanguageEntry("CommandExecutor::NoSuchClassWithConfigValues", "No such class with config values");
-                            CommandExecutor::errorMessage_s = (CommandExecutor::getToken(1) + ": " + GetLocalisation("CommandExecutor::NoSuchClassWithConfigValues"));
-                            CommandExecutor::state_s = CS_Error;
+                            CommandExecutor::getInstance().errorMessage_s = (CommandExecutor::getToken(1) + ": " + GetLocalisation("CommandExecutor::NoSuchClassWithConfigValues"));
+                            CommandExecutor::getInstance().state_s = CS_Error;
                             return;
                         }
@@ -487,5 +475,5 @@
                         {
                             // Argument 2 seems to be a valid classname: Search for possible config values
-                            CommandExecutor::state_s = CS_ConfigValue;
+                            CommandExecutor::getInstance().state_s = CS_ConfigValue;
                             CommandExecutor::parse(command, false);
                             return;
@@ -496,11 +484,11 @@
                         // There's no finished second argument
                         // Check if there's already a perfect match
-                        if (CommandExecutor::tokens_s.size() >= 2)
-                        {
-                            CommandExecutor::configvalueclass_s = CommandExecutor::getIdentifierOfPossibleConfigValueClass(CommandExecutor::getToken(1));
-                            if (CommandExecutor::configvalueclass_s != 0)
+                        if (CommandExecutor::getInstance().tokens_s.size() >= 2)
+                        {
+                            CommandExecutor::getInstance().configvalueclass_s = CommandExecutor::getIdentifierOfPossibleConfigValueClass(CommandExecutor::getToken(1));
+                            if (CommandExecutor::getInstance().configvalueclass_s != 0)
                             {
                                 // There is a perfect match: Add a whitespace and continue parsing
-                                CommandExecutor::state_s = CS_ConfigValue;
+                                CommandExecutor::getInstance().state_s = CS_ConfigValue;
                                 CommandExecutor::parse(command + " ", false);
                                 return;
@@ -510,5 +498,4 @@
                         // No perfect match: Create the list of all possible classnames and return
                         CommandExecutor::createListOfPossibleConfigValueClasses(CommandExecutor::getToken(1));
-                        CommandExecutor::state_s = CS_ConfigValueClass;
                         return;
                     }
@@ -517,10 +504,10 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
                 break;
             case CS_ConfigValue:
-                if (((CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE) || (CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE_TEMPORARY)) && (CommandExecutor::configvalueclass_s != 0))
+                if (((CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE) || (CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE_TEMPORARY)) && (CommandExecutor::getInstance().configvalueclass_s != 0))
                 {
                     // Check if there is a third argument
@@ -528,11 +515,11 @@
                     {
                         // There is a third argument: Check if it's a valid config value
-                        CommandExecutor::configvalue_s = CommandExecutor::getContainerOfPossibleConfigValue(CommandExecutor::getToken(2), CommandExecutor::configvalueclass_s);
-                        if (CommandExecutor::configvalue_s == 0)
+                        CommandExecutor::getInstance().configvalue_s = CommandExecutor::getContainerOfPossibleConfigValue(CommandExecutor::getToken(2), CommandExecutor::getInstance().configvalueclass_s);
+                        if (CommandExecutor::getInstance().configvalue_s == 0)
                         {
                             // Argument 3 seems to be wrong
                             AddLanguageEntry("CommandExecutor::NoSuchConfigValueIn", "No such config value in");
-                            CommandExecutor::errorMessage_s = (CommandExecutor::getToken(2) + ": " + GetLocalisation("CommandExecutor::NoSuchConfigValueIn") + " " + CommandExecutor::configvalueclass_s->getName());
-                            CommandExecutor::state_s = CS_Error;
+                            CommandExecutor::getInstance().errorMessage_s = (CommandExecutor::getToken(2) + ": " + GetLocalisation("CommandExecutor::NoSuchConfigValueIn") + " " + CommandExecutor::getInstance().configvalueclass_s->getName());
+                            CommandExecutor::getInstance().state_s = CS_Error;
                             return;
                         }
@@ -540,5 +527,5 @@
                         {
                             // Argument 3 seems to be a valid config value: Get the type
-                            CommandExecutor::state_s = CS_ConfigValueType;
+                            CommandExecutor::getInstance().state_s = CS_ConfigValueType;
                             CommandExecutor::parse(command, false);
                             return;
@@ -549,11 +536,11 @@
                         // There is no finished third argument
                         // Check if there's already a perfect match
-                        if (CommandExecutor::tokens_s.size() >= 3)
-                        {
-                            CommandExecutor::configvalue_s = CommandExecutor::getContainerOfPossibleConfigValue(CommandExecutor::getToken(2), CommandExecutor::configvalueclass_s);
-                            if (CommandExecutor::configvalueclass_s != 0)
+                        if (CommandExecutor::getInstance().tokens_s.size() >= 3)
+                        {
+                            CommandExecutor::getInstance().configvalue_s = CommandExecutor::getContainerOfPossibleConfigValue(CommandExecutor::getToken(2), CommandExecutor::getInstance().configvalueclass_s);
+                            if (CommandExecutor::getInstance().configvalueclass_s != 0)
                             {
                                 // There is a perfect match: Add a whitespace and continue parsing
-                                CommandExecutor::state_s = CS_ConfigValueType;
+                                CommandExecutor::getInstance().state_s = CS_ConfigValueType;
                                 CommandExecutor::parse(command + " ", false);
                                 return;
@@ -562,6 +549,5 @@
 
                         // No perfect match: Create the list of all possible config values
-                        CommandExecutor::createListOfPossibleConfigValues(CommandExecutor::getToken(2), CommandExecutor::configvalueclass_s);
-                        CommandExecutor::state_s = CS_ConfigValueType;
+                        CommandExecutor::createListOfPossibleConfigValues(CommandExecutor::getToken(2), CommandExecutor::getInstance().configvalueclass_s);
                         return;
                     }
@@ -570,16 +556,16 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
                 break;
             case CS_ConfigValueType:
-                if (((CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE) || (CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE_TEMPORARY)) && (CommandExecutor::configvalueclass_s != 0) && (CommandExecutor::configvalue_s != 0))
+                if (((CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE) || (CommandExecutor::getToken(0) == COMMAND_EXECUTOR_KEYWORD_SET_CONFIG_VALUE_TEMPORARY)) && (CommandExecutor::getInstance().configvalueclass_s != 0) && (CommandExecutor::getInstance().configvalue_s != 0))
                 {
                     // Valid command
                     // Check if there are enough parameters
-                    if (CommandExecutor::tokens_s.size() >= 4)
-                    {
-                        CommandExecutor::state_s = CS_ConfigValueFinished;
+                    if (CommandExecutor::getInstance().tokens_s.size() >= 4)
+                    {
+                        CommandExecutor::getInstance().state_s = CS_ConfigValueFinished;
                         return;
                     }
@@ -588,5 +574,5 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
@@ -600,5 +586,5 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
@@ -609,7 +595,7 @@
                     // Valid command
                     // Check if there are enough parameters
-                    if (CommandExecutor::tokens_s.size() >= 3)
-                    {
-                        CommandExecutor::state_s = CS_KeybindFinished;
+                    if (CommandExecutor::getInstance().tokens_s.size() >= 3)
+                    {
+                        CommandExecutor::getInstance().state_s = CS_KeybindFinished;
                         return;
                     }
@@ -619,5 +605,5 @@
                 {
                     // Something is wrong
-                    CommandExecutor::state_s = CS_Error;
+                    CommandExecutor::getInstance().state_s = CS_Error;
                     return;
                 }
@@ -643,20 +629,20 @@
     void CommandExecutor::initialize()
     {
-        CommandExecutor::listOfPossibleFunctionClasses_s.clear();
-        CommandExecutor::listOfPossibleShortcuts_s.clear();
-        CommandExecutor::listOfPossibleFunctions_s.clear();
-        CommandExecutor::listOfPossibleConfigValueClasses_s.clear();
-        CommandExecutor::listOfPossibleConfigValues_s.clear();
-        CommandExecutor::listOfPossibleKeys_s.clear();
-
-        CommandExecutor::functionclass_s = 0;
-        CommandExecutor::configvalueclass_s = 0;
-        CommandExecutor::shortcut_s = 0;
-        CommandExecutor::function_s = 0;
-        CommandExecutor::configvalue_s = 0;
-        CommandExecutor::key_s = 0;
-
-        CommandExecutor::errorMessage_s = "";
-        CommandExecutor::state_s = CS_Empty;
+        CommandExecutor::getInstance().listOfPossibleFunctionClasses_s.clear();
+        CommandExecutor::getInstance().listOfPossibleShortcuts_s.clear();
+        CommandExecutor::getInstance().listOfPossibleFunctions_s.clear();
+        CommandExecutor::getInstance().listOfPossibleConfigValueClasses_s.clear();
+        CommandExecutor::getInstance().listOfPossibleConfigValues_s.clear();
+        CommandExecutor::getInstance().listOfPossibleKeys_s.clear();
+
+        CommandExecutor::getInstance().functionclass_s = 0;
+        CommandExecutor::getInstance().configvalueclass_s = 0;
+        CommandExecutor::getInstance().shortcut_s = 0;
+        CommandExecutor::getInstance().function_s = 0;
+        CommandExecutor::getInstance().configvalue_s = 0;
+        CommandExecutor::getInstance().key_s = 0;
+
+        CommandExecutor::getInstance().errorMessage_s = "";
+        CommandExecutor::getInstance().state_s = CS_Empty;
     }
 
@@ -665,5 +651,5 @@
         // Because we added a cursor we have +1 arguments
         // There are num arguments given if there are at least num arguments + one cursor
-        return (CommandExecutor::tokens_s.size() >= (num + 1));
+        return (CommandExecutor::getInstance().tokens_s.size() >= (num + 1));
     }
 
@@ -671,6 +657,6 @@
     {
         // Because we added a cursor we have +1 arguments
-        if (CommandExecutor::tokens_s.size() >= 1)
-            return (CommandExecutor::tokens_s.size() - 1);
+        if (CommandExecutor::getInstance().tokens_s.size() >= 1)
+            return (CommandExecutor::getInstance().tokens_s.size() - 1);
         else
             return 0;
@@ -679,8 +665,8 @@
     std::string CommandExecutor::getToken(unsigned int index)
     {
-        if ((index >= 0) && (index < (CommandExecutor::tokens_s.size() - 1)))
-            return CommandExecutor::tokens_s[index];
-        else if (index == (CommandExecutor::tokens_s.size() - 1))
-            return CommandExecutor::tokens_s[index].substr(0, CommandExecutor::tokens_s[index].size() - 1);
+        if ((index >= 0) && (index < (CommandExecutor::getInstance().tokens_s.size() - 1)))
+            return CommandExecutor::getInstance().tokens_s[index];
+        else if (index == (CommandExecutor::getInstance().tokens_s.size() - 1))
+            return CommandExecutor::getInstance().tokens_s[index].substr(0, CommandExecutor::getInstance().tokens_s[index].size() - 1);
         else
             return "";
@@ -697,5 +683,5 @@
                 break;
         }
-        return (CommandExecutor::tokens_s.size() >= neededParams);
+        return (CommandExecutor::getInstance().tokens_s.size() >= neededParams);
     }
 
@@ -708,10 +694,10 @@
                 if ((*it).first.find(getLowercase(fragment)) == 0)
                 {
-                    CommandExecutor::listOfPossibleFunctionClasses_s.push_back(&(*it).first);
+                    CommandExecutor::getInstance().listOfPossibleFunctionClasses_s.push_back(&(*it).first);
                 }
             }
         }
 
-        CommandExecutor::listOfPossibleFunctionClasses_s.sort(CommandExecutor::compareStringsInList);
+        CommandExecutor::getInstance().listOfPossibleFunctionClasses_s.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -722,9 +708,9 @@
             if ((*it).first.find(getLowercase(fragment)) == 0)
             {
-                CommandExecutor::listOfPossibleShortcuts_s.push_back(&(*it).first);
+                CommandExecutor::getInstance().listOfPossibleShortcuts_s.push_back(&(*it).first);
             }
         }
 
-        CommandExecutor::listOfPossibleShortcuts_s.sort(CommandExecutor::compareStringsInList);
+        CommandExecutor::getInstance().listOfPossibleShortcuts_s.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -735,9 +721,9 @@
             if ((*it).first.find(getLowercase(fragment)) == 0)
             {
-                CommandExecutor::listOfPossibleFunctions_s.push_back(&(*it).first);
+                CommandExecutor::getInstance().listOfPossibleFunctions_s.push_back(&(*it).first);
             }
         }
 
-        CommandExecutor::listOfPossibleFunctions_s.sort(CommandExecutor::compareStringsInList);
+        CommandExecutor::getInstance().listOfPossibleFunctions_s.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -750,10 +736,10 @@
                 if ((*it).first.find(getLowercase(fragment)) == 0)
                 {
-                    CommandExecutor::listOfPossibleConfigValueClasses_s.push_back(&(*it).first);
+                    CommandExecutor::getInstance().listOfPossibleConfigValueClasses_s.push_back(&(*it).first);
                 }
             }
         }
 
-        CommandExecutor::listOfPossibleConfigValueClasses_s.sort(CommandExecutor::compareStringsInList);
+        CommandExecutor::getInstance().listOfPossibleConfigValueClasses_s.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -764,9 +750,9 @@
             if ((*it).first.find(getLowercase(fragment)) == 0)
             {
-                CommandExecutor::listOfPossibleConfigValues_s.push_back(&(*it).first);
+                CommandExecutor::getInstance().listOfPossibleConfigValues_s.push_back(&(*it).first);
             }
         }
 
-        CommandExecutor::listOfPossibleConfigValues_s.sort(CommandExecutor::compareStringsInList);
+        CommandExecutor::getInstance().listOfPossibleConfigValues_s.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -775,5 +761,5 @@
         // todo
 
-        CommandExecutor::listOfPossibleKeys_s.sort(CommandExecutor::compareStringsInList);
+        CommandExecutor::getInstance().listOfPossibleKeys_s.sort(CommandExecutor::compareStringsInList);
     }
 
Index: code/branches/core2/src/orxonox/core/CommandExecutor.h
===================================================================
--- code/branches/core2/src/orxonox/core/CommandExecutor.h	(revision 948)
+++ code/branches/core2/src/orxonox/core/CommandExecutor.h	(revision 949)
@@ -33,7 +33,8 @@
 #include <list>
 
+#include "util/SubString.h"
 #include "CorePrereqs.h"
 
-class SubString;
+#define COMMAND_EXECUTOR_CURSOR '$'
 
 namespace orxonox
@@ -70,18 +71,20 @@
 
             /** @brief Returns the map that stores all console commands. @return The const_iterator */
-            static inline const std::map<std::string, ExecutorStatic*>& getConsoleCommandShortcutMap() { return CommandExecutor::consoleCommandShortcuts_s; }
+            static inline const std::map<std::string, ExecutorStatic*>& getConsoleCommandShortcutMap() { return CommandExecutor::getInstance().consoleCommandShortcuts_s; }
             /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
-            static inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandShortcutMapBegin() { return CommandExecutor::consoleCommandShortcuts_s.begin(); }
+            static inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandShortcutMapBegin() { return CommandExecutor::getInstance().consoleCommandShortcuts_s.begin(); }
             /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
-            static inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandShortcutMapEnd() { return CommandExecutor::consoleCommandShortcuts_s.end(); }
+            static inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandShortcutMapEnd() { return CommandExecutor::getInstance().consoleCommandShortcuts_s.end(); }
 
             /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
-            static inline const std::map<std::string, ExecutorStatic*>& getLowercaseConsoleCommandShortcutMap() { return CommandExecutor::consoleCommandShortcuts_LC_s; }
+            static inline const std::map<std::string, ExecutorStatic*>& getLowercaseConsoleCommandShortcutMap() { return CommandExecutor::getInstance().consoleCommandShortcuts_LC_s; }
             /** @brief Returns a const_iterator to the beginning of the map that stores all console commands with their names in lowercase. @return The const_iterator */
-            static inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandShortcutMapBegin() { return CommandExecutor::consoleCommandShortcuts_LC_s.begin(); }
+            static inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandShortcutMapBegin() { return CommandExecutor::getInstance().consoleCommandShortcuts_LC_s.begin(); }
             /** @brief Returns a const_iterator to the end of the map that stores all console commands with their names in lowercase. @return The const_iterator */
-            static inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandShortcutMapEnd() { return CommandExecutor::consoleCommandShortcuts_LC_s.end(); }
+            static inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandShortcutMapEnd() { return CommandExecutor::getInstance().consoleCommandShortcuts_LC_s.end(); }
 
         private:
+            static CommandExecutor& getInstance();
+
             static void parse(const std::string& command, bool bInitialize = true);
             static void initialize();
@@ -116,27 +119,25 @@
             static ConfigValueContainer* getContainerOfPossibleKey(const std::string& name);
 
-            static const char cursor_s = '$';
+            std::string lastProcessedCommand_s;
+            SubString tokens_s;
+            std::list<const std::string*> listOfPossibleFunctionClasses_s;
+            std::list<const std::string*> listOfPossibleShortcuts_s;
+            std::list<const std::string*> listOfPossibleFunctions_s;
+            std::list<const std::string*> listOfPossibleConfigValueClasses_s;
+            std::list<const std::string*> listOfPossibleConfigValues_s;
+            std::list<const std::string*> listOfPossibleKeys_s;
 
-            static std::string lastProcessedCommand_s;
-            static SubString tokens_s;
-            static std::list<const std::string*> listOfPossibleFunctionClasses_s;
-            static std::list<const std::string*> listOfPossibleShortcuts_s;
-            static std::list<const std::string*> listOfPossibleFunctions_s;
-            static std::list<const std::string*> listOfPossibleConfigValueClasses_s;
-            static std::list<const std::string*> listOfPossibleConfigValues_s;
-            static std::list<const std::string*> listOfPossibleKeys_s;
+            Identifier* functionclass_s;
+            Identifier* configvalueclass_s;
+            ExecutorStatic* shortcut_s;
+            ExecutorStatic* function_s;
+            ConfigValueContainer* configvalue_s;
+            ConfigValueContainer* key_s;
 
-            static Identifier* functionclass_s;
-            static Identifier* configvalueclass_s;
-            static ExecutorStatic* shortcut_s;
-            static ExecutorStatic* function_s;
-            static ConfigValueContainer* configvalue_s;
-            static ConfigValueContainer* key_s;
+            std::string errorMessage_s;
+            CommandState state_s;
 
-            static std::string errorMessage_s;
-            static CommandState state_s;
-
-            static std::map<std::string, ExecutorStatic*> consoleCommandShortcuts_s;
-            static std::map<std::string, ExecutorStatic*> consoleCommandShortcuts_LC_s;
+            std::map<std::string, ExecutorStatic*> consoleCommandShortcuts_s;
+            std::map<std::string, ExecutorStatic*> consoleCommandShortcuts_LC_s;
     };
 }
Index: code/branches/core2/src/orxonox/core/ConfigValueContainer.cc
===================================================================
--- code/branches/core2/src/orxonox/core/ConfigValueContainer.cc	(revision 948)
+++ code/branches/core2/src/orxonox/core/ConfigValueContainer.cc	(revision 949)
@@ -921,4 +921,6 @@
         std::ofstream file;
         file.open(filename.c_str(), std::fstream::out);
+        file.setf(std::ios::fixed, std::ios::floatfield);
+        file.precision(6);
 
         if (!file.is_open())
Index: code/branches/core2/src/orxonox/core/ConsoleCommand.h
===================================================================
--- code/branches/core2/src/orxonox/core/ConsoleCommand.h	(revision 948)
+++ code/branches/core2/src/orxonox/core/ConsoleCommand.h	(revision 949)
@@ -40,5 +40,5 @@
 
 #define ConsoleCommandGeneric(fakevariable, classname, executor, bCreateShortcut) \
-//    Executor& fakevariable = ClassManager<classname>::getIdentifier()->addConsoleCommand((ExecutorStatic*)executor, bCreateShortcut)
+    Executor& fakevariable = ClassManager<classname>::getIdentifier()->addConsoleCommand((ExecutorStatic*)executor, bCreateShortcut)
 
 
@@ -47,5 +47,5 @@
 
 #define ConsoleCommandShortcutGeneric(fakevariable, executor) \
-//    bool fakevariable = CommandExecutor::addConsoleCommandShortcut((ExecutorStatic*)executor)
+    bool fakevariable = CommandExecutor::addConsoleCommandShortcut((ExecutorStatic*)executor)
 
 
Index: code/branches/core2/src/orxonox/core/OutputHandler.h
===================================================================
--- code/branches/core2/src/orxonox/core/OutputHandler.h	(revision 948)
+++ code/branches/core2/src/orxonox/core/OutputHandler.h	(revision 949)
@@ -61,5 +61,5 @@
             /** @brief Puts some text on the outstream. @param text The text */
             static inline void log(const std::string& text)
-                { OutputHandler::getOutStream().output(text); }
+                { OutputHandler::getOutStream().setOutputLevel(0); OutputHandler::getOutStream().output(text); }
 
             /** @brief Returns a reference to the logfile. @return The logfile */
