Index: code/branches/core2/src/orxonox/Orxonox.h
===================================================================
--- code/branches/core2/src/orxonox/Orxonox.h	(revision 994)
+++ code/branches/core2/src/orxonox/Orxonox.h	(revision 995)
Index: code/branches/core2/src/orxonox/objects/Explosion.cc
===================================================================
--- code/branches/core2/src/orxonox/objects/Explosion.cc	(revision 994)
+++ code/branches/core2/src/orxonox/objects/Explosion.cc	(revision 995)
@@ -32,5 +32,7 @@
 #include <OgreSceneNode.h>
 
-#include "../core/CoreIncludes.h"
+#include "core/CoreIncludes.h"
+#include "core/Executor.h"
+
 #include "util/Math.h"
 #include "../Orxonox.h"
@@ -52,5 +54,5 @@
         if (owner)
         {
-            this->destroyTimer_.setTimer(this->lifetime_, false, this, &Explosion::destroyObject);
+            this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Explosion::destroyObject)));
 
             Vector3 position = owner->getNode()->getWorldPosition();
Index: code/branches/core2/src/orxonox/objects/Projectile.cc
===================================================================
--- code/branches/core2/src/orxonox/objects/Projectile.cc	(revision 994)
+++ code/branches/core2/src/orxonox/objects/Projectile.cc	(revision 995)
@@ -28,5 +28,7 @@
 #include "OrxonoxStableHeaders.h"
 
-#include "../core/CoreIncludes.h"
+#include "core/CoreIncludes.h"
+#include "core/Executor.h"
+
 #include "SpaceShip.h"
 #include "Explosion.h"
@@ -60,5 +62,5 @@
         }
 
-        this->destroyTimer_.setTimer(this->lifetime_, false, this, &Projectile::destroyObject);
+        this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
     }
 
Index: code/branches/core2/src/orxonox/objects/test2.cc
===================================================================
--- code/branches/core2/src/orxonox/objects/test2.cc	(revision 994)
+++ code/branches/core2/src/orxonox/objects/test2.cc	(revision 995)
@@ -30,4 +30,5 @@
 #include "test3.h"
 #include "core/CoreIncludes.h"
+#include "core/Executor.h"
 
 namespace orxonox
@@ -43,7 +44,7 @@
         this->usefullClass3_ = Class(Test3);
 
-        timer1.setTimer(1, true, this, &Test2::timerFunction1);
-        timer2.setTimer(5, true, this, &Test2::timerFunction2);
-        timer3.setTimer(10, false, this, &Test2::timerFunction3);
+        timer1.setTimer(1, true, this, createExecutor(createFunctor(&Test2::timerFunction1)));
+        timer2.setTimer(5, true, this, createExecutor(createFunctor(&Test2::timerFunction2)));
+        timer3.setTimer(10, false, this, createExecutor(createFunctor(&Test2::timerFunction3)));
     }
 
Index: code/branches/core2/src/orxonox/tools/Timer.cc
===================================================================
--- code/branches/core2/src/orxonox/tools/Timer.cc	(revision 994)
+++ code/branches/core2/src/orxonox/tools/Timer.cc	(revision 995)
@@ -1,7 +1,53 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "core/Executor.h"
 #include "core/CoreIncludes.h"
+#include "core/ConsoleCommand.h"
+#include "core/CommandExecutor.h"
 #include "Timer.h"
 
 namespace orxonox
 {
+    ConsoleCommandShortcutExtern(delay, AccessLevel::None);
+
+    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);
+    }
+
+    void executeDelayedCommand(StaticTimer* timer, const std::string& command)
+    {
+        CommandExecutor::execute(command);
+        delete timer;
+    }
+
     /**
         @brief Constructor: Sets the default-values.
@@ -11,4 +57,5 @@
         RegisterRootObject(TimerBase);
 
+        this->executor_ = 0;
         this->interval_ = 0;
         this->bLoop_ = false;
@@ -17,3 +64,13 @@
         this->time_ = 0;
     }
+
+    TimerBase::~TimerBase()
+    {
+        delete this->executor_;
+    }
+
+    void TimerBase::run() const
+    {
+        (*this->executor_)();
+    }
 }
Index: code/branches/core2/src/orxonox/tools/Timer.h
===================================================================
--- code/branches/core2/src/orxonox/tools/Timer.h	(revision 994)
+++ code/branches/core2/src/orxonox/tools/Timer.h	(revision 995)
@@ -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,8 +61,13 @@
 
 #include <OgreFrameListener.h>
-#include "../OrxonoxPrereqs.h"
+#include "OrxonoxPrereqs.h"
+#include "core/CorePrereqs.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 OrxonoxClass
@@ -69,29 +76,46 @@
 
         public:
+            ~TimerBase();
+
+            void run() const;
+
+            /** @brief Starts the Timer: Function-call after 'interval' seconds. */
+            inline void startTimer()
+                { this->bActive_ = true; this->time_ = this->interval_; }
+            /** @brief Stops the Timer. */
+            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; }
+            /** @brief Unpauses the Timer - continues with the given state. */
+            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_; }
+            /** @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; }
+
+        protected:
             TimerBase();
 
-            virtual void run() const = 0;
-
-            /** @brief Starts the Timer: Function-call after 'interval' seconds. */
-            inline void startTimer() { this->bActive_ = true; this->time_ = this->interval_; }
-            /** @brief Stops the Timer. */
-            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; }
-            /** @brief Unpauses the Timer - continues with the given state. */
-            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_; }
-            /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
-            inline void addTime(float time) { this->time_ += time; }
-            /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
-            inline void removeTime(float time) { this->time_ -= time; }
-
-        protected:
-            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
+            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
     };
 
@@ -101,10 +125,5 @@
     {
         public:
-            /** @brief Constructor: Sets the default-values. */
-            Timer()
-            {
-                this->timerFunction_ = 0;
-                this->object_ = 0;
-            }
+            Timer() {}
 
             /**
@@ -113,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
-            */
-            Timer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
-            {
-                this->setTimer(interval, bLoop, timerFunction, object);
+                @param exeuctor A executor of the function to call
+            */
+            Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor)
+            {
+                this->setTimer(interval, bLoop, object, exeuctor);
             }
 
@@ -125,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
-            */
-            void setTimer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+                @param exeuctor A executor of the function to call
+            */
+            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
-            {
-                ((*this->object_).*timerFunction_)();
-            }
-
-        private:
-            void (T::*timerFunction_)();
-            T* object_;
+    };
+
+    //! 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->setTimer(interval, bLoop, executor);
+            }
+
+            /**
+                @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;
+            }
     };
 
