Index: code/branches/FICN/src/orxonox/objects/BaseObject.h
===================================================================
--- code/branches/FICN/src/orxonox/objects/BaseObject.h	(revision 376)
+++ code/branches/FICN/src/orxonox/objects/BaseObject.h	(revision 384)
@@ -2,5 +2,5 @@
 #define _BaseObject_H__
 
-#include "orxonox/core/IdentifierIncludes.h"
+#include "../core/IdentifierIncludes.h"
 
 namespace orxonox
@@ -11,43 +11,4 @@
             BaseObject();
             virtual ~BaseObject();
-
-            inline bool isA(const Identifier* identifier)
-                { this->getIdentifier()->isA(identifier); }
-            inline bool isDirectlyA(const Identifier* identifier)
-                { this->getIdentifier()->isDirectlyA(identifier); }
-            inline bool isChildOf(const Identifier* identifier)
-                { this->getIdentifier()->isChildOf(identifier); }
-            inline bool isParentOf(const Identifier* identifier)
-                { this->getIdentifier()->isParentOf(identifier); }
-
-            inline bool isA(const SubclassIdentifier<class B>* identifier)
-                { this->getIdentifier()->isA(identifier->getIdentifier()); }
-            inline bool isDirectlyA(const SubclassIdentifier<class B>* identifier)
-                { this->getIdentifier()->isDirectlyA(identifier->getIdentifier()); }
-            inline bool isChildOf(const SubclassIdentifier<class B>* identifier)
-                { this->getIdentifier()->isChildOf(identifier->getIdentifier()); }
-            inline bool isParentOf(const SubclassIdentifier<class B>* identifier)
-                { this->getIdentifier()->isParentOf(identifier->getIdentifier()); }
-
-            inline bool isA(const SubclassIdentifier<class B> identifier)
-                { this->getIdentifier()->isA(identifier.getIdentifier()); }
-            inline bool isDirectlyA(const SubclassIdentifier<class B> identifier)
-                { this->getIdentifier()->isDirectlyA(identifier.getIdentifier()); }
-            inline bool isChildOf(const SubclassIdentifier<class B> identifier)
-                { this->getIdentifier()->isChildOf(identifier.getIdentifier()); }
-            inline bool isParentOf(const SubclassIdentifier<class B> identifier)
-                { this->getIdentifier()->isParentOf(identifier.getIdentifier()); }
-
-            inline bool isA(const OrxonoxClass* object)
-                { this->getIdentifier()->isA(object->getIdentifier()); }
-            inline bool isDirectlyA(const OrxonoxClass* object)
-                { this->getIdentifier()->isDirectlyA(object->getIdentifier()); }
-            inline bool isChildOf(const OrxonoxClass* object)
-                { this->getIdentifier()->isChildOf(object->getIdentifier()); }
-            inline bool isParentOf(const OrxonoxClass* object)
-                { this->getIdentifier()->isParentOf(object->getIdentifier()); }
-
-            std::string name_; // test
-
     };
 }
