Index: code/branches/console/src/core/CMakeLists.txt
===================================================================
--- code/branches/console/src/core/CMakeLists.txt	(revision 1340)
+++ code/branches/console/src/core/CMakeLists.txt	(revision 1341)
@@ -17,6 +17,8 @@
   OutputBuffer.cc
   InputBuffer.cc
+  Shell.cc
   CommandExecutor.cc
-  Shell.cc
+  CommandEvaluation.cc
+  ConsoleCommandCompilation.cc
   Language.cc
   ClassTreeMask.cc
Index: code/branches/console/src/core/CommandEvaluation.cc
===================================================================
--- code/branches/console/src/core/CommandEvaluation.cc	(revision 1341)
+++ code/branches/console/src/core/CommandEvaluation.cc	(revision 1341)
@@ -0,0 +1,204 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "CommandEvaluation.h"
+#include "ConsoleCommand.h"
+
+namespace orxonox
+{
+    CommandEvaluation::CommandEvaluation()
+    {
+        this->processedCommand_ = "";
+        this->additionalParameter_ = "";
+
+        this->functionclass_ = 0;
+        this->configvalueclass_ = 0;
+        this->shortcut_ = 0;
+        this->function_ = 0;
+        this->configvalue_ = 0;
+        this->key_ = 0;
+
+        this->errorMessage_ = "";
+        this->state_ = CS_Uninitialized;
+
+        this->bEvaluatedParams_ = false;
+        this->evaluatedExecutor_ = 0;
+    }
+
+    KeybindMode CommandEvaluation::getKeybindMode()
+    {
+        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
+        {
+//            if (this->shortcut_ != 0)
+//                return this->shortcut_->getKeybindMode();
+        }
+        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
+        {
+//            if (this->function_ != 0)
+//                return this->function_->getKeybindMode();
+        }
+        else if (this->state_ == CS_ConfigValueType || this->state_ == CS_ConfigValueFinished)
+        {
+//            return KeybindMode::onPress;
+        }
+        else if (this->state_ == CS_KeybindCommand || this->state_ == CS_KeybindFinished)
+        {
+//            return KeybindMode::onPress;
+        }
+        else
+        {
+//            return KeybindMode::onPress;
+        }
+        // FIXME: Had to insert a return statement
+        return (KeybindMode)0;
+    }
+
+    bool CommandEvaluation::isValid() const
+    {
+        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
+        {
+            return this->shortcut_;
+        }
+        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
+        {
+            return (this->functionclass_ && this->function_);
+        }
+        else if (this->state_ == CS_ConfigValueType || this->state_ == CS_ConfigValueFinished)
+        {
+            return (this->configvalueclass_ && this->configvalue_);
+        }
+        else if (this->state_ == CS_KeybindCommand || this->state_ == CS_KeybindFinished)
+        {
+            return this->key_;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    void CommandEvaluation::evaluateParams()
+    {
+        this->bEvaluatedParams_ = false;
+        this->evaluatedExecutor_ = 0;
+
+        for (unsigned int i = 0; i < MAX_FUNCTOR_ARGUMENTS; i++)
+            this->param_[i] = MT_null;
+
+        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
+        {
+            if (this->shortcut_)
+            {
+                if (this->tokens_.size() <= 1)
+                {
+                    if (this->shortcut_->evaluate(this->getAdditionalParameter(), this->param_, " "))
+                    {
+                        this->bEvaluatedParams_ = true;
+                        this->evaluatedExecutor_ = this->shortcut_;
+                    }
+                }
+                else if (this->tokens_.size() > 1)
+                {
+                    if (this->shortcut_->evaluate(this->tokens_.subSet(1).join() + this->getAdditionalParameter(), this->param_, " "))
+                    {
+                        this->bEvaluatedParams_ = true;
+                        this->evaluatedExecutor_ = this->shortcut_;
+                    }
+                }
+            }
+        }
+        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
+        {
+            if (this->function_)
+            {
+                if (this->tokens_.size() <= 2)
+                {
+                    if (this->function_->evaluate(this->getAdditionalParameter(), this->param_, " "))
+                    {
+                        this->bEvaluatedParams_ = true;
+                        this->evaluatedExecutor_ = this->function_;
+                    }
+                }
+                else if (this->tokens_.size() > 2)
+                {
+                    if (this->function_->evaluate(this->tokens_.subSet(2).join() + this->getAdditionalParameter(), this->param_, " "))
+                    {
+                        this->bEvaluatedParams_ = true;
+                        this->evaluatedExecutor_ = this->function_;
+                    }
+                }
+            }
+        }
+    }
+
+    void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiTypeMath param)
+    {
+        if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+            this->param_[index] = param;
+    }
+
+    MultiTypeMath CommandEvaluation::getEvaluatedParameter(unsigned int index) const
+    {
+        if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
+            return this->param_[index];
+
+        return MT_null;
+    }
+
+    bool CommandEvaluation::hasReturnvalue() const
+    {
+        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
+        {
+            if (this->shortcut_)
+                return this->shortcut_->hasReturnvalue();
+        }
+        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
+        {
+            if (this->function_)
+                return this->function_->hasReturnvalue();
+        }
+
+        return MT_null;
+    }
+
+    MultiTypeMath CommandEvaluation::getReturnvalue() const
+    {
+        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
+        {
+            if (this->shortcut_)
+                return this->shortcut_->getReturnvalue();
+        }
+        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
+        {
+            if (this->function_)
+                return this->function_->getReturnvalue();
+        }
+
+        return MT_null;
+    }
+}
Index: code/branches/console/src/core/CommandEvaluation.h
===================================================================
--- code/branches/console/src/core/CommandEvaluation.h	(revision 1341)
+++ code/branches/console/src/core/CommandEvaluation.h	(revision 1341)
@@ -0,0 +1,115 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _CommandEvaluation_H__
+#define _CommandEvaluation_H__
+
+#include "CorePrereqs.h"
+
+#include <string>
+#include <list>
+
+#include "util/SubString.h"
+#include "util/MultiTypeMath.h"
+
+namespace orxonox
+{
+    enum CommandState
+    {
+        CS_Uninitialized,
+        CS_Empty,
+        CS_FunctionClass_Or_Shortcut_Or_Keyword,
+        CS_Shortcut_Params,
+        CS_Shortcut_Finished,
+        CS_Function,
+        CS_Function_Params,
+        CS_Function_Finished,
+        CS_ConfigValueClass,
+        CS_ConfigValue,
+        CS_ConfigValueType,
+        CS_ConfigValueFinished,
+        CS_KeybindKey,
+        CS_KeybindCommand,
+        CS_KeybindFinished,
+        CS_Error
+    };
+
+    enum KeybindMode {}; // temporary
+
+    class _CoreExport CommandEvaluation
+    {
+        friend class CommandExecutor;
+
+        public:
+            CommandEvaluation();
+
+            KeybindMode getKeybindMode();
+            bool isValid() const;
+
+            inline void setAdditionalParameter(const std::string& param)
+                { this->additionalParameter_ = param; this->bEvaluatedParams_ = false; }
+            inline std::string getAdditionalParameter() const
+                { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
+
+            void setEvaluatedParameter(unsigned int index, MultiTypeMath param);
+            MultiTypeMath getEvaluatedParameter(unsigned int index) const;
+
+            void evaluateParams();
+
+            bool hasReturnvalue() const;
+            MultiTypeMath getReturnvalue() const;
+
+        private:
+            std::string processedCommand_;
+            SubString tokens_;
+            std::string additionalParameter_;
+
+            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleFunctionClasses_;
+            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleShortcuts_;
+            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleFunctions_;
+            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleConfigValueClasses_;
+            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleConfigValues_;
+            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleKeys_;
+
+            Identifier* functionclass_;
+            Identifier* configvalueclass_;
+            ConsoleCommand* shortcut_;
+            ConsoleCommand* function_;
+            ConfigValueContainer* configvalue_;
+            ConfigValueContainer* key_;
+
+            std::string errorMessage_;
+            CommandState state_;
+
+            bool bEvaluatedParams_;
+            MultiTypeMath param_[5];
+            ConsoleCommand* evaluatedExecutor_;
+    };
+}
+
+#endif /* _CommandEvaluation_H__ */
Index: code/branches/console/src/core/CommandExecutor.cc
===================================================================
--- code/branches/console/src/core/CommandExecutor.cc	(revision 1340)
+++ code/branches/console/src/core/CommandExecutor.cc	(revision 1341)
@@ -44,299 +44,8 @@
 namespace orxonox
 {
-    ConsoleCommandShortcutGeneric(keyword1, createExecutor((FunctorStatic*)0, "set", AccessLevel::User));
-    ConsoleCommandShortcutGeneric(keyword2, createExecutor((FunctorStatic*)0, "tset", AccessLevel::User));
-    ConsoleCommandShortcutGeneric(keyword3, createExecutor((FunctorStatic*)0, "bind", AccessLevel::User));
-
-    ConsoleCommandShortcutExtern(source, AccessLevel::None);
-    ConsoleCommandShortcutExtern(echo, AccessLevel::None);
-    ConsoleCommandShortcutExtern(puts, AccessLevel::None);
-
-    ConsoleCommandShortcutExtern(read, AccessLevel::None);
-    ConsoleCommandShortcutExtern(append, AccessLevel::None);
-    ConsoleCommandShortcutExtern(write, AccessLevel::None);
-
-    void source(const std::string& filename)
-    {
-        static std::set<std::string> executingFiles;
-
-        std::set<std::string>::const_iterator it = executingFiles.find(filename);
-        if (it != executingFiles.end())
-        {
-            COUT(1) << "Error: Recurring source command in \"" << filename << "\". Stopped execution." << std::endl;
-            return;
-        }
-
-        // Open the file
-        std::ifstream file;
-        file.open(filename.c_str(), std::fstream::in);
-
-        if (!file.is_open())
-        {
-            COUT(1) << "Error: Couldn't open file \"" << filename << "\"." << std::endl;
-            return;
-        }
-
-        executingFiles.insert(filename);
-
-        // Iterate through the file and put the lines into the CommandExecutor
-        char line[1024];
-        while (file.good() && !file.eof())
-        {
-            file.getline(line, 1024);
-            CommandExecutor::execute(line);
-        }
-
-        executingFiles.erase(filename);
-        file.close();
-    }
-
-    std::string echo(const std::string& text)
-    {
-        std::cout << text << std::endl;
-        return text;
-    }
-
-    void puts(bool newline, const std::string& text)
-    {
-        if (newline)
-            COUT(0) << text << std::endl;
-        else
-            COUT(0) << text;
-    }
-
-    void write(const std::string& filename, const std::string& text)
-    {
-        std::ofstream file;
-        file.open(filename.c_str(), std::fstream::out);
-
-        if (!file.is_open())
-        {
-            COUT(1) << "Error: Couldn't write to file \"" << filename << "\"." << std::endl;
-            return;
-        }
-
-        file << text << std::endl;
-        file.close();
-    }
-
-    void append(const std::string& filename, const std::string& text)
-    {
-        std::ofstream file;
-        file.open(filename.c_str(), std::fstream::app);
-
-        if (!file.is_open())
-        {
-            COUT(1) << "Error: Couldn't append to file \"" << filename << "\"." << std::endl;
-            return;
-        }
-
-        file << text << std::endl;
-        file.close();
-    }
-
-    std::string read(const std::string& filename)
-    {
-        std::ifstream file;
-        file.open(filename.c_str(), std::fstream::in);
-
-        if (!file.is_open())
-        {
-            COUT(1) << "Error: Couldn't read from file \"" << filename << "\"." << std::endl;
-            return "";
-        }
-
-        std::string output = "";
-        char line[1024];
-        while (file.good() && !file.eof())
-        {
-            file.getline(line, 1024);
-            output += line;
-            output += "\n";
-        }
-
-        file.close();
-
-        return output;
-    }
-
-
-    ///////////////////////
-    // CommandEvaluation //
-    ///////////////////////
-    CommandEvaluation::CommandEvaluation()
-    {
-        this->processedCommand_ = "";
-        this->additionalParameter_ = "";
-
-        this->functionclass_ = 0;
-        this->configvalueclass_ = 0;
-        this->shortcut_ = 0;
-        this->function_ = 0;
-        this->configvalue_ = 0;
-        this->key_ = 0;
-
-        this->errorMessage_ = "";
-        this->state_ = CS_Uninitialized;
-
-        this->bEvaluatedParams_ = false;
-        this->evaluatedExecutor_ = 0;
-    }
-
-    KeybindMode CommandEvaluation::getKeybindMode()
-    {
-        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
-        {
-//            if (this->shortcut_ != 0)
-//                return this->shortcut_->getKeybindMode();
-        }
-        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
-        {
-//            if (this->function_ != 0)
-//                return this->function_->getKeybindMode();
-        }
-        else if (this->state_ == CS_ConfigValueType || this->state_ == CS_ConfigValueFinished)
-        {
-//            return KeybindMode::onPress;
-        }
-        else if (this->state_ == CS_KeybindCommand || this->state_ == CS_KeybindFinished)
-        {
-//            return KeybindMode::onPress;
-        }
-        else
-        {
-//            return KeybindMode::onPress;
-        }
-        // FIXME: Had to insert a return statement
-        return (KeybindMode)0;
-    }
-
-    bool CommandEvaluation::isValid() const
-    {
-        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
-        {
-            return this->shortcut_;
-        }
-        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
-        {
-            return (this->functionclass_ && this->function_);
-        }
-        else if (this->state_ == CS_ConfigValueType || this->state_ == CS_ConfigValueFinished)
-        {
-            return (this->configvalueclass_ && this->configvalue_);
-        }
-        else if (this->state_ == CS_KeybindCommand || this->state_ == CS_KeybindFinished)
-        {
-            return this->key_;
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    void CommandEvaluation::evaluateParams()
-    {
-        this->bEvaluatedParams_ = false;
-        this->evaluatedExecutor_ = 0;
-
-        for (unsigned int i = 0; i < MAX_FUNCTOR_ARGUMENTS; i++)
-            this->param_[i] = MT_null;
-
-        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
-        {
-            if (this->shortcut_)
-            {
-                if (this->tokens_.size() <= 1)
-                {
-                    if (this->shortcut_->evaluate(this->getAdditionalParameter(), this->param_, " "))
-                    {
-                        this->bEvaluatedParams_ = true;
-                        this->evaluatedExecutor_ = this->shortcut_;
-                    }
-                }
-                else if (this->tokens_.size() > 1)
-                {
-                    if (this->shortcut_->evaluate(this->tokens_.subSet(1).join() + this->getAdditionalParameter(), this->param_, " "))
-                    {
-                        this->bEvaluatedParams_ = true;
-                        this->evaluatedExecutor_ = this->shortcut_;
-                    }
-                }
-            }
-        }
-        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
-        {
-            if (this->function_)
-            {
-                if (this->tokens_.size() <= 2)
-                {
-                    if (this->function_->evaluate(this->getAdditionalParameter(), this->param_, " "))
-                    {
-                        this->bEvaluatedParams_ = true;
-                        this->evaluatedExecutor_ = this->function_;
-                    }
-                }
-                else if (this->tokens_.size() > 2)
-                {
-                    if (this->function_->evaluate(this->tokens_.subSet(2).join() + this->getAdditionalParameter(), this->param_, " "))
-                    {
-                        this->bEvaluatedParams_ = true;
-                        this->evaluatedExecutor_ = this->function_;
-                    }
-                }
-            }
-        }
-    }
-
-    void CommandEvaluation::setEvaluatedParameter(unsigned int index, MultiTypeMath param)
-    {
-        if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
-            this->param_[index] = param;
-    }
-
-    MultiTypeMath CommandEvaluation::getEvaluatedParameter(unsigned int index) const
-    {
-        if (index >= 0 && index < MAX_FUNCTOR_ARGUMENTS)
-            return this->param_[index];
-
-        return MT_null;
-    }
-
-    bool CommandEvaluation::hasReturnvalue() const
-    {
-        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
-        {
-            if (this->shortcut_)
-                return this->shortcut_->hasReturnvalue();
-        }
-        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
-        {
-            if (this->function_)
-                return this->function_->hasReturnvalue();
-        }
-
-        return MT_null;
-    }
-
-    MultiTypeMath CommandEvaluation::getReturnvalue() const
-    {
-        if (this->state_ == CS_Shortcut_Params || this->state_ == CS_Shortcut_Finished)
-        {
-            if (this->shortcut_)
-                return this->shortcut_->getReturnvalue();
-        }
-        else if (this->state_ == CS_Function_Params || this->state_ == CS_Function_Finished)
-        {
-            if (this->function_)
-                return this->function_->getReturnvalue();
-        }
-
-        return MT_null;
-    }
-
-
-    /////////////////////
-    // CommandExecutor //
-    /////////////////////
+    SetConsoleCommandShortcutGeneric(keyword1, createExecutor((FunctorStatic*)0, "set")).setAccessLevel(AccessLevel::User);
+    SetConsoleCommandShortcutGeneric(keyword2, createExecutor((FunctorStatic*)0, "tset")).setAccessLevel(AccessLevel::User);
+    SetConsoleCommandShortcutGeneric(keyword3, createExecutor((FunctorStatic*)0, "bind")).setAccessLevel(AccessLevel::User);
+
     CommandExecutor& CommandExecutor::getInstance()
     {
@@ -355,9 +64,9 @@
     }
 
-    Executor& CommandExecutor::addConsoleCommandShortcut(ExecutorStatic* executor)
-    {
-        CommandExecutor::getInstance().consoleCommandShortcuts_[executor->getName()] = executor;
-        CommandExecutor::getInstance().consoleCommandShortcuts_LC_[getLowercase(executor->getName())] = executor;
-        return (*executor);
+    ConsoleCommand& CommandExecutor::addConsoleCommandShortcut(ConsoleCommand* command)
+    {
+        CommandExecutor::getInstance().consoleCommandShortcuts_[command->getName()] = command;
+        CommandExecutor::getInstance().consoleCommandShortcuts_LC_[getLowercase(command->getName())] = command;
+        return (*command);
     }
 
@@ -367,7 +76,7 @@
         @return The executor of the requested console command shortcut
     */
-    ExecutorStatic* CommandExecutor::getConsoleCommandShortcut(const std::string& name)
-    {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_.find(name);
+    ConsoleCommand* CommandExecutor::getConsoleCommandShortcut(const std::string& name)
+    {
+        std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_.find(name);
         if (it != CommandExecutor::getInstance().consoleCommandShortcuts_.end())
             return (*it).second;
@@ -381,7 +90,7 @@
         @return The executor of the requested console command shortcut
     */
-    ExecutorStatic* CommandExecutor::getLowercaseConsoleCommandShortcut(const std::string& name)
-    {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_LC_.find(name);
+    ConsoleCommand* CommandExecutor::getLowercaseConsoleCommandShortcut(const std::string& name)
+    {
+        std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getInstance().consoleCommandShortcuts_LC_.find(name);
         if (it != CommandExecutor::getInstance().consoleCommandShortcuts_LC_.end())
             return (*it).second;
@@ -1187,5 +896,5 @@
     void CommandExecutor::createListOfPossibleShortcuts(const std::string& fragment)
     {
-        for (std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMapBegin(); it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd(); ++it)
+        for (std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMapBegin(); it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd(); ++it)
         {
             if ((*it).first.find(getLowercase(fragment)) == 0 || fragment == "")
@@ -1200,5 +909,5 @@
     void CommandExecutor::createListOfPossibleFunctions(const std::string& fragment, Identifier* identifier)
     {
-        for (std::map<std::string, ExecutorStatic*>::const_iterator it = identifier->getLowercaseConsoleCommandMapBegin(); it != identifier->getLowercaseConsoleCommandMapEnd(); ++it)
+        for (std::map<std::string, ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMapBegin(); it != identifier->getLowercaseConsoleCommandMapEnd(); ++it)
         {
             if ((*it).first.find(getLowercase(fragment)) == 0 || fragment == "")
@@ -1261,7 +970,7 @@
     }
 
-    ExecutorStatic* CommandExecutor::getExecutorOfPossibleShortcut(const std::string& name)
-    {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMap().find(getLowercase(name));
+    ConsoleCommand* CommandExecutor::getExecutorOfPossibleShortcut(const std::string& name)
+    {
+        std::map<std::string, ConsoleCommand*>::const_iterator it = CommandExecutor::getLowercaseConsoleCommandShortcutMap().find(getLowercase(name));
         if (it != CommandExecutor::getLowercaseConsoleCommandShortcutMapEnd())
             return (*it).second;
@@ -1270,7 +979,7 @@
     }
 
-    ExecutorStatic* CommandExecutor::getExecutorOfPossibleFunction(const std::string& name, Identifier* identifier)
-    {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = identifier->getLowercaseConsoleCommandMap().find(getLowercase(name));
+    ConsoleCommand* CommandExecutor::getExecutorOfPossibleFunction(const std::string& name, Identifier* identifier)
+    {
+        std::map<std::string, ConsoleCommand*>::const_iterator it = identifier->getLowercaseConsoleCommandMap().find(getLowercase(name));
         if (it != identifier->getLowercaseConsoleCommandMapEnd())
             return (*it).second;
@@ -1319,21 +1028,21 @@
     }
 
-    std::string CommandExecutor::dump(const ExecutorStatic* executor)
+    std::string CommandExecutor::dump(const ConsoleCommand* command)
     {
         std::string output = "";
-        for (unsigned int i = 0; i < executor->getParamCount(); i++)
+        for (unsigned int i = 0; i < command->getParamCount(); i++)
         {
             if (i != 0)
                 output += " ";
 
-            if (executor->defaultValueSet(i))
+            if (command->defaultValueSet(i))
                 output += "[";
             else
                 output += "{";
 
-            output += executor->getTypenameParam(i);
-
-            if (executor->defaultValueSet(i))
-                output += "=" + executor->getDefaultValue(i).toString() + "]";
+            output += command->getTypenameParam(i);
+
+            if (command->defaultValueSet(i))
+                output += "=" + command->getDefaultValue(i).toString() + "]";
             else
                 output += "}";
Index: code/branches/console/src/core/CommandExecutor.h
===================================================================
--- code/branches/console/src/core/CommandExecutor.h	(revision 1340)
+++ code/branches/console/src/core/CommandExecutor.h	(revision 1341)
@@ -32,10 +32,7 @@
 #include "CorePrereqs.h"
 
-#include <string>
 #include <map>
-#include <list>
 
-#include "util/SubString.h"
-#include "util/MultiTypeMath.h"
+#include "CommandEvaluation.h"
 
 #define COMMAND_EXECUTOR_CURSOR "$"
@@ -43,90 +40,4 @@
 namespace orxonox
 {
-    enum CommandState
-    {
-        CS_Uninitialized,
-        CS_Empty,
-        CS_FunctionClass_Or_Shortcut_Or_Keyword,
-        CS_Shortcut_Params,
-        CS_Shortcut_Finished,
-        CS_Function,
-        CS_Function_Params,
-        CS_Function_Finished,
-        CS_ConfigValueClass,
-        CS_ConfigValue,
-        CS_ConfigValueType,
-        CS_ConfigValueFinished,
-        CS_KeybindKey,
-        CS_KeybindCommand,
-        CS_KeybindFinished,
-        CS_Error
-    };
-
-    void source(const std::string& filename);
-    std::string echo(const std::string& text);
-    void puts(bool newline, const std::string& test);
-
-    void write(const std::string& filename, const std::string& text);
-    void append(const std::string& filename, const std::string& text);
-    std::string read(const std::string& filename);
-
-    enum KeybindMode {}; // temporary
-
-    ///////////////////////
-    // CommandEvaluation //
-    ///////////////////////
-    class _CoreExport CommandEvaluation
-    {
-        friend class CommandExecutor;
-
-        public:
-            CommandEvaluation();
-
-            KeybindMode getKeybindMode();
-            bool isValid() const;
-
-            inline void setAdditionalParameter(const std::string& param)
-                { this->additionalParameter_ = param; this->bEvaluatedParams_ = false; }
-            inline std::string getAdditionalParameter() const
-                { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
-
-            void setEvaluatedParameter(unsigned int index, MultiTypeMath param);
-            MultiTypeMath getEvaluatedParameter(unsigned int index) const;
-
-            void evaluateParams();
-
-            bool hasReturnvalue() const;
-            MultiTypeMath getReturnvalue() const;
-
-        private:
-            std::string processedCommand_;
-            SubString tokens_;
-            std::string additionalParameter_;
-
-            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleFunctionClasses_;
-            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleShortcuts_;
-            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleFunctions_;
-            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleConfigValueClasses_;
-            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleConfigValues_;
-            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleKeys_;
-
-            Identifier* functionclass_;
-            Identifier* configvalueclass_;
-            ExecutorStatic* shortcut_;
-            ExecutorStatic* function_;
-            ConfigValueContainer* configvalue_;
-            ConfigValueContainer* key_;
-
-            std::string errorMessage_;
-            CommandState state_;
-
-            bool bEvaluatedParams_;
-            MultiTypeMath param_[5];
-            ExecutorStatic* evaluatedExecutor_;
-    };
-
-    /////////////////////
-    // CommandExecutor //
-    /////////////////////
     class _CoreExport CommandExecutor
     {
@@ -145,21 +56,21 @@
             static const CommandEvaluation& getLastEvaluation();
 
-            static Executor& addConsoleCommandShortcut(ExecutorStatic* executor);
-            static ExecutorStatic* getConsoleCommandShortcut(const std::string& name);
-            static ExecutorStatic* getLowercaseConsoleCommandShortcut(const std::string& name);
+            static ConsoleCommand& addConsoleCommandShortcut(ConsoleCommand* command);
+            static ConsoleCommand* getConsoleCommandShortcut(const std::string& name);
+            static ConsoleCommand* getLowercaseConsoleCommandShortcut(const std::string& name);
 
             /** @brief Returns the map that stores all console commands. @return The const_iterator */
-            static inline const std::map<std::string, ExecutorStatic*>& getConsoleCommandShortcutMap() { return CommandExecutor::getInstance().consoleCommandShortcuts_; }
+            static inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandShortcutMap() { return CommandExecutor::getInstance().consoleCommandShortcuts_; }
             /** @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::getInstance().consoleCommandShortcuts_.begin(); }
+            static inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandShortcutMapBegin() { return CommandExecutor::getInstance().consoleCommandShortcuts_.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::getInstance().consoleCommandShortcuts_.end(); }
+            static inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandShortcutMapEnd() { return CommandExecutor::getInstance().consoleCommandShortcuts_.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::getInstance().consoleCommandShortcuts_LC_; }
+            static inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandShortcutMap() { return CommandExecutor::getInstance().consoleCommandShortcuts_LC_; }
             /** @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::getInstance().consoleCommandShortcuts_LC_.begin(); }
+            static inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandShortcutMapBegin() { return CommandExecutor::getInstance().consoleCommandShortcuts_LC_.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::getInstance().consoleCommandShortcuts_LC_.end(); }
+            static inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandShortcutMapEnd() { return CommandExecutor::getInstance().consoleCommandShortcuts_LC_.end(); }
 
         private:
@@ -191,5 +102,5 @@
 
             static std::string dump(const std::list<std::pair<const std::string*, const std::string*> >& list);
-            static std::string dump(const ExecutorStatic* executor);
+            static std::string dump(const ConsoleCommand* command);
             static std::string dump(const ConfigValueContainer* container);
 
@@ -197,6 +108,6 @@
 
             static Identifier* getIdentifierOfPossibleFunctionClass(const std::string& name);
-            static ExecutorStatic* getExecutorOfPossibleShortcut(const std::string& name);
-            static ExecutorStatic* getExecutorOfPossibleFunction(const std::string& name, Identifier* identifier);
+            static ConsoleCommand* getExecutorOfPossibleShortcut(const std::string& name);
+            static ConsoleCommand* getExecutorOfPossibleFunction(const std::string& name, Identifier* identifier);
             static Identifier* getIdentifierOfPossibleConfigValueClass(const std::string& name);
             static ConfigValueContainer* getContainerOfPossibleConfigValue(const std::string& name, Identifier* identifier);
@@ -205,6 +116,6 @@
             CommandEvaluation evaluation_;
 
-            std::map<std::string, ExecutorStatic*> consoleCommandShortcuts_;
-            std::map<std::string, ExecutorStatic*> consoleCommandShortcuts_LC_;
+            std::map<std::string, ConsoleCommand*> consoleCommandShortcuts_;
+            std::map<std::string, ConsoleCommand*> consoleCommandShortcuts_LC_;
     };
 }
Index: code/branches/console/src/core/ConfigFileManager.cc
===================================================================
--- code/branches/console/src/core/ConfigFileManager.cc	(revision 1340)
+++ code/branches/console/src/core/ConfigFileManager.cc	(revision 1341)
@@ -38,8 +38,8 @@
 namespace orxonox
 {
-    ConsoleCommandShortcutExtern(reloadConfig, AccessLevel::None);
-    ConsoleCommandShortcutExtern(cleanConfig, AccessLevel::None);
-    ConsoleCommandShortcutExtern(loadSettings, AccessLevel::None);
-    ConsoleCommandShortcutExtern(loadKeybindings, AccessLevel::None);
+    SetConsoleCommandShortcutExtern(reloadConfig);
+    SetConsoleCommandShortcutExtern(cleanConfig);
+    SetConsoleCommandShortcutExtern(loadSettings);
+    SetConsoleCommandShortcutExtern(loadKeybindings);
 
     void reloadConfig()
Index: code/branches/console/src/core/ConsoleCommand.h
===================================================================
--- code/branches/console/src/core/ConsoleCommand.h	(revision 1340)
+++ code/branches/console/src/core/ConsoleCommand.h	(revision 1341)
@@ -38,21 +38,74 @@
 
 
+#define SetConsoleCommand(classname, function,  bCreateShortcut) \
+    SetConsoleCommandGeneric(classname##function##consolecommand__, classname, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function), bCreateShortcut)
 
-#define ConsoleCommand(classname, function, accesslevel, bCreateShortcut) \
-    ConsoleCommandGeneric(classname##function##consolecommand__, classname, orxonox::createExecutor(orxonox::createFunctor(&classname::function), #function, accesslevel), bCreateShortcut)
-
-#define ConsoleCommandGeneric(fakevariable, classname, executor, bCreateShortcut) \
-    Executor& fakevariable = ClassManager<classname>::getIdentifier()->addConsoleCommand((ExecutorStatic*)executor, bCreateShortcut)
+#define SetConsoleCommandGeneric(fakevariable, classname, executor, bCreateShortcut) \
+    Executor& fakevariable = ClassManager<classname>::getIdentifier()->addConsoleCommand((ConsoleCommand*)executor, bCreateShortcut)
 
 
-#define ConsoleCommandShortcut(classname, function, accesslevel) \
-    ConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createExecutor(orxonox::createFunctor(&classname::function), #function, accesslevel))
+#define SetConsoleCommandShortcut(classname, function) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&classname::function), #function))
 
-#define ConsoleCommandShortcutExtern(function, accesslevel) \
-    ConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createExecutor(orxonox::createFunctor(&function), #function, accesslevel))
+#define SetConsoleCommandShortcutExtern(function) \
+    SetConsoleCommandShortcutGeneric(function##consolecommand__, orxonox::createConsoleCommand(orxonox::createFunctor(&function), #function))
 
-#define ConsoleCommandShortcutGeneric(fakevariable, executor) \
-    Executor& fakevariable = CommandExecutor::addConsoleCommandShortcut((ExecutorStatic*)executor)
+#define SetConsoleCommandShortcutGeneric(fakevariable, executor) \
+    Executor& fakevariable = CommandExecutor::addConsoleCommandShortcut((ConsoleCommand*)executor)
 
 
+namespace orxonox
+{
+    namespace AccessLevel
+    {
+        enum Level
+        {
+            None,
+            User,
+            Admin,
+            Offline,
+            Debug,
+            Disabled
+        };
+    }
+
+    class _CoreExport ConsoleCommand : public ExecutorStatic
+    {
+        public:
+            ConsoleCommand(FunctorStatic* functor, const std::string& name = "") : ExecutorStatic(functor, name), accessLevel_(AccessLevel::None) {}
+
+            inline ConsoleCommand& setDescription(const std::string& description)
+                { this->ExecutorStatic::setDescription(description); return (*this); }
+            inline ConsoleCommand& setDescriptionParam(int param, const std::string& description)
+                { this->ExecutorStatic::setDescriptionParam(param, description); return (*this); }
+            inline ConsoleCommand& setDescriptionReturnvalue(const std::string& description)
+                { this->ExecutorStatic::setDescriptionReturnvalue(description); return (*this); }
+            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1)
+                { this->ExecutorStatic::setDefaultValues(param1); return (*this); }
+            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
+                { this->ExecutorStatic::setDefaultValues(param1, param2); return (*this); }
+            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
+                { this->ExecutorStatic::setDefaultValues(param1, param2, param3); return (*this); }
+            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
+                { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4); return (*this); }
+            inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
+                { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
+            inline ConsoleCommand& setDefaultValue(unsigned int index, const MultiTypeMath& param)
+                { this->ExecutorStatic::setDefaultValue(index, param); return (*this); }
+
+            inline ConsoleCommand& setAccessLevel(AccessLevel::Level level)
+                { this->accessLevel_ = level; return (*this); }
+            inline AccessLevel::Level getAccessLevel() const
+                { return this->accessLevel_; }
+
+        private:
+            AccessLevel::Level accessLevel_;
+    };
+
+    inline ConsoleCommand* createConsoleCommand(FunctorStatic* functor, const std::string& name = "")
+    {
+        return new ConsoleCommand(functor, name);
+    }
+}
+
 #endif /* _ConsoleCommand_H__ */
Index: code/branches/console/src/core/ConsoleCommandCompilation.cc
===================================================================
--- code/branches/console/src/core/ConsoleCommandCompilation.cc	(revision 1341)
+++ code/branches/console/src/core/ConsoleCommandCompilation.cc	(revision 1341)
@@ -0,0 +1,171 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "ConsoleCommandCompilation.h"
+#include "ConsoleCommand.h"
+#include "Debug.h"
+#include "util/ExprParser.h"
+
+namespace orxonox
+{
+    SetConsoleCommandShortcutExtern(source);
+    SetConsoleCommandShortcutExtern(echo);
+    SetConsoleCommandShortcutExtern(puts);
+
+    SetConsoleCommandShortcutExtern(read);
+    SetConsoleCommandShortcutExtern(append);
+    SetConsoleCommandShortcutExtern(write);
+
+    SetConsoleCommandShortcutExtern(calculate);
+
+    void source(const std::string& filename)
+    {
+        static std::set<std::string> executingFiles;
+
+        std::set<std::string>::const_iterator it = executingFiles.find(filename);
+        if (it != executingFiles.end())
+        {
+            COUT(1) << "Error: Recurring source command in \"" << filename << "\". Stopped execution." << std::endl;
+            return;
+        }
+
+        // Open the file
+        std::ifstream file;
+        file.open(filename.c_str(), std::fstream::in);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't open file \"" << filename << "\"." << std::endl;
+            return;
+        }
+
+        executingFiles.insert(filename);
+
+        // Iterate through the file and put the lines into the CommandExecutor
+        char line[1024];
+        while (file.good() && !file.eof())
+        {
+            file.getline(line, 1024);
+            CommandExecutor::execute(line);
+        }
+
+        executingFiles.erase(filename);
+        file.close();
+    }
+
+    std::string echo(const std::string& text)
+    {
+        std::cout << text << std::endl;
+        return text;
+    }
+
+    void puts(bool newline, const std::string& text)
+    {
+        if (newline)
+            COUT(0) << text << std::endl;
+        else
+            COUT(0) << text;
+    }
+
+    void write(const std::string& filename, const std::string& text)
+    {
+        std::ofstream file;
+        file.open(filename.c_str(), std::fstream::out);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't write to file \"" << filename << "\"." << std::endl;
+            return;
+        }
+
+        file << text << std::endl;
+        file.close();
+    }
+
+    void append(const std::string& filename, const std::string& text)
+    {
+        std::ofstream file;
+        file.open(filename.c_str(), std::fstream::app);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't append to file \"" << filename << "\"." << std::endl;
+            return;
+        }
+
+        file << text << std::endl;
+        file.close();
+    }
+
+    std::string read(const std::string& filename)
+    {
+        std::ifstream file;
+        file.open(filename.c_str(), std::fstream::in);
+
+        if (!file.is_open())
+        {
+            COUT(1) << "Error: Couldn't read from file \"" << filename << "\"." << std::endl;
+            return "";
+        }
+
+        std::string output = "";
+        char line[1024];
+        while (file.good() && !file.eof())
+        {
+            file.getline(line, 1024);
+            output += line;
+            output += "\n";
+        }
+
+        file.close();
+
+        return output;
+    }
+
+    float calculate(const std::string& calculation)
+    {
+        ExprParser expr(calculation);
+        if (expr.getSuccess())
+        {
+            if (expr.getResult() == 42.0)
+            {
+                COUT(3) << "Greetings from the restaurant at the end of the universe." << std::endl;
+            }
+            if (expr.getRemains() != "")
+            {
+                COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << "'" << std::endl;
+            }
+            return expr.getResult();
+        }
+        else
+        {
+            COUT(1) << "Error: Cannot calculate expression: Parse error." << std::endl;
+            return 0;
+        }
+    }
+}
Index: code/branches/console/src/core/ConsoleCommandCompilation.h
===================================================================
--- code/branches/console/src/core/ConsoleCommandCompilation.h	(revision 1341)
+++ code/branches/console/src/core/ConsoleCommandCompilation.h	(revision 1341)
@@ -0,0 +1,49 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#ifndef _ConsoleCommandCompilation_H__
+#define _ConsoleCommandCompilation_H__
+
+#include "CorePrereqs.h"
+
+#include <string>
+
+namespace orxonox
+{
+    _CoreExport void source(const std::string& filename);
+    _CoreExport std::string echo(const std::string& text);
+    _CoreExport void puts(bool newline, const std::string& test);
+
+    _CoreExport void write(const std::string& filename, const std::string& text);
+    _CoreExport void append(const std::string& filename, const std::string& text);
+    _CoreExport std::string read(const std::string& filename);
+
+    _CoreExport float calculate(const std::string& calculation);
+}
+
+#endif /* _ConsoleCommandCompilation_H__ */
Index: code/branches/console/src/core/CorePrereqs.h
===================================================================
--- code/branches/console/src/core/CorePrereqs.h	(revision 1340)
+++ code/branches/console/src/core/CorePrereqs.h	(revision 1341)
@@ -66,6 +66,4 @@
 namespace orxonox
 {
-#ifndef _XMLPort_Mode__
-#define _XMLPort_Mode__
   namespace XMLPort
   {
@@ -76,5 +74,4 @@
     };
   }
-#endif
 
   typedef std::string LanguageEntryLabel;
@@ -101,4 +98,5 @@
   class ConfigFileSection;
   class ConfigValueContainer;
+  class ConsoleCommand;
   class CoreSettings;
   class Error;
Index: code/branches/console/src/core/Executor.cc
===================================================================
--- code/branches/console/src/core/Executor.cc	(revision 1340)
+++ code/branches/console/src/core/Executor.cc	(revision 1341)
@@ -34,9 +34,8 @@
 namespace orxonox
 {
-    Executor::Executor(Functor* functor, const std::string& name, AccessLevel::Level level)
+    Executor::Executor(Functor* functor, const std::string& name)
     {
         this->functor_ = functor;
         this->name_ = name;
-        this->accessLevel_ = level;
 
         this->bAddedDescription_ = false;
Index: code/branches/console/src/core/Executor.h
===================================================================
--- code/branches/console/src/core/Executor.h	(revision 1340)
+++ code/branches/console/src/core/Executor.h	(revision 1341)
@@ -135,17 +135,4 @@
     return true
 
-namespace AccessLevel
-{
-    enum Level
-    {
-        None,
-        User,
-        Admin,
-        Offline,
-        Debug,
-        Disabled
-    };
-}
-
 namespace orxonox
 {
@@ -153,5 +140,5 @@
     {
         public:
-            Executor(Functor* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None);
+            Executor(Functor* functor, const std::string& name = "");
             virtual ~Executor();
 
@@ -182,4 +169,6 @@
             const std::string& getDescriptionReturnvalue(int param) const;
 
+            inline Functor* getFunctor() const
+                { return this->functor_; }
             inline unsigned int getParamCount() const
                 { return this->functor_->getParamCount(); }
@@ -200,9 +189,4 @@
                 { return this->name_; }
 
-            inline void setAccessLevel(AccessLevel::Level level)
-                { this->accessLevel_ = level; }
-            inline AccessLevel::Level getAccessLevel() const
-                { return this->accessLevel_; }
-
             Executor& setDefaultValues(const MultiTypeMath& param1);
             Executor& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2);
@@ -243,6 +227,4 @@
             bool bAddedDescriptionReturnvalue_;
             bool bAddedDescriptionParam_[MAX_FUNCTOR_ARGUMENTS];
-
-            AccessLevel::Level accessLevel_;
     };
 
@@ -250,5 +232,5 @@
     {
         public:
-            ExecutorStatic(FunctorStatic* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None) : Executor(functor, name, level) {}
+            ExecutorStatic(FunctorStatic* functor, const std::string& name = "") : Executor(functor, name) {}
             virtual ~ExecutorStatic() {}
     };
@@ -258,5 +240,5 @@
     {
         public:
-            ExecutorMember(FunctorMember<T>* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None) : Executor(functor, name, level) {}
+            ExecutorMember(FunctorMember<T>* functor, const std::string& name = "") : Executor(functor, name) {}
             virtual ~ExecutorMember() {}
 
@@ -304,18 +286,18 @@
     };
 
-    inline Executor* createExecutor(Functor* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
-    {
-        return new Executor(functor, name, level);
+    inline Executor* createExecutor(Functor* functor, const std::string& name = "")
+    {
+        return new Executor(functor, name);
     }
 
     template <class T>
-    inline ExecutorMember<T>* createExecutor(FunctorMember<T>* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
-    {
-        return new ExecutorMember<T>(functor, name, level);
+    inline ExecutorMember<T>* createExecutor(FunctorMember<T>* functor, const std::string& name = "")
+    {
+        return new ExecutorMember<T>(functor, name);
     }
 
-    inline ExecutorStatic* createExecutor(FunctorStatic* functor, const std::string& name = "", AccessLevel::Level level = AccessLevel::None)
-    {
-        return new ExecutorStatic(functor, name, level);
+    inline ExecutorStatic* createExecutor(FunctorStatic* functor, const std::string& name = "")
+    {
+        return new ExecutorStatic(functor, name);
     }
 }
Index: code/branches/console/src/core/IRC.cc
===================================================================
--- code/branches/console/src/core/IRC.cc	(revision 1340)
+++ code/branches/console/src/core/IRC.cc	(revision 1341)
@@ -39,7 +39,7 @@
 namespace orxonox
 {
-    ConsoleCommand(IRC, say,  AccessLevel::User, true);
-    ConsoleCommand(IRC, msg,  AccessLevel::User, false);
-    ConsoleCommand(IRC, nick, AccessLevel::User, false);
+    SetConsoleCommand(IRC, say,  true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, msg,  false).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(IRC, nick, false).setAccessLevel(AccessLevel::User);
 
     IRC* instance_irc = &IRC::getInstance();
Index: code/branches/console/src/core/Identifier.cc
===================================================================
--- code/branches/console/src/core/Identifier.cc	(revision 1340)
+++ code/branches/console/src/core/Identifier.cc	(revision 1341)
@@ -37,5 +37,5 @@
 
 #include "Factory.h"
-#include "Executor.h"
+#include "ConsoleCommand.h"
 #include "CommandExecutor.h"
 
@@ -270,14 +270,14 @@
         @return The executor of the command
     */
-    ExecutorStatic& Identifier::addConsoleCommand(ExecutorStatic* executor, bool bCreateShortcut)
+    ConsoleCommand& Identifier::addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut)
     {
         this->bHasConsoleCommands_ = true;
-        this->consoleCommands_[executor->getName()] = executor;
-        this->consoleCommands_LC_[getLowercase(executor->getName())] = executor;
+        this->consoleCommands_[command->getName()] = command;
+        this->consoleCommands_LC_[getLowercase(command->getName())] = command;
 
         if (bCreateShortcut)
-            CommandExecutor::addConsoleCommandShortcut(executor);
-
-        return (*executor);
+            CommandExecutor::addConsoleCommandShortcut(command);
+
+        return (*command);
     }
 
@@ -287,7 +287,7 @@
         @return The executor of the requested console command
     */
-    ExecutorStatic* Identifier::getConsoleCommand(const std::string& name) const
-    {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = this->consoleCommands_.find(name);
+    ConsoleCommand* Identifier::getConsoleCommand(const std::string& name) const
+    {
+        std::map<std::string, ConsoleCommand*>::const_iterator it = this->consoleCommands_.find(name);
         if (it != this->consoleCommands_.end())
             return (*it).second;
@@ -301,7 +301,7 @@
         @return The executor of the requested console command
     */
-    ExecutorStatic* Identifier::getLowercaseConsoleCommand(const std::string& name) const
-    {
-        std::map<std::string, ExecutorStatic*>::const_iterator it = this->consoleCommands_LC_.find(name);
+    ConsoleCommand* Identifier::getLowercaseConsoleCommand(const std::string& name) const
+    {
+        std::map<std::string, ConsoleCommand*>::const_iterator it = this->consoleCommands_LC_.find(name);
         if (it != this->consoleCommands_LC_.end())
             return (*it).second;
Index: code/branches/console/src/core/Identifier.h
===================================================================
--- code/branches/console/src/core/Identifier.h	(revision 1340)
+++ code/branches/console/src/core/Identifier.h	(revision 1341)
@@ -176,16 +176,16 @@
 
             /** @brief Returns the map that stores all console commands. @return The const_iterator */
-            inline const std::map<std::string, ExecutorStatic*>& getConsoleCommandMap() const { return this->consoleCommands_; }
+            inline const std::map<std::string, ConsoleCommand*>& getConsoleCommandMap() const { return this->consoleCommands_; }
             /** @brief Returns a const_iterator to the beginning of the map that stores all console commands. @return The const_iterator */
-            inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
+            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapBegin() const { return this->consoleCommands_.begin(); }
             /** @brief Returns a const_iterator to the end of the map that stores all console commands. @return The const_iterator */
-            inline std::map<std::string, ExecutorStatic*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
+            inline std::map<std::string, ConsoleCommand*>::const_iterator getConsoleCommandMapEnd() const { return this->consoleCommands_.end(); }
 
             /** @brief Returns the map that stores all console commands with their names in lowercase. @return The const_iterator */
-            inline const std::map<std::string, ExecutorStatic*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
+            inline const std::map<std::string, ConsoleCommand*>& getLowercaseConsoleCommandMap() const { return this->consoleCommands_LC_; }
             /** @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 */
-            inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.begin(); }
+            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapBegin() const { return this->consoleCommands_LC_.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 */
-            inline std::map<std::string, ExecutorStatic*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
+            inline std::map<std::string, ConsoleCommand*>::const_iterator getLowercaseConsoleCommandMapEnd() const { return this->consoleCommands_LC_.end(); }
 
 
@@ -214,7 +214,7 @@
             virtual XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname) = 0;
 
-            ExecutorStatic& addConsoleCommand(ExecutorStatic* executor, bool bCreateShortcut);
-            ExecutorStatic* getConsoleCommand(const std::string& name) const;
-            ExecutorStatic* getLowercaseConsoleCommand(const std::string& name) const;
+            ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
+            ConsoleCommand* getConsoleCommand(const std::string& name) const;
+            ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
 
         protected:
@@ -271,6 +271,6 @@
 
             bool bHasConsoleCommands_;                                     //!< True if this class has at least one assigned console command
-            std::map<std::string, ExecutorStatic*> consoleCommands_;       //!< All console commands of this class
-            std::map<std::string, ExecutorStatic*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
+            std::map<std::string, ConsoleCommand*> consoleCommands_;       //!< All console commands of this class
+            std::map<std::string, ConsoleCommand*> consoleCommands_LC_;    //!< All console commands of this class with their names in lowercase
     };
 
Index: code/branches/console/src/core/InputManager.cc
===================================================================
--- code/branches/console/src/core/InputManager.cc	(revision 1340)
+++ code/branches/console/src/core/InputManager.cc	(revision 1341)
@@ -43,5 +43,5 @@
 namespace orxonox
 {
-  ConsoleCommand(InputManager, setInputMode, AccessLevel::Admin, true).setDefaultValue(0, IM_INGAME);
+  SetConsoleCommand(InputManager, setInputMode, true).setDefaultValue(0, IM_INGAME);
 
   /**
Index: code/branches/console/src/core/OutputHandler.cc
===================================================================
--- code/branches/console/src/core/OutputHandler.cc	(revision 1340)
+++ code/branches/console/src/core/OutputHandler.cc	(revision 1341)
@@ -38,9 +38,9 @@
 namespace orxonox
 {
-    ConsoleCommandShortcutGeneric(log,     createExecutor(createFunctor(&OutputHandler::log),     "log",     AccessLevel::None));
-    ConsoleCommandShortcutGeneric(error,   createExecutor(createFunctor(&OutputHandler::error),   "error",   AccessLevel::None));
-    ConsoleCommandShortcutGeneric(warning, createExecutor(createFunctor(&OutputHandler::warning), "warning", AccessLevel::None));
-    ConsoleCommandShortcutGeneric(info,    createExecutor(createFunctor(&OutputHandler::info),    "info",    AccessLevel::None));
-    ConsoleCommandShortcutGeneric(debug,   createExecutor(createFunctor(&OutputHandler::debug),   "debug",   AccessLevel::None));
+    SetConsoleCommandShortcutGeneric(log,     createExecutor(createFunctor(&OutputHandler::log),     "log"    ));
+    SetConsoleCommandShortcutGeneric(error,   createExecutor(createFunctor(&OutputHandler::error),   "error"  ));
+    SetConsoleCommandShortcutGeneric(warning, createExecutor(createFunctor(&OutputHandler::warning), "warning"));
+    SetConsoleCommandShortcutGeneric(info,    createExecutor(createFunctor(&OutputHandler::info),    "info"   ));
+    SetConsoleCommandShortcutGeneric(debug,   createExecutor(createFunctor(&OutputHandler::debug),   "debug"  ));
 
     /**
Index: code/branches/console/src/core/TclBind.cc
===================================================================
--- code/branches/console/src/core/TclBind.cc	(revision 1340)
+++ code/branches/console/src/core/TclBind.cc	(revision 1341)
@@ -39,6 +39,6 @@
 namespace orxonox
 {
-    ConsoleCommandShortcutGeneric(tcl, createExecutor(createFunctor(&TclBind::tcl), "tcl", AccessLevel::None));
-    ConsoleCommandShortcutGeneric(bgerror, createExecutor(createFunctor(&TclBind::bgerror), "bgerror", AccessLevel::None));
+    SetConsoleCommandShortcutGeneric(tcl, createExecutor(createFunctor(&TclBind::tcl), "tcl"));
+    SetConsoleCommandShortcutGeneric(bgerror, createExecutor(createFunctor(&TclBind::bgerror), "bgerror"));
 
     TclBind::TclBind()
Index: code/branches/console/src/core/TclThreadManager.cc
===================================================================
--- code/branches/console/src/core/TclThreadManager.cc	(revision 1340)
+++ code/branches/console/src/core/TclThreadManager.cc	(revision 1341)
@@ -48,13 +48,13 @@
 namespace orxonox
 {
-    ConsoleCommandShortcutGeneric(tclexecute, createExecutor(createFunctor(&TclThreadManager::execute), "tclexecute", AccessLevel::None));
-    ConsoleCommandShortcutGeneric(tclquery,   createExecutor(createFunctor(&TclThreadManager::query),   "tclquery",   AccessLevel::None));
-    ConsoleCommand(TclThreadManager, create,    AccessLevel::None, false);
-    ConsoleCommand(TclThreadManager, destroy,   AccessLevel::None, false);
-    ConsoleCommand(TclThreadManager, execute,   AccessLevel::None, false);
-    ConsoleCommand(TclThreadManager, query,     AccessLevel::None, false);
-    ConsoleCommand(TclThreadManager, status,    AccessLevel::None, false);
-    ConsoleCommand(TclThreadManager, dump,      AccessLevel::None, false);
-    ConsoleCommand(TclThreadManager, flush,     AccessLevel::None, false);
+    SetConsoleCommandShortcutGeneric(tclexecute, createExecutor(createFunctor(&TclThreadManager::execute), "tclexecute"));
+    SetConsoleCommandShortcutGeneric(tclquery,   createExecutor(createFunctor(&TclThreadManager::query),   "tclquery"  ));
+    SetConsoleCommand(TclThreadManager, create,  false);
+    SetConsoleCommand(TclThreadManager, destroy, false);
+    SetConsoleCommand(TclThreadManager, execute, false);
+    SetConsoleCommand(TclThreadManager, query,   false);
+    SetConsoleCommand(TclThreadManager, status,  false);
+    SetConsoleCommand(TclThreadManager, dump,    false);
+    SetConsoleCommand(TclThreadManager, flush,   false);
 
     TclThreadManager* instance_tclthreadmanager = &TclThreadManager::getInstance();
Index: code/branches/console/src/core/XMLPort.h
===================================================================
--- code/branches/console/src/core/XMLPort.h	(revision 1340)
+++ code/branches/console/src/core/XMLPort.h	(revision 1341)
@@ -78,17 +78,4 @@
 namespace orxonox
 {
-
-#ifndef _XMLPort_Mode__
-#define _XMLPort_Mode__
-    namespace XMLPort
-    {
-        enum Mode
-        {
-            LoadObject,
-            SaveObject
-        };
-    }
-#endif
-
     // ###############################
     // ###  XMLPortParamContainer  ###
Index: code/branches/console/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/console/src/orxonox/Orxonox.cc	(revision 1340)
+++ code/branches/console/src/orxonox/Orxonox.cc	(revision 1341)
@@ -54,5 +54,4 @@
 //#include "util/Sleep.h"
 #include "util/ArgReader.h"
-#include "util/ExprParser.h"
 
 // core
@@ -60,8 +59,6 @@
 #include "core/ConsoleCommand.h"
 #include "core/Debug.h"
-#include "core/Factory.h"
 #include "core/Loader.h"
 #include "core/Tickable.h"
-#include "core/InputBuffer.h"
 #include "core/InputManager.h"
 
@@ -74,5 +71,4 @@
 
 // objects and tools
-#include "tools/Timer.h"
 #include "hud/HUD.h"
 //#include "console/InGameConsole.h"
@@ -85,33 +81,7 @@
 namespace orxonox
 {
-  ConsoleCommand(Orxonox, exit, AccessLevel::None, true);
-  ConsoleCommand(Orxonox, slomo, AccessLevel::Offline, true).setDefaultValue(0, 1.0);
-  ConsoleCommand(Orxonox, setTimeFactor, AccessLevel::Offline, false).setDefaultValue(0, 1.0);
-
-  class Calculator
-  {
-  public:
-    static float calculate(const std::string& calculation)
-    {
-      ExprParser expr(calculation);
-      if (expr.getSuccess())
-      {
-        if (expr.getResult() == 42.0)
-          std::cout << "Greetings from the restaurant at the end of the universe." << std::endl;
-        // FIXME: insert modifier to display in full precision
-        std::cout << "Result is: " << expr.getResult() << std::endl;
-        if (expr.getRemains() != "")
-          std::cout << "Warning: Expression could not be parsed to the end! Remains: '"
-              << expr.getRemains() << "'" << std::endl;
-        return expr.getResult();
-      }
-      else
-      {
-        std::cout << "Cannot calculate expression: Parse error" << std::endl;
-        return 0;
-      }
-    }
-  };
-  ConsoleCommandShortcut(Calculator, calculate, AccessLevel::None);
+  SetConsoleCommand(Orxonox, exit, true);
+  SetConsoleCommand(Orxonox, slomo, true).setDefaultValue(0, 1.0).setAccessLevel(AccessLevel::Offline);
+  SetConsoleCommand(Orxonox, setTimeFactor, false).setDefaultValue(0, 1.0).setAccessLevel(AccessLevel::Offline);
 
   /**
Index: code/branches/console/src/orxonox/console/InGameConsole.cc
===================================================================
--- code/branches/console/src/orxonox/console/InGameConsole.cc	(revision 1340)
+++ code/branches/console/src/orxonox/console/InGameConsole.cc	(revision 1341)
@@ -49,6 +49,6 @@
 namespace orxonox
 {
-    ConsoleCommand(InGameConsole, openConsole, AccessLevel::None, true);
-    ConsoleCommand(InGameConsole, closeConsole, AccessLevel::None, true);
+    SetConsoleCommand(InGameConsole, openConsole, true);
+    SetConsoleCommand(InGameConsole, closeConsole, true);
 
     using namespace Ogre;
Index: code/branches/console/src/orxonox/objects/Ambient.cc
===================================================================
--- code/branches/console/src/orxonox/objects/Ambient.cc	(revision 1340)
+++ code/branches/console/src/orxonox/objects/Ambient.cc	(revision 1341)
@@ -47,5 +47,5 @@
 namespace orxonox
 {
-    ConsoleCommand(Ambient, setAmbientLightTest, AccessLevel::Offline, false).setDefaultValues(ColourValue(1, 1, 1, 1));
+    SetConsoleCommand(Ambient, setAmbientLightTest, false).setDefaultValues(ColourValue(1, 1, 1, 1)).setAccessLevel(AccessLevel::Offline);
 
     CreateFactory(Ambient);
Index: code/branches/console/src/orxonox/objects/SpaceShip.cc
===================================================================
--- code/branches/console/src/orxonox/objects/SpaceShip.cc	(revision 1340)
+++ code/branches/console/src/orxonox/objects/SpaceShip.cc	(revision 1341)
@@ -53,8 +53,8 @@
 namespace orxonox
 {
-    ConsoleCommand(SpaceShip, setMaxSpeedTest, AccessLevel::Debug, false);
-    ConsoleCommandGeneric(test1, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed", AccessLevel::Debug), false);
-    ConsoleCommandGeneric(test2, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber", AccessLevel::Debug), false);
-    ConsoleCommandGeneric(test3, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl", AccessLevel::Debug), false);
+    SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test1, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test2, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test3, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl"), false).setAccessLevel(AccessLevel::Debug);
 
     CreateFactory(SpaceShip);
Index: code/branches/console/src/orxonox/tools/Timer.cc
===================================================================
--- code/branches/console/src/orxonox/tools/Timer.cc	(revision 1340)
+++ code/branches/console/src/orxonox/tools/Timer.cc	(revision 1341)
@@ -27,4 +27,6 @@
  */
 
+#include <set>
+
 #include "OrxonoxStableHeaders.h"
 #include "Timer.h"
@@ -37,5 +39,8 @@
 namespace orxonox
 {
-    ConsoleCommandShortcutExtern(delay, AccessLevel::None);
+    SetConsoleCommandShortcutExtern(delay);
+    SetConsoleCommandShortcutExtern(killdelays);
+
+    static std::set<StaticTimer*> delaytimerset;
 
     /**
@@ -47,4 +52,6 @@
     {
         StaticTimer *delaytimer = new StaticTimer();
+        delaytimerset.insert(delaytimer);
+
         ExecutorStatic* delayexecutor = createExecutor(createFunctor(&executeDelayedCommand));
         delayexecutor->setDefaultValues(delaytimer, command);
@@ -61,4 +68,16 @@
         CommandExecutor::execute(command);
         delete timer;
+        delaytimerset.erase(timer);
+    }
+
+    /**
+        @brief Kills all delayed commands.
+    */
+    void killdelays()
+    {
+        for (std::set<StaticTimer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it)
+            delete (*it);
+
+        delaytimerset.clear();
     }
 
Index: code/branches/console/src/orxonox/tools/Timer.h
===================================================================
--- code/branches/console/src/orxonox/tools/Timer.h	(revision 1340)
+++ code/branches/console/src/orxonox/tools/Timer.h	(revision 1341)
@@ -69,4 +69,5 @@
     class StaticTimer;
     void delay(float delay, const std::string& command);
+    void killdelays();
     void executeDelayedCommand(StaticTimer* timer, const std::string& command);
 
