[1505] | 1 | /* |
---|
| 2 | * ORXONOX - the hottest 3D action shooter ever to exist |
---|
| 3 | * > www.orxonox.net < |
---|
| 4 | * |
---|
| 5 | * |
---|
| 6 | * License notice: |
---|
| 7 | * |
---|
| 8 | * This program is free software; you can redistribute it and/or |
---|
| 9 | * modify it under the terms of the GNU General Public License |
---|
| 10 | * as published by the Free Software Foundation; either version 2 |
---|
| 11 | * of the License, or (at your option) any later version. |
---|
| 12 | * |
---|
| 13 | * This program is distributed in the hope that it will be useful, |
---|
| 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
---|
| 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
---|
| 16 | * GNU General Public License for more details. |
---|
| 17 | * |
---|
| 18 | * You should have received a copy of the GNU General Public License |
---|
| 19 | * along with this program; if not, write to the Free Software |
---|
| 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
---|
| 21 | * |
---|
| 22 | * Author: |
---|
| 23 | * Fabian 'x3n' Landau |
---|
| 24 | * Co-authors: |
---|
| 25 | * ... |
---|
| 26 | * |
---|
| 27 | */ |
---|
| 28 | |
---|
| 29 | /*! |
---|
| 30 | @file Timer.h |
---|
| 31 | @brief Definition and Implementation of the Timer class. |
---|
| 32 | |
---|
| 33 | The Timer is a callback-object, calling a given function after a given time-interval. |
---|
| 34 | |
---|
| 35 | Usage: |
---|
| 36 | header.h: |
---|
| 37 | class ClassName |
---|
| 38 | { |
---|
| 39 | public: |
---|
| 40 | ClassName(); |
---|
| 41 | void functionName(); |
---|
| 42 | Timer<ClassName> myTimer; |
---|
| 43 | }; |
---|
| 44 | |
---|
| 45 | source.cc: |
---|
| 46 | include "core/Executor.h" |
---|
| 47 | |
---|
| 48 | ClassName::ClassName() |
---|
| 49 | { |
---|
| 50 | myTimer.setTimer(interval_in_seconds, bLoop, this, createExecutor(createFunctor(&ClassName::functionName))); |
---|
| 51 | } |
---|
| 52 | |
---|
| 53 | void ClassName::functionName() |
---|
| 54 | { |
---|
| 55 | whateveryouwant(); |
---|
| 56 | something(else); |
---|
| 57 | } |
---|
| 58 | */ |
---|
| 59 | |
---|
| 60 | #ifndef _Timer_H__ |
---|
| 61 | #define _Timer_H__ |
---|
| 62 | |
---|
| 63 | #include "OrxonoxPrereqs.h" |
---|
[1755] | 64 | #include "core/OrxonoxClass.h" |
---|
[1505] | 65 | |
---|
| 66 | namespace orxonox |
---|
| 67 | { |
---|
| 68 | class StaticTimer; |
---|
| 69 | void delay(float delay, const std::string& command); |
---|
| 70 | void killdelays(); |
---|
| 71 | void executeDelayedCommand(StaticTimer* timer, const std::string& command); |
---|
| 72 | |
---|
| 73 | //! TimerBase is the parent of the Timer class. |
---|
[1755] | 74 | class _OrxonoxExport TimerBase : public OrxonoxClass |
---|
[1505] | 75 | { |
---|
| 76 | public: |
---|
| 77 | ~TimerBase(); |
---|
| 78 | |
---|
| 79 | void run() const; |
---|
[1552] | 80 | void deleteExecutor(); |
---|
[1505] | 81 | |
---|
| 82 | /** @brief Starts the Timer: Function-call after 'interval' seconds. */ |
---|
| 83 | inline void startTimer() |
---|
| 84 | { this->bActive_ = true; this->time_ = this->interval_; } |
---|
| 85 | /** @brief Stops the Timer. */ |
---|
| 86 | inline void stopTimer() |
---|
| 87 | { this->bActive_ = false; this->time_ = this->interval_; } |
---|
| 88 | /** @brief Pauses the Timer - it will continue with the actual state if you unpause it. */ |
---|
| 89 | inline void pauseTimer() |
---|
| 90 | { this->bActive_ = false; } |
---|
| 91 | /** @brief Unpauses the Timer - continues with the given state. */ |
---|
| 92 | inline void unpauseTimer() |
---|
| 93 | { this->bActive_ = true; } |
---|
| 94 | /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */ |
---|
| 95 | inline bool isActive() const |
---|
| 96 | { return this->bActive_; } |
---|
[1608] | 97 | /** @brief Returns the remaining time until the Timer calls the function. @return The remaining time */ |
---|
| 98 | inline float getRemainingTime() const |
---|
[1755] | 99 | { return (float)this->time_ / 1000000.0f; } |
---|
[1505] | 100 | /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */ |
---|
| 101 | inline void addTime(float time) |
---|
[1755] | 102 | { if (time > 0.0f) this->time_ += (long long)(time * 1000000.0f); } |
---|
[1505] | 103 | /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */ |
---|
| 104 | inline void removeTime(float time) |
---|
[1755] | 105 | { if (time > 0.0f) this->time_ -= (long long)(time * 1000000.0f); } |
---|
[1505] | 106 | /** @brief Sets the interval of the Timer. @param interval The interval */ |
---|
| 107 | inline void setInterval(float interval) |
---|
[1755] | 108 | { this->interval_ = (long long)(interval * 1000000.0f); } |
---|
[1505] | 109 | /** @brief Sets bLoop to a given value. @param bLoop True = loop */ |
---|
| 110 | inline void setLoop(bool bLoop) |
---|
| 111 | { this->bLoop_ = bLoop; } |
---|
| 112 | |
---|
[1755] | 113 | void tick(const Clock& time); |
---|
[1505] | 114 | |
---|
| 115 | protected: |
---|
| 116 | TimerBase(); |
---|
| 117 | |
---|
[2087] | 118 | Executor* executor_; //!< The executor of the function that should be called when the time expires |
---|
[1505] | 119 | |
---|
[2087] | 120 | long long interval_; //!< The time-interval in micro seconds |
---|
| 121 | bool bLoop_; //!< If true, the function gets called every 'interval' seconds |
---|
| 122 | bool bActive_; //!< If true, the Timer ticks and calls the function if the time's up |
---|
| 123 | bool bKillAfterCall_; //!< If true the timer gets deleted after it called the function |
---|
[1505] | 124 | |
---|
[2087] | 125 | long long time_; //!< Internal variable, counting the time till the next function-call |
---|
[1505] | 126 | }; |
---|
| 127 | |
---|
| 128 | //! The Timer is a callback-object, calling a given function after a given time-interval. |
---|
| 129 | template <class T = BaseObject> |
---|
| 130 | class Timer : public TimerBase |
---|
| 131 | { |
---|
| 132 | public: |
---|
| 133 | Timer() {} |
---|
| 134 | |
---|
| 135 | /** |
---|
| 136 | @brief Constructor: Initializes the Timer with given values. |
---|
| 137 | @param interval The timer-interval in seconds |
---|
| 138 | @param bLoop If true, the function gets called every 'interval' seconds |
---|
| 139 | @param object The object owning the timer and the function |
---|
| 140 | @param exeuctor A executor of the function to call |
---|
| 141 | */ |
---|
[2087] | 142 | Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor, bool bKillAfterCall = false) |
---|
[1505] | 143 | { |
---|
[2087] | 144 | this->setTimer(interval, bLoop, object, exeuctor, bKillAfterCall); |
---|
[1505] | 145 | } |
---|
| 146 | |
---|
| 147 | /** |
---|
| 148 | @brief Initializes the Timer with given values. |
---|
| 149 | @param interval The timer-interval in seconds |
---|
| 150 | @param bLoop If true, the function gets called every 'interval' seconds |
---|
| 151 | @param object The object owning the timer and the function |
---|
| 152 | @param exeuctor A executor of the function to call |
---|
| 153 | */ |
---|
[2087] | 154 | void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor, bool bKillAfterCall = false) |
---|
[1505] | 155 | { |
---|
[1552] | 156 | this->deleteExecutor(); |
---|
| 157 | |
---|
[1755] | 158 | this->setInterval(interval); |
---|
[1505] | 159 | this->bLoop_ = bLoop; |
---|
| 160 | executor->setObject(object); |
---|
| 161 | this->executor_ = (Executor*)executor; |
---|
| 162 | this->bActive_ = true; |
---|
| 163 | |
---|
[1755] | 164 | this->time_ = this->interval_; |
---|
[2087] | 165 | this->bKillAfterCall_ = bKillAfterCall; |
---|
[1505] | 166 | } |
---|
| 167 | }; |
---|
| 168 | |
---|
| 169 | //! The StaticTimer is a callback-object, calling a static function after a given time-interval. |
---|
| 170 | class StaticTimer : public TimerBase |
---|
| 171 | { |
---|
| 172 | public: |
---|
| 173 | StaticTimer() {} |
---|
| 174 | |
---|
| 175 | /** |
---|
| 176 | @brief Constructor: Initializes the Timer with given values. |
---|
| 177 | @param interval The timer-interval in seconds |
---|
| 178 | @param bLoop If true, the function gets called every 'interval' seconds |
---|
| 179 | @param exeuctor A executor of the function to call |
---|
| 180 | */ |
---|
[2087] | 181 | StaticTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false) |
---|
[1505] | 182 | { |
---|
[2087] | 183 | this->setTimer(interval, bLoop, executor, bKillAfterCall); |
---|
[1505] | 184 | } |
---|
| 185 | |
---|
| 186 | /** |
---|
| 187 | @brief Initializes the Timer with given values. |
---|
| 188 | @param interval The timer-interval in seconds |
---|
| 189 | @param bLoop If true, the function gets called every 'interval' seconds |
---|
| 190 | @param object The object owning the timer and the function |
---|
| 191 | @param executor A executor of the function to call |
---|
| 192 | */ |
---|
[2087] | 193 | void setTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false) |
---|
[1505] | 194 | { |
---|
[1552] | 195 | this->deleteExecutor(); |
---|
| 196 | |
---|
[1755] | 197 | this->setInterval(interval); |
---|
[1505] | 198 | this->bLoop_ = bLoop; |
---|
| 199 | this->executor_ = (Executor*)executor; |
---|
| 200 | this->bActive_ = true; |
---|
| 201 | |
---|
[1755] | 202 | this->time_ = this->interval_; |
---|
[2087] | 203 | this->bKillAfterCall_ = bKillAfterCall; |
---|
[1505] | 204 | } |
---|
| 205 | }; |
---|
| 206 | |
---|
| 207 | } |
---|
| 208 | |
---|
| 209 | #endif /* _Timer_H__ */ |
---|