Changeset 995

Timestamp:

Apr 5, 2008, 6:46:43 PM (17 years ago)

Author:

landauf

Message:

added 'delay time command' console command that executes 'command' after 'time' seconds. it uses a automatically destroying timer for every execution, so you can start several delayed commands at the same time without overwriting older entries.

and this is great:

append disco.txt delay 0.0 Ambient setAmbientLightTest 1,0,0,1
append disco.txt delay 0.2 Ambient setAmbientLightTest 0,1,0,1
append disco.txt delay 0.4 Ambient setAmbientLightTest 0,0,1,1
append disco.txt delay 0.6 exec disco.txt

exec disco.txt

and you'll have disco in space… forever!

Location:

code/branches/core2/src/orxonox

Files:

• objects/Explosion.cc (modified) (2 diffs)
• objects/Projectile.cc (modified) (2 diffs)
• objects/test2.cc (modified) (2 diffs)
• tools/Timer.cc (modified) (3 diffs)
• tools/Timer.h (modified) (6 diffs)

code/branches/core2/src/orxonox/objects/Explosion.cc

@@ -32 +32 @@
 #include <OgreSceneNode.h>
 
-#include "../core/CoreIncludes.h"
+#include "core/CoreIncludes.h"
+#include "core/Executor.h"
+
 #include "util/Math.h"
 #include "../Orxonox.h"
@@ -52 +54 @@
         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();

code/branches/core2/src/orxonox/objects/Projectile.cc

@@ -28 +28 @@
 #include "OrxonoxStableHeaders.h"
 
-#include "../core/CoreIncludes.h"
+#include "core/CoreIncludes.h"
+#include "core/Executor.h"
+
 #include "SpaceShip.h"
 #include "Explosion.h"
@@ -60 +62 @@
         }
 
-        this->destroyTimer_.setTimer(this->lifetime_, false, this, &Projectile::destroyObject);
+        this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
     }
 

code/branches/core2/src/orxonox/objects/test2.cc

@@ -30 +30 @@
 #include "test3.h"
 #include "core/CoreIncludes.h"
+#include "core/Executor.h"
 
 namespace orxonox
@@ -43 +44 @@
         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)));
     }
 

code/branches/core2/src/orxonox/tools/Timer.cc

@@ +1 @@
+/*
+ *   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 +57 @@
         RegisterRootObject(TimerBase);
 
+        this->executor_ = 0;
         this->interval_ = 0;
         this->bLoop_ = false;
@@ -17 +64 @@
         this->time_ = 0;
     }
+
+    TimerBase::~TimerBase()
+    {
+        delete this->executor_;
+    }
+
+    void TimerBase::run() const
+    {
+        (*this->executor_)();
+    }
 }

code/branches/core2/src/orxonox/tools/Timer.h

@@ -43 +43 @@
 
     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 +61 @@
 
 #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 +76 @@
 
         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 +125 @@
     {
         public:
-            /** @brief Constructor: Sets the default-values. */
-            Timer()
-            {
-                this->timerFunction_ = 0;
-                this->object_ = 0;
-            }
+            Timer() {}
 
             /**
@@ -113 +132 @@
                 @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 +144 @@
                 @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;
+            }
     };