Index: code/branches/FICN/src/orxonox/objects/Tickable.h
===================================================================
--- code/branches/FICN/src/orxonox/objects/Tickable.h	(revision 384)
+++ code/branches/FICN/src/orxonox/objects/Tickable.h	(revision 384)
@@ -0,0 +1,33 @@
+#ifndef _Tickable_H__
+#define _Tickable_H__
+
+#include "../core/IdentifierIncludes.h"
+#include "Ogre.h"
+
+namespace orxonox
+{
+    class TickFrameListener;
+
+    class Tickable : virtual public OrxonoxClass
+    {
+        public:
+            virtual void tick(float dt) = 0;
+
+        protected:
+            Tickable() { RegisterRootObject(Tickable); }
+    };
+
+    class TickFrameListener : public Ogre::FrameListener
+    {
+        private:
+            bool frameStarted(const Ogre::FrameEvent &evt)
+            {
+                for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+                    it->tick(evt.timeSinceLastFrame);
+
+                return FrameListener::frameStarted(evt);
+            }
+    };
+}
+
+#endif
Index: code/branches/FICN/src/orxonox/objects/Timer.h
===================================================================
--- code/branches/FICN/src/orxonox/objects/Timer.h	(revision 384)
+++ code/branches/FICN/src/orxonox/objects/Timer.h	(revision 384)
@@ -0,0 +1,105 @@
+#ifndef _Timer_H__
+#define _Timer_H__
+
+#include "../core/IdentifierIncludes.h"
+#include "Ogre.h"
+
+namespace orxonox
+{
+    class TimerBase : public OrxonoxClass
+    {
+        friend class TimerFrameListener;
+
+        public:
+            TimerBase()
+            {
+                RegisterRootObject(TimerBase);
+
+                this->interval_ = 0;
+                this->bLoop_ = false;
+                this->bActive_ = false;
+
+                this->time_ = 0;
+            }
+
+            virtual void run() const = 0;
+
+            inline void startTimer() { this->bActive_ = true; this->time_ = this->interval_; }
+            inline void stopTimer() { this->bActive_ = false; this->time_ = this->interval_; }
+            inline void pauseTimer() { this->bActive_ = false; }
+            inline void unpauseTimer() { this->bActive_ = true; }
+            inline bool isActive() const { return this->bActive_; }
+
+        protected:
+            float interval_;
+            bool bLoop_;
+            bool bActive_;
+
+            float time_;
+    };
+
+    template <class T = BaseObject>
+    class Timer : public TimerBase
+    {
+        public:
+            Timer()
+            {
+                this->timerFunction_ = 0;
+                this->object_ = 0;
+            }
+
+            Timer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+            {
+                this->setTimer(interval, bLoop, timerFunction, object);
+            }
+
+            void setTimer(float interval, bool bLoop, T* object, void (T::*timerFunction)())
+            {
+                this->interval_ = interval;
+                this->bLoop_ = bLoop;
+                this->timerFunction_ = timerFunction;
+                this->object_ = object;
+                this->bActive_ = true;
+
+                this->time_ = interval;
+            }
+
+            void run() const
+            {
+                ((*this->object_).*timerFunction_)();
+            }
+
+        private:
+            void (T::*timerFunction_)();
+            T* object_;
+    };
+
+    class TimerFrameListener : public Ogre::FrameListener
+    {
+        private:
+            bool frameStarted(const Ogre::FrameEvent &evt)
+            {
+                for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; ++it)
+                {
+                    if (it->isActive())
+                    {
+                        it->time_ -= evt.timeSinceLastFrame;
+
+                        if (it->time_ <= 0)
+                        {
+                            if (it->bLoop_)
+                                it->time_ += it->interval_;
+                            else
+                                it->stopTimer();
+
+                            it->run();
+                        }
+                    }
+                }
+
+                return FrameListener::frameStarted(evt);
+            }
+    };
+}
+
+#endif
Index: code/branches/FICN/src/orxonox/objects/test1.cc
===================================================================
--- code/branches/FICN/src/orxonox/objects/test1.cc	(revision 376)
+++ code/branches/FICN/src/orxonox/objects/test1.cc	(revision 384)
@@ -18,4 +18,9 @@
     Test1::~Test1()
     {
+    }
+
+    void Test1::tick(float dt)
+    {
+        std::cout << "Test1: " << this << "\n";
     }
 
Index: code/branches/FICN/src/orxonox/objects/test1.h
===================================================================
--- code/branches/FICN/src/orxonox/objects/test1.h	(revision 376)
+++ code/branches/FICN/src/orxonox/objects/test1.h	(revision 384)
@@ -3,13 +3,16 @@
 
 #include "BaseObject.h"
+#include "Tickable.h"
 #include "test3.h"
 
 namespace orxonox
 {
-    class Test1 : public BaseObject
+    class Test1 : public BaseObject, public Tickable
     {
         public:
             Test1();
             virtual ~Test1();
+
+            virtual void tick(float dt);
 
             bool usefullClass1isA(Identifier* identifier);
Index: code/branches/FICN/src/orxonox/objects/test2.cc
===================================================================
--- code/branches/FICN/src/orxonox/objects/test2.cc	(revision 376)
+++ code/branches/FICN/src/orxonox/objects/test2.cc	(revision 384)
@@ -14,8 +14,27 @@
         this->usefullClass2_ = Class(Test2);
         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);
     }
 
     Test2::~Test2()
     {
+    }
+
+    void Test2::timerFunction1()
+    {
+        std::cout << "Test2: 1 Sekunde\n";
+    }
+
+    void Test2::timerFunction2()
+    {
+        std::cout << "Test2: 5 Sekunden\n";
+    }
+
+    void Test2::timerFunction3()
+    {
+        std::cout << "Test2: 10 Sekunden sind um!\n";
     }
 
Index: code/branches/FICN/src/orxonox/objects/test2.h
===================================================================
--- code/branches/FICN/src/orxonox/objects/test2.h	(revision 376)
+++ code/branches/FICN/src/orxonox/objects/test2.h	(revision 384)
@@ -3,4 +3,5 @@
 
 #include "BaseObject.h"
+#include "Timer.h"
 
 namespace orxonox
@@ -21,4 +22,8 @@
             void setUsefullClassOfTypeTest3(Identifier* identifier);
 
+            void timerFunction1();
+            void timerFunction2();
+            void timerFunction3();
+
         private:
             Identifier* usefullClass1_;
@@ -26,4 +31,7 @@
             SubclassIdentifier<Test3> usefullClass3_;
 
+            Timer<Test2> timer1;
+            Timer<Test2> timer2;
+            Timer<Test2> timer3;
     };
 }
