Index: code/trunk/src/orxonox/tools/Timer.cc
===================================================================
--- code/trunk/src/orxonox/tools/Timer.cc	(revision 1039)
+++ code/trunk/src/orxonox/tools/Timer.cc	(revision 1052)
@@ -27,10 +27,38 @@
 
 #include "OrxonoxStableHeaders.h"
+#include "core/Executor.h"
+#include "core/CoreIncludes.h"
+#include "core/ConsoleCommand.h"
+#include "core/CommandExecutor.h"
 #include "Timer.h"
-
-#include "core/CoreIncludes.h"
 
 namespace orxonox
 {
+    ConsoleCommandShortcutExtern(delay, AccessLevel::None);
+
+    /**
+        @brief Calls a console command after 'delay' seconds.
+        @param delay The delay in seconds
+        @param command The console command
+    */
+    void delay(float delay, const std::string& command)
+    {
+        StaticTimer *delaytimer = new StaticTimer();
+        ExecutorStatic* delayexecutor = createExecutor(createFunctor(&executeDelayedCommand));
+        delayexecutor->setDefaultValues(delaytimer, command);
+        delaytimer->setTimer(delay, false, delayexecutor);
+    }
+
+    /**
+        @brief Executes the command.
+        @param timer The timer to destroy after the command-execution
+        @param command The command to execute
+    */
+    void executeDelayedCommand(StaticTimer* timer, const std::string& command)
+    {
+        CommandExecutor::execute(command);
+        delete timer;
+    }
+
     /**
         @brief Constructor: Sets the default-values.
@@ -40,4 +68,5 @@
         RegisterRootObject(TimerBase);
 
+        this->executor_ = 0;
         this->interval_ = 0;
         this->bLoop_ = false;
@@ -45,4 +74,20 @@
 
         this->time_ = 0;
+    }
+
+    /**
+        @brief Deletes the executor.
+    */
+    TimerBase::~TimerBase()
+    {
+        delete this->executor_;
+    }
+
+    /**
+        @brief Executes the executor.
+    */
+    void TimerBase::run() const
+    {
+        (*this->executor_)();
     }
 
Index: code/trunk/src/orxonox/tools/Timer.h
===================================================================
--- code/trunk/src/orxonox/tools/Timer.h	(revision 1039)
+++ code/trunk/src/orxonox/tools/Timer.h	(revision 1052)
@@ -43,7 +43,9 @@
 
     source.cc:
+        include "core/Executor.h"
+
         ClassName::ClassName()
         {
-            myTimer.setTimer(interval_in_seconds, bLoop, this, &ClassName::functionName);
+            myTimer.setTimer(interval_in_seconds, bLoop, this, createExecutor(createFunctor(&ClassName::functionName)));
         }
 
@@ -59,36 +61,61 @@
 
 #include "OrxonoxPrereqs.h"
-
+#include "core/CorePrereqs.h"
 #include "core/Tickable.h"
 
 namespace orxonox
 {
+    class StaticTimer;
+    void delay(float delay, const std::string& command);
+    void executeDelayedCommand(StaticTimer* timer, const std::string& command);
+
     //! TimerBase is the parent of the Timer class.
     class _OrxonoxExport TimerBase : public Tickable
     {
         public:
-            TimerBase();
+            ~TimerBase();
 
-            virtual void run() const = 0;
+            void run() const;
 
             /** @brief Starts the Timer: Function-call after 'interval' seconds. */
-            inline void startTimer() { this->bActive_ = true; this->time_ = this->interval_; }
+            inline void startTimer()
+                { this->bActive_ = true; this->time_ = this->interval_; }
             /** @brief Stops the Timer. */
-            inline void stopTimer() { this->bActive_ = false; this->time_ = this->interval_; }
+            inline void stopTimer()
+                { this->bActive_ = false; this->time_ = this->interval_; }
             /** @brief Pauses the Timer - it will continue with the actual state if you unpause it. */
-            inline void pauseTimer() { this->bActive_ = false; }
+            inline void pauseTimer()
+                { this->bActive_ = false; }
             /** @brief Unpauses the Timer - continues with the given state. */
-            inline void unpauseTimer() { this->bActive_ = true; }
+            inline void unpauseTimer()
+                { this->bActive_ = true; }
             /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */
-            inline bool isActive() const { return this->bActive_; }
+            inline bool isActive() const
+                { return this->bActive_; }
+            /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
+            inline void addTime(float time)
+                { this->time_ += time; }
+            /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
+            inline void removeTime(float time)
+                { this->time_ -= time; }
+            /** @brief Sets the interval of the Timer. @param interval The interval */
+            inline void setInterval(float interval)
+                { this->interval_ = interval; }
+            /** @brief Sets bLoop to a given value. @param bLoop True = loop */
+            inline void setLoop(bool bLoop)
+                { this->bLoop_ = bLoop; }
 
             void tick(float dt);
 
         protected:
-            float interval_;    //!< The time-interval in seconds
-            bool bLoop_;        //!< If true, the function gets called every 'interval' seconds
-            bool bActive_;      //!< If true, the Timer ticks and calls the function if the time's up
+            TimerBase();
 
-            float time_;        //!< Internal variable, counting the time till the next function-call
+            Executor* executor_; //!< The executor of the function that should be called when the time expires
+
+            float interval_;     //!< The time-interval in seconds
+            bool bLoop_;         //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;       //!< If true, the Timer ticks and calls the function if the time's up
+
+            float time_;         //!< Internal variable, counting the time till the next function-call
     };
 
@@ -98,10 +125,5 @@
     {
         public:
-            /** @brief Constructor: Sets the default-values. */
-            Timer()
-            {
-                this->timerFunction_ = 0;
-                this->object_ = 0;
-            }
+            Timer() {}
 
             /**
@@ -110,9 +132,9 @@
                 @param bLoop If true, the function gets called every 'interval' seconds
                 @param object The object owning the timer and the function
-                @param timerFunction A function pointer to the function to call
+                @param exeuctor A executor of the function to call
             */
-            Timer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+            Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor)
             {
-                this->setTimer(interval, bLoop, timerFunction, object);
+                this->setTimer(interval, bLoop, object, exeuctor);
             }
 
@@ -122,26 +144,51 @@
                 @param bLoop If true, the function gets called every 'interval' seconds
                 @param object The object owning the timer and the function
-                @param timerFunction A function pointer to the function to call
+                @param exeuctor A executor of the function to call
             */
-            void setTimer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+            void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor)
             {
                 this->interval_ = interval;
                 this->bLoop_ = bLoop;
-                this->timerFunction_ = timerFunction;
-                this->object_ = object;
+                executor->setObject(object);
+                this->executor_ = (Executor*)executor;
                 this->bActive_ = true;
 
                 this->time_ = interval;
             }
+    };
 
-            /** @brief Calls the given function of the given object. */
-            void run() const
+    //! The StaticTimer is a callback-object, calling a static function after a given time-interval.
+    class StaticTimer : public TimerBase
+    {
+        public:
+            StaticTimer() {}
+
+            /**
+                @brief Constructor: Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param exeuctor A executor of the function to call
+            */
+            StaticTimer(float interval, bool bLoop, ExecutorStatic* executor)
             {
-                ((*this->object_).*timerFunction_)();
+                this->setTimer(interval, bLoop, executor);
             }
 
-        private:
-            void (T::*timerFunction_)();
-            T* object_;
+            /**
+                @brief Initializes the Timer with given values.
+                @param interval The timer-interval in seconds
+                @param bLoop If true, the function gets called every 'interval' seconds
+                @param object The object owning the timer and the function
+                @param executor A executor of the function to call
+            */
+            void setTimer(float interval, bool bLoop, ExecutorStatic* executor)
+            {
+                this->interval_ = interval;
+                this->bLoop_ = bLoop;
+                this->executor_ = (Executor*)executor;
+                this->bActive_ = true;
+
+                this->time_ = interval;
+            }
     };
 
