Index: code/trunk/src/orxonox/objects/Ambient.cc
===================================================================
--- code/trunk/src/orxonox/objects/Ambient.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Ambient.cc	(revision 790)
@@ -0,0 +1,79 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include <vector>
+#include <string>
+
+#include <OgreSceneManager.h>
+
+#include "util/tinyxml/tinyxml.h"
+#include "util/Tokenizer.h"
+#include "util/String2Number.h"
+#include "util/Math.h"
+#include "../core/Debug.h"
+#include "../core/CoreIncludes.h"
+#include "../Orxonox.h"
+
+#include "Ambient.h"
+
+namespace orxonox
+{
+    // create a template instantiations
+    //template class _OrxonoxExport ClassIdentifier<Ambient>;
+
+    CreateFactory(Ambient);
+
+    Ambient::Ambient()
+    {
+        RegisterObject(Ambient);
+    }
+
+    Ambient::~Ambient()
+    {
+    }
+
+    void Ambient::loadParams(TiXmlElement* xmlElem)
+    {
+    	Ogre::SceneManager* mgr = orxonox::Orxonox::getSingleton()->getSceneManager();
+
+    	if (xmlElem->Attribute("colourvalue"))
+    	{
+
+	    	std::vector<std::string> colourvalues = tokenize(xmlElem->Attribute("colourvalue"),",");
+	    	float r, g, b;
+    	 	String2Number<float>(r, colourvalues[0]);
+	    	String2Number<float>(g, colourvalues[1]);
+	    	String2Number<float>(b, colourvalues[2]);
+
+	    	mgr->setAmbientLight(ColourValue(r,g,b));
+
+	    	COUT(4) << "Loader: Set ambient light: "<<r<<" " << g << " " << b  << std::endl << std::endl;
+    	}
+   }
+}
Index: code/trunk/src/orxonox/objects/Ambient.h
===================================================================
--- code/trunk/src/orxonox/objects/Ambient.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Ambient.h	(revision 790)
@@ -0,0 +1,26 @@
+#ifndef _Ambient_H__
+#define _Ambient_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "core/BaseObject.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport Ambient : public BaseObject
+    {
+        public:
+            Ambient();
+            virtual ~Ambient();
+
+            
+            void loadParams(TiXmlElement* xmlElem);
+
+        private:
+            
+
+    };
+    ExportClass(Ambient, Orxonox);
+}
+
+#endif /* _Ambient_H__ */
Index: code/trunk/src/orxonox/objects/BaseObject.cc
===================================================================
--- code/trunk/src/orxonox/objects/BaseObject.cc	(revision 258)
+++ 	(revision )
@@ -1,15 +1,0 @@
-#include "BaseObject.h"
-
-namespace orxonox
-{
-    CreateFactory(BaseObject);
-
-    BaseObject::BaseObject()
-    {
-        RegisterRootObject(BaseObject);
-    }
-
-    BaseObject::~BaseObject()
-    {
-    }
-}
Index: code/trunk/src/orxonox/objects/BaseObject.h
===================================================================
--- code/trunk/src/orxonox/objects/BaseObject.h	(revision 258)
+++ 	(revision )
@@ -1,55 +1,0 @@
-#ifndef _BaseObject_H__
-#define _BaseObject_H__
-
-#include "../core/IdentifierIncludes.h"
-
-namespace orxonox
-{
-    class BaseObject : virtual public OrxonoxClass
-    {
-        public:
-            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
-
-    };
-}
-
-#endif
Index: code/trunk/src/orxonox/objects/Camera.cc
===================================================================
--- code/trunk/src/orxonox/objects/Camera.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Camera.cc	(revision 790)
@@ -0,0 +1,77 @@
+
+#include "OrxonoxStableHeaders.h"
+
+#include <string>
+
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+#include <OgreRoot.h>
+#include <OgreRenderWindow.h>
+#include <OgreViewport.h>
+
+#include "util/tinyxml/tinyxml.h"
+#include "util/Tokenizer.h"
+#include "util/String2Number.h"
+#include "util/Math.h"
+#include "../core/Debug.h"
+#include "../core/CoreIncludes.h"
+#include "../Orxonox.h"
+#include "../GraphicsEngine.h"
+
+#include "Camera.h"
+
+namespace orxonox
+{
+    CreateFactory(Camera);
+
+    Camera::Camera()
+    {
+        RegisterObject(Camera);
+    }
+
+    Camera::~Camera()
+    {
+    }
+
+    void Camera::loadParams(TiXmlElement* xmlElem)
+    {
+      Ogre::SceneManager* mgr = orxonox::Orxonox::getSingleton()->getSceneManager();
+
+      if (xmlElem->Attribute("name") && xmlElem->Attribute("pos") && xmlElem->Attribute("lookat") && xmlElem->Attribute("node"))
+      {
+        //    <Camera name="Camera" pos="0,0,-250" lookat="0,0,0" />
+
+        std::string name = xmlElem->Attribute("name");
+        std::string pos = xmlElem->Attribute("pos");
+        std::string lookat = xmlElem->Attribute("lookat");
+
+        Ogre::Camera *cam = mgr->createCamera(name);
+
+        float x, y, z;
+        std::vector<std::string> posVec = tokenize(xmlElem->Attribute("pos"),",");
+        String2Number<float>(x, posVec[0]);
+        String2Number<float>(y, posVec[1]);
+        String2Number<float>(z, posVec[2]);
+
+        cam->setPosition(Vector3(x,y,z));
+
+        posVec = tokenize(xmlElem->Attribute("lookat"),",");
+        String2Number<float>(x, posVec[0]);
+        String2Number<float>(y, posVec[1]);
+        String2Number<float>(z, posVec[2]);
+
+        cam->lookAt(Vector3(x,y,z));
+
+        std::string node = xmlElem->Attribute("node");
+
+        Ogre::SceneNode* sceneNode = (Ogre::SceneNode*)mgr->getRootSceneNode()->createChildSceneNode(node); //getChild(node);
+        sceneNode->attachObject((Ogre::MovableObject*)cam);
+
+        // FIXME: unused var
+        Ogre::Viewport* vp = orxonox::Orxonox::getSingleton()->getOgrePointer()->getRoot()->getAutoCreatedWindow()->addViewport(cam);
+
+
+        COUT(4) << "Loader: Created camera "<< name  << std::endl << std::endl;
+      }
+   }
+}
Index: code/trunk/src/orxonox/objects/Camera.h
===================================================================
--- code/trunk/src/orxonox/objects/Camera.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Camera.h	(revision 790)
@@ -0,0 +1,26 @@
+#ifndef _Camera_H__
+#define _Camera_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "core/BaseObject.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport Camera : public BaseObject
+    {
+        public:
+            Camera();
+            virtual ~Camera();
+
+            
+            void loadParams(TiXmlElement* xmlElem);
+
+        private:
+            
+
+    };
+    ExportClass(Camera, Orxonox);
+}
+
+#endif /* _Camera_H__ */
Index: code/trunk/src/orxonox/objects/Explosion.cc
===================================================================
--- code/trunk/src/orxonox/objects/Explosion.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Explosion.cc	(revision 790)
@@ -0,0 +1,85 @@
+/*
+ *   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 "OrxonoxStableHeaders.h"
+
+#include <OgreParticleSystem.h>
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+
+#include "../core/CoreIncludes.h"
+#include "util/Math.h"
+#include "../Orxonox.h"
+#include "../particle/ParticleInterface.h"
+
+#include "Explosion.h"
+
+namespace orxonox
+{
+    CreateFactory(Explosion);
+
+    Explosion::Explosion(WorldEntity* owner)
+    {
+        RegisterObject(Explosion);
+
+        this->particle_ = 0;
+        this->lifetime_ = 0.4;
+
+        if (owner)
+        {
+            this->destroyTimer_.setTimer(this->lifetime_, false, this, &Explosion::destroyObject);
+
+            Vector3 position = owner->getNode()->getWorldPosition();
+
+            this->particle_ = new ParticleInterface(Orxonox::getSingleton()->getSceneManager(), "explosion" + this->getName(), "Orxonox/treibwerk");
+            this->particle_->getParticleSystem()->setParameter("local_space", "true");
+            this->particle_->newEmitter();
+            this->particle_->setPositionOfEmitter(0, Vector3::ZERO);
+            this->particle_->setPositionOfEmitter(1, Vector3::ZERO);
+            this->particle_->setColour(ColourValue(1.0, 0.8, 0.2));
+
+            this->setPosition(position);
+            this->scale(2);
+
+            this->particle_->addToSceneNode(this->getNode());
+        }
+    }
+
+    Explosion::~Explosion()
+    {
+        if (this->particle_)
+        {
+            this->particle_->detachFromSceneNode();
+            delete this->particle_;
+        }
+    };
+
+    void Explosion::destroyObject()
+    {
+        delete this;
+    }
+}
Index: code/trunk/src/orxonox/objects/Explosion.h
===================================================================
--- code/trunk/src/orxonox/objects/Explosion.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Explosion.h	(revision 790)
@@ -0,0 +1,26 @@
+#ifndef _Explosion_H__
+#define _Explosion_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "WorldEntity.h"
+#include "../tools/Timer.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport Explosion : public WorldEntity
+    {
+        public:
+            Explosion(WorldEntity* owner = 0);
+            virtual ~Explosion();
+            void destroyObject();
+
+        private:
+            Timer<Explosion> destroyTimer_;
+            float lifetime_;
+            ParticleInterface* particle_;
+    };
+    ExportClass(Explosion, Orxonox);
+}
+
+#endif /* _Explosion_H__ */
Index: code/trunk/src/orxonox/objects/Fighter.cc
===================================================================
--- code/trunk/src/orxonox/objects/Fighter.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Fighter.cc	(revision 790)
@@ -0,0 +1,510 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include <string>
+
+#include <OgreCamera.h>
+#include <OgreRenderWindow.h>
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+
+#include "util/tinyxml/tinyxml.h"
+#include "util/String2Number.h"
+#include "../core/CoreIncludes.h"
+#include "../Orxonox.h"
+#include "../particle/ParticleInterface.h"
+#include "weapon/AmmunitionDump.h"
+#include "weapon/BarrelGun.h"
+
+#include "Fighter.h"
+
+namespace orxonox
+{
+    CreateFactory(Fighter);
+
+    Fighter::Fighter()
+    {
+        RegisterObject(Fighter);
+
+        this->setConfigValues();
+
+        this->setMouseEventCallback_ = false;
+
+        this->w = NULL;
+        this->tt = NULL;
+        this->ammoDump_ = NULL;
+        this->mainWeapon_ = NULL;
+        this->rightButtonPressed_ = false;
+        this->leftButtonPressed_ = false;
+
+        this->moveForward_ = 0;
+        this->rotateUp_ = 0;
+        this->rotateDown_ = 0;
+        this->rotateRight_ = 0;
+        this->rotateLeft_ = 0;
+        this->loopRight_ = 0;
+        this->loopLeft_ = 0;
+        this->brakeForward_ = 0;
+        this->brakeRotate_ = 0;
+        this->brakeLoop_ = 0;
+        this->speedForward_ = 0;
+        this->speedRotateUpDown_ = 0;
+        this->speedRotateRightLeft_ = 0;
+        this->speedLoopRightLeft_ = 0;
+        this->maxSpeedForward_ = 0;
+        this->maxSpeedRotateUpDown_ = 0;
+        this->maxSpeedRotateRightLeft_ = 0;
+        this->maxSpeedLoopRightLeft_ = 0;
+        this->accelerationForward_ = 0;
+        this->accelerationRotateUpDown_ = 0;
+        this->accelerationRotateRightLeft_ = 0;
+        this->accelerationLoopRightLeft_ = 0;
+
+        this->speed = 250;
+        this->loop = 100;
+        this->rotate = 10;
+        this->mouseX = 0;
+        this->mouseY = 0;
+        this->maxMouseX = 0;
+        this->minMouseX = 0;
+        this->moved = false;
+
+        this->brakeRotate(rotate*10);
+        this->brakeLoop(loop);
+
+        COUT(3) << "Info: Fighter was loaded" << std::endl;
+    }
+
+    Fighter::~Fighter()
+    {
+        if (w)
+            delete w;
+        if (tt)
+            delete tt;
+    }
+
+    void Fighter::setConfigValues()
+    {
+        SetConfigValue(bInvertMouse_, false).description("Set this to true for joystick-like mouse behaviour (mouse up = ship down).");
+    }
+
+    void Fighter::setMaxSpeedValues(float maxSpeedForward, float maxSpeedRotateUpDown, float maxSpeedRotateRightLeft, float maxSpeedLoopRightLeft)
+    {
+        this->maxSpeedForward_ = maxSpeedForward;
+        this->maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
+        this->maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
+        this->maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
+    }
+
+    void Fighter::loadParams(TiXmlElement* xmlElem)
+    {
+        Model::loadParams(xmlElem);
+
+#if 0
+        w = new particle::ParticleInterface(Orxonox::getSingleton()->getSceneManager(),"schuss" + this->getName(),"Orxonox/schuss");
+        w->getParticleSystem()->setParameter("local_space","true");
+        w->newEmitter();
+/*
+        w->setDirection(Vector3(0,0,1));
+        w->setPositionOfEmitter(0, Vector3(10,10,0));
+        w->setPositionOfEmitter(1, Vector3(-10,10,0));
+*/
+        w->setDirection(Vector3(1,0,0));
+        w->setPositionOfEmitter(0, Vector3(0,10,10));
+        w->setPositionOfEmitter(1, Vector3(0,-10,10));
+
+        emitterRate_ = w->getRate();
+
+        Ogre::SceneNode* node1 = this->getNode()->createChildSceneNode(this->getName() + "particle1");
+        node1->setInheritScale(false);
+        w->addToSceneNode(node1);
+#endif
+
+        tt = new ParticleInterface(Orxonox::getSingleton()->getSceneManager(),"twinthruster" + this->getName(),"Orxonox/engineglow");
+        tt->getParticleSystem()->setParameter("local_space","true");
+        tt->newEmitter();
+/*
+        tt->setDirection(Vector3(0,0,1));
+        tt->setPositionOfEmitter(0, Vector3(20,-1,-15));
+        tt->setPositionOfEmitter(1, Vector3(-20,-1,-15));
+*/
+        tt->setDirection(Vector3(-1,0,0));
+        tt->setPositionOfEmitter(0, Vector3(-15,20,-1));
+        tt->setPositionOfEmitter(1, Vector3(-15,-20,-1));
+        tt->setVelocity(50);
+
+        Ogre::SceneNode* node2 = this->getNode()->createChildSceneNode(this->getName() + "particle2");
+        node2->setInheritScale(false);
+        tt->addToSceneNode(node2);
+
+        // add weapon
+
+        ammoDump_ = new AmmunitionDump();
+        ammoDump_->setDumpSize("Barrel", 1000);
+        ammoDump_->store("Barrel", 420);
+
+        mainWeapon_ = new BarrelGun();
+        mainWeapon_->setAmmoDump(ammoDump_);
+        Orxonox::getSingleton()->getSceneManager()->getRootSceneNode()->removeChild(mainWeapon_->getNode());
+        getNode()->addChild(mainWeapon_->getNode());
+
+        if (xmlElem->Attribute("forward") && xmlElem->Attribute("rotateupdown") && xmlElem->Attribute("rotaterightleft") && xmlElem->Attribute("looprightleft"))
+        {
+            std::string forwardStr = xmlElem->Attribute("forward");
+            std::string rotateupdownStr = xmlElem->Attribute("rotateupdown");
+            std::string rotaterightleftStr = xmlElem->Attribute("rotaterightleft");
+            std::string looprightleftStr = xmlElem->Attribute("looprightleft");
+
+            String2Number<float>(this->maxSpeedForward_, forwardStr);
+            String2Number<float>(this->maxSpeedRotateUpDown_, rotateupdownStr);
+            String2Number<float>(this->maxSpeedRotateRightLeft_, rotaterightleftStr);
+            String2Number<float>(this->maxSpeedLoopRightLeft_, looprightleftStr);
+
+            COUT(4) << "Loader: Initialized spaceship steering with values " << maxSpeedForward_ << " " << maxSpeedRotateUpDown_ << " " << maxSpeedRotateRightLeft_ << " " << maxSpeedLoopRightLeft_ << " " << std::endl;
+    	}
+
+    	if (xmlElem->Attribute("camera"))
+    	{
+            Ogre::Camera *cam = Orxonox::getSingleton()->getSceneManager()->createCamera("ShipCam");
+            Ogre::SceneNode *node = this->getNode()->createChildSceneNode("CamNode");
+/*
+//            node->setInheritOrientation(false);
+            cam->setPosition(Vector3(0,50,-150));
+            cam->lookAt(Vector3(0,20,0));
+            cam->roll(Degree(0));
+*/
+
+            cam->setPosition(Vector3(-150,0,50));
+//            cam->setPosition(Vector3(0,-350,0));
+            cam->lookAt(Vector3(0,0,20));
+            cam->roll(Degree(-90));
+
+            node->attachObject(cam);
+            Orxonox::getSingleton()->getOgrePointer()->getRoot()->getAutoCreatedWindow()->addViewport(cam);
+    	}
+    }
+
+    bool Fighter::mouseMoved(const OIS::MouseEvent &e)
+    {
+        this->mouseX += e.state.X.rel;
+        //if (this->bInvertMouse_)
+            //this->mouseY += e.state.Y.rel;
+        //else
+            this->mouseY -= e.state.Y.rel;
+
+//        if(mouseX>maxMouseX) maxMouseX = mouseX;
+//        if(mouseX<minMouseX) minMouseX = mouseX;
+//        cout << "mouseX: " << mouseX << "\tmouseY: " << mouseY << endl;
+
+        this->moved = true;
+
+        return true;
+    }
+
+    bool Fighter::mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id )
+    {
+      if (id == OIS::MB_Left)
+      {
+        this->leftButtonPressed_ = true;
+      }
+      else if (id == OIS::MB_Right)
+        this->rightButtonPressed_ = true;
+      return true;
+    }
+
+    bool Fighter::mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id )
+    {
+      if (id == OIS::MB_Left)
+      {
+        this->leftButtonPressed_ = false;
+      }
+      else if (id == OIS::MB_Right)
+        this->rightButtonPressed_ = false;
+      return true;
+    }
+
+    void Fighter::tick(float dt)
+    {
+        if (!this->setMouseEventCallback_)
+        {
+            if (Orxonox::getSingleton()->getMouse())
+            {
+                Orxonox::getSingleton()->getMouse()->setEventCallback(this);
+                this->setMouseEventCallback_ = true;
+            }
+        }
+
+        WorldEntity::tick(dt);
+
+        OIS::Keyboard* mKeyboard = Orxonox::getSingleton()->getKeyboard();
+        OIS::Mouse* mMouse = Orxonox::getSingleton()->getMouse();
+
+        mKeyboard->capture();
+        mMouse->capture();
+
+        if (leftButtonPressed_)
+            mainWeapon_->primaryFireRequest();
+        if (rightButtonPressed_)
+            mainWeapon_->secondaryFireRequest();
+
+        if (mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W))
+            this->moveForward(speed);
+        else
+            this->moveForward(0);
+
+        if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S))
+            this->brakeForward(speed);
+        else
+            this->brakeForward(speed/10);
+
+        if (mKeyboard->isKeyDown(OIS::KC_RIGHT) || mKeyboard->isKeyDown(OIS::KC_D))
+            this->loopRight(loop);
+        else
+            this->loopRight(0);
+
+        if (mKeyboard->isKeyDown(OIS::KC_LEFT) || mKeyboard->isKeyDown(OIS::KC_A))
+            this->loopLeft(loop);
+        else
+            this->loopLeft(0);
+
+        if (mKeyboard->isKeyDown(OIS::KC_G))
+            this->mainWeapon_->addAction(BaseWeapon::RELOAD);
+        else
+            this->loopLeft(0);
+
+        if(moved)
+        {
+            if (mouseY<=0)
+                this->rotateUp(-mouseY*rotate);
+            if (mouseY>0)
+                this->rotateDown(mouseY*rotate);
+            if (mouseX>0)
+                this->rotateRight(mouseX*rotate);
+            if (mouseX<=0)
+                this->rotateLeft(-mouseX*rotate);
+
+            mouseY = 0;
+            mouseX = 0;
+            moved = false;
+        }
+        else
+        {
+            this->rotateUp(0);
+            this->rotateDown(0);
+            this->rotateRight(0);
+            this->rotateLeft(0);
+        }
+
+        if(moveForward_ > 0)
+        {
+            accelerationForward_ = moveForward_;
+            if(speedForward_ < maxSpeedForward_)
+                speedForward_ += accelerationForward_*dt;
+            if(speedForward_ > maxSpeedForward_)
+                speedForward_ = maxSpeedForward_;
+        }
+
+        if(moveForward_ <= 0)
+        {
+            accelerationForward_ = -brakeForward_;
+            if(speedForward_ > 0)
+                speedForward_ += accelerationForward_*dt;
+            if(speedForward_ < 0)
+                speedForward_ = 0;
+        }
+
+        if(rotateUp_ > 0)
+        {
+            accelerationRotateUpDown_ = rotateUp_;
+            if(speedRotateUpDown_ < maxSpeedRotateUpDown_)
+                speedRotateUpDown_ += accelerationRotateUpDown_*dt;
+            if(speedRotateUpDown_ > maxSpeedRotateUpDown_)
+            speedRotateUpDown_ = maxSpeedRotateUpDown_;
+        }
+
+        if(rotateDown_ > 0)
+        {
+            accelerationRotateUpDown_ = rotateDown_;
+            if(speedRotateUpDown_ > -maxSpeedRotateUpDown_)
+                speedRotateUpDown_ -= accelerationRotateUpDown_*dt;
+            if(speedRotateUpDown_ < -maxSpeedRotateUpDown_)
+                speedRotateUpDown_ = -maxSpeedRotateUpDown_;
+        }
+
+        if(rotateUp_ == 0 && rotateDown_ == 0)
+        {
+            accelerationRotateUpDown_ = brakeRotate_;
+            if(speedRotateUpDown_ > 0)
+                speedRotateUpDown_ -= accelerationRotateUpDown_*dt;
+            if(speedRotateUpDown_ < 0)
+                speedRotateUpDown_ += accelerationRotateUpDown_*dt;
+            if(fabs(speedRotateUpDown_) < accelerationRotateUpDown_*dt)
+                speedRotateUpDown_ = 0;
+        }
+
+        if(rotateRight_ > 0)
+        {
+            accelerationRotateRightLeft_ = rotateRight_;
+            if(speedRotateRightLeft_ > -maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ -= accelerationRotateRightLeft_*dt;
+            if(speedRotateRightLeft_ < -maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ = -maxSpeedRotateRightLeft_;
+        }
+
+        if(rotateLeft_ > 0)
+        {
+            accelerationRotateRightLeft_ = rotateLeft_;
+            if(speedRotateRightLeft_ < maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ += accelerationRotateRightLeft_*dt;
+            if(speedRotateRightLeft_ > maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ = maxSpeedRotateRightLeft_;
+        }
+
+        if(rotateRight_ == 0 && rotateLeft_ == 0)
+        {
+            accelerationRotateRightLeft_ = brakeRotate_;
+            if(speedRotateRightLeft_ > 0)
+                speedRotateRightLeft_ -= accelerationRotateRightLeft_*dt;
+            if(speedRotateRightLeft_ < 0)
+                speedRotateRightLeft_ += accelerationRotateRightLeft_*dt;
+            if(fabs(speedRotateRightLeft_) < accelerationRotateRightLeft_*dt)
+                speedRotateRightLeft_ = 0;
+        }
+
+        if(loopRight_ > 0)
+        {
+            accelerationLoopRightLeft_ = loopRight_;
+            if(speedLoopRightLeft_ < maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ += accelerationLoopRightLeft_*dt;
+            if(speedLoopRightLeft_ > maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ = maxSpeedLoopRightLeft_;
+        }
+
+        if(loopLeft_ > 0)
+        {
+            accelerationLoopRightLeft_ = loopLeft_;
+            if(speedLoopRightLeft_ > -maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ -= accelerationLoopRightLeft_*dt;
+            if(speedLoopRightLeft_ < -maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ = -maxSpeedLoopRightLeft_;
+        }
+
+        if(loopLeft_ == 0 && loopRight_ == 0)
+        {
+            accelerationLoopRightLeft_ = brakeLoop_;
+            if(speedLoopRightLeft_ > 0)
+                speedLoopRightLeft_ -= accelerationLoopRightLeft_*dt;
+            if(speedLoopRightLeft_ < 0)
+                speedLoopRightLeft_ += accelerationLoopRightLeft_*dt;
+            if(fabs(speedLoopRightLeft_) < accelerationLoopRightLeft_*dt)
+                speedLoopRightLeft_ = 0;
+        }
+
+        Vector3 transVector = Vector3::ZERO;
+/*
+        transVector.z = 1;
+        this->translate(transVector*speedForward_*dt, Ogre::Node::TS_LOCAL);
+        this->pitch(Degree(speedRotateUpDown_*dt), Ogre::Node::TS_LOCAL);
+        this->yaw(Degree(speedRotateRightLeft_*dt), Ogre::Node::TS_LOCAL);
+        this->roll(Degree(speedLoopRightLeft_*dt), Ogre::Node::TS_LOCAL);
+*/
+
+        transVector.x = 1;
+        this->translate(transVector*speedForward_*dt, Ogre::Node::TS_LOCAL);
+        this->yaw(Degree(speedRotateUpDown_*dt), Ogre::Node::TS_LOCAL);
+        this->roll(Degree(speedRotateRightLeft_*dt), Ogre::Node::TS_LOCAL);
+        this->pitch(Degree(speedLoopRightLeft_*dt), Ogre::Node::TS_LOCAL);
+
+        if (accelerationForward_ > 25.0)
+        {
+          this->tt->setRate(emitterRate_);
+        }
+        else
+        {
+          this->tt->setRate(0);
+        }
+
+    }
+
+    void Fighter::moveForward(float moveForward) {
+        moveForward_ = moveForward;
+    }
+
+    void Fighter::rotateUp(float rotateUp) {
+        rotateUp_ = rotateUp;
+    }
+
+    void Fighter::rotateDown(float rotateDown) {
+        rotateDown_ = rotateDown;
+    }
+
+    void Fighter::rotateLeft(float rotateLeft) {
+        rotateLeft_ = rotateLeft;
+    }
+
+    void Fighter::rotateRight(float rotateRight) {
+        rotateRight_ = rotateRight;
+    }
+
+    void Fighter::loopLeft(float loopLeft) {
+        loopLeft_ = loopLeft;
+    }
+
+    void Fighter::loopRight(float loopRight) {
+        loopRight_ = loopRight;
+    }
+
+    void Fighter::brakeForward(float brakeForward) {
+        brakeForward_ = brakeForward;
+    }
+
+    void Fighter::brakeRotate(float brakeRotate) {
+        brakeRotate_ = brakeRotate;
+    }
+
+    void Fighter::brakeLoop(float brakeLoop) {
+        brakeLoop_ = brakeLoop;
+    }
+
+    void Fighter::maxSpeedForward(float maxSpeedForward) {
+        maxSpeedForward_ = maxSpeedForward;
+    }
+
+    void Fighter::maxSpeedRotateUpDown(float maxSpeedRotateUpDown) {
+        maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
+    }
+
+    void Fighter::maxSpeedRotateRightLeft(float maxSpeedRotateRightLeft) {
+        maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
+    }
+
+    void Fighter::maxSpeedLoopRightLeft(float maxSpeedLoopRightLeft) {
+        maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
+    }
+}
Index: code/trunk/src/orxonox/objects/Fighter.h
===================================================================
--- code/trunk/src/orxonox/objects/Fighter.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Fighter.h	(revision 790)
@@ -0,0 +1,95 @@
+#ifndef _Fighter_H__
+#define _Fighter_H__
+
+#include <OIS/OIS.h>
+
+#include "../OrxonoxPrereqs.h"
+
+#include "Model.h"
+
+class TiXmlElement; // Forward declaration
+
+namespace orxonox
+{
+    class _OrxonoxExport Fighter : public Model, public OIS::MouseListener
+    {
+        public:
+            Fighter();
+            ~Fighter();
+            void setConfigValues();
+            virtual void loadParams(TiXmlElement* xmlElem);
+            void setMaxSpeedValues(float maxSpeedForward, float maxSpeedRotateUpDown, float maxSpeedRotateRightLeft, float maxSpeedLoopRightLeft);
+            virtual void tick(float dt);
+            void moveForward(float moveForward);
+            void rotateUp(float rotateUp);
+            void rotateDown(float rotateDown);
+            void rotateRight(float rotateRight);
+            void rotateLeft(float rotateLeft);
+            void loopRight(float loopRight);
+            void loopLeft(float loopLeft);
+            void brakeForward(float brakeForward);
+            void brakeRotate(float brakeRotate);
+            void brakeLoop(float brakeLoop);
+            void maxSpeedForward(float maxSpeedForward);
+            void maxSpeedRotateUpDown(float maxSpeedRotateUpDown);
+            void maxSpeedRotateRightLeft(float maxSpeedRotateRightLeft);
+            void maxSpeedLoopRightLeft(float maxSpeedLoopRightLeft);
+            bool mouseMoved(const OIS::MouseEvent &e);
+            bool mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id);// { return true; }
+            bool mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id);// { return true; }
+
+
+        private:
+            bool bInvertMouse_;
+            bool setMouseEventCallback_;
+
+            ParticleInterface *w;
+            ParticleInterface *tt;
+
+            AmmunitionDump* ammoDump_;
+            BarrelGun* mainWeapon_;
+
+            bool leftButtonPressed_;
+            bool rightButtonPressed_;
+
+            float moveForward_;
+            float rotateUp_;
+            float rotateDown_;
+            float rotateRight_;
+            float rotateLeft_;
+            float loopRight_;
+            float loopLeft_;
+            float brakeForward_;
+            float brakeRotate_;
+            float brakeLoop_;
+
+            float speedForward_;
+            float speedRotateUpDown_;
+            float speedRotateRightLeft_;
+            float speedLoopRightLeft_;
+
+            float maxSpeedForward_;
+            float maxSpeedRotateUpDown_;
+            float maxSpeedRotateRightLeft_;
+            float maxSpeedLoopRightLeft_;
+
+            float accelerationForward_;
+            float accelerationRotateUpDown_;
+            float accelerationRotateRightLeft_;
+            float accelerationLoopRightLeft_;
+
+            float speed;
+            float rotate;
+            float loop;
+            float mouseY;
+            float mouseX;
+            float maxMouseX;
+            float minMouseX;
+            bool moved;
+
+            int emitterRate_;
+    };
+    ExportClass(Fighter, Orxonox);
+}
+
+#endif /* _Fighter_H__ */
Index: code/trunk/src/orxonox/objects/Model.cc
===================================================================
--- code/trunk/src/orxonox/objects/Model.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Model.cc	(revision 790)
@@ -0,0 +1,75 @@
+/*
+ *   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 "OrxonoxStableHeaders.h"
+
+#include "util/tinyxml/tinyxml.h"
+#include "util/Tokenizer.h"
+#include "util/String2Number.h"
+#include "../core/CoreIncludes.h"
+#include "../Orxonox.h"
+
+#include "Model.h"
+
+namespace orxonox
+{
+    CreateFactory(Model);
+
+    Model::Model()
+    {
+        RegisterObject(Model);
+    }
+
+    Model::~Model()
+    {
+    }
+
+    void Model::loadParams(TiXmlElement* xmlElem)
+    {
+        WorldEntity::loadParams(xmlElem);
+
+        if (xmlElem->Attribute("mesh"))
+        {
+            meshSrc_ = xmlElem->Attribute("mesh");
+        }
+        create();
+    }
+
+    bool Model::create(){
+      if(meshSrc_.compare("")!=0){
+        this->mesh_.setMesh(meshSrc_);
+        this->attachObject(this->mesh_.getEntity());
+        COUT(4) << "Loader: Created model" << std::endl;
+      }
+      registerAllVariables();
+      return true;
+    }
+
+    void Model::registerAllVariables(){
+      registerVar(&meshSrc_, meshSrc_.length() + 1, network::STRING);
+    }
+}
Index: code/trunk/src/orxonox/objects/Model.h
===================================================================
--- code/trunk/src/orxonox/objects/Model.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Model.h	(revision 790)
@@ -0,0 +1,30 @@
+#ifndef _Model_H__
+#define _Model_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "WorldEntity.h"
+#include "../tools/Mesh.h"
+
+class TiXmlElement; // Forward declaration
+
+namespace orxonox
+{
+
+    class _OrxonoxExport Model : public WorldEntity
+    {
+        public:
+            Model();
+            virtual ~Model();
+            virtual void loadParams(TiXmlElement* xmlElem);
+            bool create();
+
+        private:
+            std::string meshSrc_;
+            Mesh mesh_;
+            void registerAllVariables();
+    };
+    ExportClass(Model, Orxonox);
+}
+
+#endif /* _Model_H__ */
Index: code/trunk/src/orxonox/objects/NPC.cc
===================================================================
--- code/trunk/src/orxonox/objects/NPC.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/NPC.cc	(revision 790)
@@ -0,0 +1,172 @@
+/*
+ *   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:
+ *      Benjamin Knecht, beni_at_orxonox.net
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include "../core/CoreIncludes.h"
+#include "NPC.h"
+
+namespace orxonox {
+
+  CreateFactory(NPC);
+
+  NPC::NPC()
+  {
+    RegisterObject(NPC);
+    movable_ = true;
+  }
+
+  NPC::~NPC()
+  {
+  }
+
+  void NPC::loadParams(TiXmlElement* xmlElem)
+  {
+    Model::loadParams(xmlElem);
+  }
+
+  /**
+   * function to chance values of an element
+   */
+  void NPC::setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable) {
+    this->setAcceleration(acceleration);
+    this->setVelocity(speed);
+    this->translate(location);
+    movable_ = movable;
+  }
+
+  /**
+   * calculates the distance between the element and an other point given by temp
+   */
+  float NPC::getDistance(WorldEntity* temp)
+  {
+    Vector3 distance = temp->getPosition() - this->getPosition();
+    return distance.length();
+  }
+
+  /**
+   * updates the data of an element
+   */
+  void NPC::update()
+  {
+
+    //if element is movable, calculate acceleration
+    if (this->movable_ == true) calculateAcceleration();
+
+  }
+
+  /**
+   * tick this NPC
+   */
+  void NPC::tick(float dt)
+  {
+
+    this->setVelocity(0.995*this->getVelocity() + this->getAcceleration()*dt);
+    this->translate(this->getVelocity()*dt);
+    this->setAcceleration(Vector3(0,0,0));
+  }
+
+  /**
+   * calculates the new acceleration of an element
+   */
+  void NPC::calculateAcceleration()
+  {
+    //acceleration consisting of flocking-functions
+    this->setAcceleration(separation() + alignment() + cohesion());
+  }
+
+  /**
+   * separation-function (keep elements separated, avoid crashs)
+   */
+  Vector3 NPC::separation()
+  {
+    Vector3 steering = Vector3(0,0,0); //steeringvector
+    Vector3 inverseDistance = Vector3(0,0,0);  //vector pointing away from possible collisions
+    int numberOfNeighbour = 0;  //number of observed neighbours
+    float distance = 0;  // distance to the actual element
+    for(Iterator<WorldEntity> it = ObjectList<WorldEntity>::start(); it; ++it) {  //go through all elements
+      distance = getDistance(*it);  //get distance between this and actual
+      if ((distance > 0) && (distance < SEPERATIONDISTANCE)) {  //do only if actual is inside detectionradius
+        inverseDistance = Vector3(0,0,0);
+        inverseDistance = this->getPosition() - it->getPosition();  //calculate the distancevector heading towards this
+        //adaptation of the inverseDistance to the distance
+        if ((distance < 200) && (distance >= 120)) {inverseDistance = 2*inverseDistance;}
+        if ((distance < 120) && (distance >= 80)) {inverseDistance = 5*inverseDistance;}
+        if ((distance < 80) && (distance >= 40)) {inverseDistance = 10*inverseDistance;}
+        if ((distance < 40) && (distance > 0)) {inverseDistance = 10*inverseDistance;}
+        steering = steering + inverseDistance;  //add up all significant steeringvectors
+        numberOfNeighbour++;  //counts the elements inside the detectionradius
+      }
+    }
+    if(numberOfNeighbour > 0) { steering = steering / (float)numberOfNeighbour; }  //devide the sum of steeringvectors by the number of elements -> separation steeringvector
+    return steering;
+  }
+
+  /**
+   * alignment-function (lead elements to the same heading)
+   */
+  Vector3 NPC::alignment()
+  {
+    Vector3 steering = Vector3(0,0,0); //steeringvector
+    int numberOfNeighbour = 0;  //number of observed neighbours
+    //float distance = 0;
+    //go through all elements
+    for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) {  //just working with 3 elements at the moment
+      float distance = getDistance(*it);  //get distance between this and actual
+      if ((distance > 0) && (distance < ALIGNMENTDISTANCE)) {  //check if actual element is inside detectionradius
+        steering = steering + it->getVelocity();  //add up all speedvectors inside the detectionradius
+        numberOfNeighbour++;  //counts the elements inside the detectionradius
+      }
+    }
+    if(numberOfNeighbour > 0) { steering = steering / (float)numberOfNeighbour; }  //devide the sum of steeringvectors by the number of elements -> alignment steeringvector
+    return steering;
+  }
+
+  /**
+   * cohseion-function (keep elements close to each other)
+   */
+  Vector3 NPC::cohesion()
+  {
+    Vector3 steering = Vector3(0,0,0); //steeringvector
+    int numberOfNeighbour = 0;  //number of observed neighbours
+    //float distance = 0;
+    //go through all elements
+    for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it) {  //just working with 3 elements at the moment
+      float distance = getDistance(*it);  //get distance between this and actual
+      if ((distance > 0) && (distance < COHESIONDISTANCE)) {  //check if actual element is inside detectionradius
+        steering = steering + it->getPosition();  //add up all locations of elements inside the detectionradius
+        numberOfNeighbour++;  //counts the elements inside the detectionradius
+      }
+    }
+    if(numberOfNeighbour > 0) {
+      steering = steering  / (float)numberOfNeighbour;  //devide the sum steeringvector by the number of elements -> cohesion steeringvector
+      steering = steering - this->getPosition();  //transform the vector for the ship
+    }
+    return steering;
+  }
+
+} // end of class NPC
Index: code/trunk/src/orxonox/objects/NPC.h
===================================================================
--- code/trunk/src/orxonox/objects/NPC.h	(revision 790)
+++ code/trunk/src/orxonox/objects/NPC.h	(revision 790)
@@ -0,0 +1,49 @@
+/**
+  @file NPC.h
+  @brief AI using WorldEntity
+  @author Benjamin Knecht <beni_at_orxonox.net>
+ */
+
+#ifndef _NPC_H__
+#define _NPC_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "Model.h"
+
+class TiXmlElement; // Forward declaration
+
+namespace orxonox {
+
+  class _OrxonoxExport NPC : public Model
+  {
+    public:
+
+      NPC();
+      virtual ~NPC();
+      virtual void loadParams(TiXmlElement* xmlElem);
+      void tick(float dt);
+      void update();
+      void setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable);
+
+    private:
+      float getDistance(WorldEntity* temp);
+      void calculateAcceleration();
+      Vector3 separation();
+      Vector3 alignment();
+      Vector3 cohesion();
+
+
+    private:
+      bool movable_;  // movability of the element, (false) gives the possiblity that an object can`t be moved by flocking but still gets into the calculation
+
+      // those values should maybe be controlled by a higher power and should maybe be parameters that can be changed
+      static int const SEPERATIONDISTANCE = 300;  //detectionradius of seperation
+      static int const ALIGNMENTDISTANCE = 300;  //detectionradius of alignment
+      static int const COHESIONDISTANCE = 5000;  //detectionradius of cohesion
+      static int const NUMELEMENTS = 9;  //number of elements
+  };
+  ExportClass(NPC, Orxonox);
+
+}
+#endif /* _NPC_H__ */
Index: code/trunk/src/orxonox/objects/Projectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/Projectile.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Projectile.cc	(revision 790)
@@ -0,0 +1,100 @@
+/*
+ *   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 "OrxonoxStableHeaders.h"
+
+#include "../core/CoreIncludes.h"
+#include "SpaceShip.h"
+#include "Explosion.h"
+#include "Model.h"
+
+#include "Projectile.h"
+
+namespace orxonox
+{
+    CreateFactory(Projectile);
+
+    Projectile::Projectile(SpaceShip* owner)
+    {
+        RegisterObject(Projectile);
+
+        this->setConfigValues();
+
+        this->owner_ = owner;
+
+        this->billboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 1.0, 0.5), 1);
+        this->attachObject(this->billboard_.getBillboardSet());
+        this->scale(0.5);
+
+        if (this->owner_)
+        {
+            this->setStatic(false);
+            this->setOrientation(this->owner_->getOrientation());
+            this->setPosition(this->owner_->getPosition());
+            this->translate(Vector3(55, 0, 0), Ogre::Node::TS_LOCAL);
+            this->setVelocity(Vector3(1, 0, 0) * this->speed_);
+        }
+
+        this->destroyTimer_.setTimer(this->lifetime_, false, this, &Projectile::destroyObject);
+    }
+
+    Projectile::~Projectile()
+    {
+    }
+
+    void Projectile::setConfigValues()
+    {
+        SetConfigValue(lifetime_, 10.0).description("The time in seconds a projectile stays alive");
+        SetConfigValue(speed_, 2000.0).description("The speed of a projectile in units per second");
+    }
+
+    void Projectile::tick(float dt)
+    {
+        WorldEntity::tick(dt);
+
+        float radius;
+        for (Iterator<Model> it = ObjectList<Model>::start(); it; ++it)
+        {
+            if ((*it) != this->owner_)
+            {
+                radius = it->getScale().x * 3.0;
+
+                if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))
+                {
+                    new Explosion(this);
+                    delete this;
+                    return;
+                }
+            }
+        }
+    }
+
+    void Projectile::destroyObject()
+    {
+        delete this;
+    }
+}
Index: code/trunk/src/orxonox/objects/Projectile.h
===================================================================
--- code/trunk/src/orxonox/objects/Projectile.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Projectile.h	(revision 790)
@@ -0,0 +1,33 @@
+#ifndef _Projectile_H__
+#define _Projectile_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "WorldEntity.h"
+#include "../tools/BillboardSet.h"
+#include "../tools/Timer.h"
+
+namespace orxonox
+{
+    class SpaceShip; // Forward declaration
+
+    class _OrxonoxExport Projectile : public WorldEntity
+    {
+        public:
+            Projectile(SpaceShip* owner = 0);
+            virtual ~Projectile();
+            void setConfigValues();
+            void destroyObject();
+            virtual void tick(float dt);
+
+        private:
+            SpaceShip* owner_;
+            BillboardSet billboard_;
+            float speed_;
+            float lifetime_;
+            Timer<Projectile> destroyTimer_;
+    };
+    ExportClass(Projectile, Orxonox);
+}
+
+#endif /* _Projectile_H__ */
Index: code/trunk/src/orxonox/objects/Skybox.cc
===================================================================
--- code/trunk/src/orxonox/objects/Skybox.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/Skybox.cc	(revision 790)
@@ -0,0 +1,68 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include <string>
+
+#include <OgreSceneManager.h>
+
+#include "util/tinyxml/tinyxml.h"
+//#include "util/Tokenizer.h"
+//#include "util/String2Number.h"
+#include "../Orxonox.h"
+#include "../core/CoreIncludes.h"
+#include "../core/Debug.h"
+
+#include "Skybox.h"
+
+namespace orxonox
+{
+    CreateFactory(Skybox);
+
+    Skybox::Skybox()
+    {
+        RegisterObject(Skybox);
+    }
+
+    Skybox::~Skybox()
+    {
+    }
+
+    void Skybox::loadParams(TiXmlElement* xmlElem)
+    {
+    	Ogre::SceneManager* mgr = orxonox::Orxonox::getSingleton()->getSceneManager();
+
+    	if (xmlElem->Attribute("src"))
+    	{
+    		std::string skyboxSrc = xmlElem->Attribute("src");
+	    	mgr->setSkyBox(true, skyboxSrc);
+
+	    	COUT(4) << "Loader: Set skybox: "<< skyboxSrc << std::endl << std::endl;
+    	}
+   }
+}
Index: code/trunk/src/orxonox/objects/Skybox.h
===================================================================
--- code/trunk/src/orxonox/objects/Skybox.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Skybox.h	(revision 790)
@@ -0,0 +1,28 @@
+#ifndef _Skybox_H__
+#define _Skybox_H__
+
+#include "../OrxonoxPrereqs.h"
+
+#include "core/BaseObject.h"
+
+class TiXmlElement; // Forward declaration
+
+namespace orxonox
+{
+    class _OrxonoxExport Skybox : public BaseObject
+    {
+        public:
+            Skybox();
+            virtual ~Skybox();
+
+            
+            void loadParams(TiXmlElement* xmlElem);
+
+        private:
+            
+
+    };
+    ExportClass(Skybox, Orxonox);
+}
+
+#endif /* _Skybox_H__ */
Index: code/trunk/src/orxonox/objects/SpaceShip.cc
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShip.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/SpaceShip.cc	(revision 790)
@@ -0,0 +1,714 @@
+/*
+ *   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 "OrxonoxStableHeaders.h"
+
+#include <string>
+
+#include <OIS/OIS.h>
+#include <OgreCamera.h>
+#include <OgreRenderWindow.h>
+#include <OgreParticleSystem.h>
+#include <OgreSceneNode.h>
+
+#include "util/tinyxml/tinyxml.h"
+#include "util/String2Number.h"
+#include "util/Math.h"
+#include "../core/CoreIncludes.h"
+#include "../core/Debug.h"
+#include "../Orxonox.h"
+#include "../particle/ParticleInterface.h"
+#include "Projectile.h"
+
+#include "SpaceShip.h"
+
+namespace orxonox
+{
+    CreateFactory(SpaceShip);
+
+    SpaceShip::SpaceShip()
+    {
+        RegisterObject(SpaceShip);
+
+        this->setConfigValues();
+
+        this->setMouseEventCallback_ = false;
+        this->bLMousePressed_ = false;
+        this->bRMousePressed_ = false;
+        this->mouseX_ = 0;
+        this->mouseY_ = 0;
+
+        this->camNode_ = 0;
+
+        this->tt_ = 0;
+        this->redNode_ = 0;
+        this->greenNode_ = 0;
+        this->blinkTime_ = 0;
+
+        this->timeToReload_ = 0;
+
+        this->maxSpeed_ = 0;
+        this->maxSideAndBackSpeed_ = 0;
+        this->maxRotation_ = 0;
+        this->translationAcceleration_ = 0;
+        this->rotationAcceleration_ = 0;
+        this->translationDamping_ = 0;
+        this->rotationDamping_ = 0;
+
+        this->maxRotationRadian_ = 0;
+        this->rotationAccelerationRadian_ = 0;
+        this->rotationDampingRadian_ = 0;
+        this->zeroRadian_ = Radian(0);
+
+        this->setRotationAxis(1, 0, 0);
+        this->setStatic(false);
+/*
+        this->moveForward_ = 0;
+        this->rotateUp_ = 0;
+        this->rotateDown_ = 0;
+        this->rotateRight_ = 0;
+        this->rotateLeft_ = 0;
+        this->loopRight_ = 0;
+        this->loopLeft_ = 0;
+        this->brakeForward_ = 0;
+        this->brakeRotate_ = 0;
+        this->brakeLoop_ = 0;
+        this->speedForward_ = 0;
+        this->speedRotateUpDown_ = 0;
+        this->speedRotateRightLeft_ = 0;
+        this->speedLoopRightLeft_ = 0;
+        this->maxSpeedForward_ = 0;
+        this->maxSpeedRotateUpDown_ = 0;
+        this->maxSpeedRotateRightLeft_ = 0;
+        this->maxSpeedLoopRightLeft_ = 0;
+        this->accelerationForward_ = 0;
+        this->accelerationRotateUpDown_ = 0;
+        this->accelerationRotateRightLeft_ = 0;
+        this->accelerationLoopRightLeft_ = 0;
+
+        this->speed = 250;
+        this->loop = 100;
+        this->rotate = 10;
+        this->mouseX = 0;
+        this->mouseY = 0;
+        this->maxMouseX = 0;
+        this->minMouseX = 0;
+        this->moved = false;
+
+        this->brakeRotate(rotate*10);
+        this->brakeLoop(loop);
+*/
+        COUT(3) << "Info: SpaceShip was loaded" << std::endl;
+    }
+
+    SpaceShip::~SpaceShip()
+    {
+        if (this->tt_)
+            delete this->tt_;
+    }
+
+    void SpaceShip::setConfigValues()
+    {
+        SetConfigValue(bInvertYAxis_, false).description("Set this to true for joystick-like mouse behaviour (mouse up = ship down).");
+        SetConfigValue(reloadTime_, 0.125).description("The reload time of the weapon in seconds");
+        SetConfigValue(testvector_, Vector3()).description("asdfblah");
+    }
+
+    void SpaceShip::loadParams(TiXmlElement* xmlElem)
+    {
+        Model::loadParams(xmlElem);
+
+
+        // START CREATING THRUSTER
+        this->tt_ = new ParticleInterface(Orxonox::getSingleton()->getSceneManager(),"twinthruster" + this->getName(),"Orxonox/engineglow");
+        this->tt_->getParticleSystem()->setParameter("local_space","true");
+        this->tt_->newEmitter();
+/*
+        this->tt_->setDirection(Vector3(0,0,1));
+        this->tt_->setPositionOfEmitter(0, Vector3(20,-1,-15));
+        this->tt_->setPositionOfEmitter(1, Vector3(-20,-1,-15));
+*/
+        this->tt_->setDirection(Vector3(-1,0,0));
+        this->tt_->setPositionOfEmitter(0, Vector3(-15,20,-1));
+        this->tt_->setPositionOfEmitter(1, Vector3(-15,-20,-1));
+        this->tt_->setVelocity(50);
+
+        emitterRate_ = tt_->getRate();
+
+        Ogre::SceneNode* node2 = this->getNode()->createChildSceneNode(this->getName() + "particle2");
+        node2->setInheritScale(false);
+        tt_->addToSceneNode(node2);
+        // END CREATING THRUSTER
+
+        // START CREATING BLINKING LIGHTS
+        this->redBillboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+        this->greenBillboard_.setBillboardSet("Examples/Flare", ColourValue(0.0, 1.0, 0.0), 1);
+
+        this->redNode_ = this->getNode()->createChildSceneNode(this->getName() + "red", Vector3(0.3, 4.7, -0.3));
+        this->redNode_->setInheritScale(false);
+        this->greenNode_ = this->getNode()->createChildSceneNode(this->getName() + "green", Vector3(0.3, -4.7, -0.3));
+        this->greenNode_->setInheritScale(false);
+
+        this->redNode_->attachObject(this->redBillboard_.getBillboardSet());
+        this->redNode_->setScale(0.3, 0.3, 0.3);
+
+        this->greenNode_->attachObject(this->greenBillboard_.getBillboardSet());
+        this->greenNode_->setScale(0.3, 0.3, 0.3);
+        // END CREATING BLINKING LIGHTS
+
+        // START of testing crosshair
+        this->crosshairNear_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+        this->crosshairFar_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+
+        this->chNearNode_ = this->getNode()->createChildSceneNode(this->getName() + "near", Vector3(50.0, 0.0, 0.0));
+        this->chNearNode_->setInheritScale(false);
+        this->chFarNode_ = this->getNode()->createChildSceneNode(this->getName() + "far", Vector3(200.0, 0.0, 0.0));
+        this->chFarNode_->setInheritScale(false);
+
+        this->chNearNode_->attachObject(this->crosshairNear_.getBillboardSet());
+        this->chNearNode_->setScale(0.2, 0.2, 0.2);
+
+        this->chFarNode_->attachObject(this->crosshairFar_.getBillboardSet());
+        this->chFarNode_->setScale(0.4, 0.4, 0.4);
+
+        // END of testing crosshair
+
+/*
+        if (xmlElem->Attribute("forward") && xmlElem->Attribute("rotateupdown") && xmlElem->Attribute("rotaterightleft") && xmlElem->Attribute("looprightleft"))
+        {
+            std::string forwardStr = xmlElem->Attribute("forward");
+            std::string rotateupdownStr = xmlElem->Attribute("rotateupdown");
+            std::string rotaterightleftStr = xmlElem->Attribute("rotaterightleft");
+            std::string looprightleftStr = xmlElem->Attribute("looprightleft");
+
+            String2Number<float>(this->maxSpeedForward_, forwardStr);
+            String2Number<float>(this->maxSpeedRotateUpDown_, rotateupdownStr);
+            String2Number<float>(this->maxSpeedRotateRightLeft_, rotaterightleftStr);
+            String2Number<float>(this->maxSpeedLoopRightLeft_, looprightleftStr);
+
+            COUT(4) << "Loader: Initialized spaceship steering with values " << maxSpeedForward_ << " " << maxSpeedRotateUpDown_ << " " << maxSpeedRotateRightLeft_ << " " << maxSpeedLoopRightLeft_ << " " << std::endl;
+    	}
+*/
+        if (xmlElem->Attribute("maxSpeed") && xmlElem->Attribute("maxSideAndBackSpeed") && xmlElem->Attribute("maxRotation") && xmlElem->Attribute("transAcc") && xmlElem->Attribute("rotAcc") && xmlElem->Attribute("transDamp") && xmlElem->Attribute("rotDamp"))
+        {
+
+            std::string msStr = xmlElem->Attribute("maxSpeed");
+            std::string msabsStr = xmlElem->Attribute("maxSideAndBackSpeed");
+            std::string mrStr = xmlElem->Attribute("maxRotation");
+            std::string taStr = xmlElem->Attribute("transAcc");
+            std::string raStr = xmlElem->Attribute("rotAcc");
+            std::string tdStr = xmlElem->Attribute("transDamp");
+            std::string rdStr = xmlElem->Attribute("rotDamp");
+
+            String2Number<float>(this->maxSpeed_, msStr);
+            String2Number<float>(this->maxSideAndBackSpeed_, msabsStr);
+            String2Number<float>(this->maxRotation_, mrStr);
+            String2Number<float>(this->translationAcceleration_, taStr);
+            String2Number<float>(this->rotationAcceleration_, raStr);
+            String2Number<float>(this->translationDamping_, tdStr);
+            String2Number<float>(this->rotationDamping_, rdStr);
+
+            this->maxRotationRadian_ = Radian(this->maxRotation_);
+            this->rotationAccelerationRadian_ = Radian(this->rotationAcceleration_);
+            this->rotationDampingRadian_ = Radian(this->rotationDamping_);
+
+            COUT(4) << "Loader: Initialized SpaceShip" << std::endl;
+    	}
+
+    	if (xmlElem->Attribute("camera"))
+    	{
+            Ogre::Camera *cam = Orxonox::getSingleton()->getSceneManager()->createCamera("ShipCam");
+            this->camNode_ = this->getNode()->createChildSceneNode("CamNode");
+/*
+//            node->setInheritOrientation(false);
+            cam->setPosition(Vector3(0,50,-150));
+            cam->lookAt(Vector3(0,20,0));
+            cam->roll(Degree(0));
+*/
+
+            cam->setPosition(Vector3(-200,0,35));
+//            cam->setPosition(Vector3(0,-350,0));
+            cam->lookAt(Vector3(0,0,35));
+            cam->roll(Degree(-90));
+
+            this->camNode_->attachObject(cam);
+            Orxonox::getSingleton()->getOgrePointer()->getRoot()->getAutoCreatedWindow()->addViewport(cam);
+    	}
+    }
+
+    int sgn(float x)
+    {
+        if (x >= 0)
+            return 1;
+        else
+            return -1;
+    }
+
+    bool SpaceShip::mouseMoved(const OIS::MouseEvent &e)
+    {
+/*
+        this->mouseX += e.state.X.rel;
+        if (this->bInvertMouse_)
+            this->mouseY += e.state.Y.rel;
+        else
+            this->mouseY -= e.state.Y.rel;
+
+//        if(mouseX>maxMouseX) maxMouseX = mouseX;
+//        if(mouseX<minMouseX) minMouseX = mouseX;
+//        cout << "mouseX: " << mouseX << "\tmouseY: " << mouseY << endl;
+
+        this->moved = true;
+*/
+        if (this->bRMousePressed_)
+        {
+            this->camNode_->roll(Degree(-e.state.X.rel * 0.10));
+            this->camNode_->yaw(Degree(e.state.Y.rel * 0.10));
+        }
+        else
+        {
+            float minDimension = e.state.height;
+            if (e.state.width < minDimension)
+                minDimension = e.state.width;
+
+            this->mouseX_ += e.state.X.rel;
+            if (this->mouseX_ < -minDimension)
+                this->mouseX_ = -minDimension;
+            if (this->mouseX_ > minDimension)
+                this->mouseX_ = minDimension;
+
+            this->mouseY_ += e.state.Y.rel;
+            if (this->mouseY_ < -minDimension)
+                this->mouseY_ = -minDimension;
+            if (this->mouseY_ > minDimension)
+                this->mouseY_ = minDimension;
+
+            float xRotation = this->mouseX_ / minDimension;
+            xRotation = xRotation*xRotation * sgn(xRotation);
+            xRotation *= -this->rotationAcceleration_;
+            if (xRotation > this->maxRotation_)
+                xRotation = this->maxRotation_;
+            if (xRotation < -this->maxRotation_)
+                xRotation = -this->maxRotation_;
+            this->mouseXRotation_ = Radian(xRotation);
+
+            float yRotation = this->mouseY_ / minDimension;
+            yRotation = yRotation*yRotation * sgn(yRotation);
+            yRotation *= this->rotationAcceleration_;
+            if (yRotation > this->maxRotation_)
+                yRotation = this->maxRotation_;
+            if (yRotation < -this->maxRotation_)
+                yRotation = -this->maxRotation_;
+            this->mouseYRotation_ = Radian(yRotation);
+        }
+
+        return true;
+    }
+
+    bool SpaceShip::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        if (id == OIS::MB_Left)
+            this->bLMousePressed_ = true;
+        else if (id == OIS::MB_Right)
+            this->bRMousePressed_ = true;
+
+        return true;
+    }
+
+    bool SpaceShip::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        if (id == OIS::MB_Left)
+            this->bLMousePressed_ = false;
+        else if (id == OIS::MB_Right)
+        {
+            this->bRMousePressed_ = false;
+            this->camNode_->resetOrientation();
+        }
+
+        return true;
+    }
+
+    void SpaceShip::tick(float dt)
+    {
+        if (!this->setMouseEventCallback_)
+        {
+            if (Orxonox::getSingleton()->getMouse())
+            {
+                Orxonox::getSingleton()->getMouse()->setEventCallback(this);
+                this->setMouseEventCallback_ = true;
+            }
+        }
+
+        if (this->redNode_ && this->greenNode_)
+        {
+            this->blinkTime_ += dt;
+            float redScale = 0.15 + 0.15 * sin(this->blinkTime_ * 10.0);
+            float greenScale = 0.15 - 0.15 * sin(this->blinkTime_ * 10.0);
+            this->redNode_->setScale(redScale, redScale, redScale);
+            this->greenNode_->setScale(greenScale, greenScale, greenScale);
+        }
+
+        if (this->timeToReload_ > 0)
+            this->timeToReload_ -= dt;
+        else
+            this->timeToReload_ = 0;
+
+        if (this->bLMousePressed_ && this->timeToReload_ <= 0)
+        {
+            new Projectile(this);
+            this->timeToReload_ = this->reloadTime_;
+        }
+
+        OIS::Keyboard* mKeyboard = Orxonox::getSingleton()->getKeyboard();
+        OIS::Mouse* mMouse = Orxonox::getSingleton()->getMouse();
+
+        mKeyboard->capture();
+        mMouse->capture();
+
+
+        // #####################################
+        // ############# STEERING ##############
+        // #####################################
+
+        if (this->velocity_.x > this->maxSpeed_)
+            this->velocity_.x = this->maxSpeed_;
+        if (this->velocity_.x < -this->maxSideAndBackSpeed_)
+            this->velocity_.x = -this->maxSideAndBackSpeed_;
+        if (this->velocity_.y > this->maxSideAndBackSpeed_)
+            this->velocity_.y = this->maxSideAndBackSpeed_;
+        if (this->velocity_.y < -this->maxSideAndBackSpeed_)
+            this->velocity_.y = -this->maxSideAndBackSpeed_;
+        if (this->rotationRate_ > this->maxRotationRadian_)
+            this->rotationRate_ = this->maxRotationRadian_;
+        if (this->rotationRate_ < -this->maxRotationRadian_)
+            this->rotationRate_ = -this->maxRotationRadian_;
+
+        if (this->acceleration_.x == 0)
+        {
+            if (this->velocity_.x > 0)
+            {
+                this->velocity_.x -= (this->translationDamping_ * dt);
+                if (this->velocity_.x < 0)
+                    this->velocity_.x = 0;
+            }
+            else if (this->velocity_.x < 0)
+            {
+                this->velocity_.x += (this->translationDamping_ * dt);
+                if (this->velocity_.x > 0)
+                    this->velocity_.x = 0;
+            }
+        }
+
+        if (this->acceleration_.y == 0)
+        {
+            if (this->velocity_.y > 0)
+            {
+                this->velocity_.y -= (this->translationDamping_ * dt);
+                if (this->velocity_.y < 0)
+                    this->velocity_.y = 0;
+            }
+            else if (this->velocity_.y < 0)
+            {
+                this->velocity_.y += (this->translationDamping_ * dt);
+                if (this->velocity_.y > 0)
+                    this->velocity_.y = 0;
+            }
+        }
+
+        if (this->momentum_ == this->zeroRadian_)
+        {
+            if (this->rotationRate_ > this->zeroRadian_)
+            {
+                this->rotationRate_ -= (this->rotationDampingRadian_ * dt);
+                if (this->rotationRate_ < this->zeroRadian_)
+                    this->rotationRate_ = 0;
+            }
+            else if (this->rotationRate_ < this->zeroRadian_)
+            {
+                this->rotationRate_ += (this->rotationDampingRadian_ * dt);
+                if (this->rotationRate_ > this->zeroRadian_)
+                    this->rotationRate_ = 0;
+            }
+        }
+
+        if (mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W))
+            this->acceleration_.x = this->translationAcceleration_;
+        else if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S))
+            this->acceleration_.x = -this->translationAcceleration_;
+        else
+            this->acceleration_.x = 0;
+
+        if (mKeyboard->isKeyDown(OIS::KC_RIGHT) || mKeyboard->isKeyDown(OIS::KC_D))
+            this->acceleration_.y = -this->translationAcceleration_;
+        else if (mKeyboard->isKeyDown(OIS::KC_LEFT) || mKeyboard->isKeyDown(OIS::KC_A))
+            this->acceleration_.y = this->translationAcceleration_;
+        else
+            this->acceleration_.y = 0;
+
+        if (mKeyboard->isKeyDown(OIS::KC_DELETE) || mKeyboard->isKeyDown(OIS::KC_Q))
+            this->momentum_ = Radian(-this->rotationAccelerationRadian_);
+        else if (mKeyboard->isKeyDown(OIS::KC_PGDOWN) || mKeyboard->isKeyDown(OIS::KC_E))
+            this->momentum_ = Radian(this->rotationAccelerationRadian_);
+        else
+            this->momentum_ = 0;
+
+        WorldEntity::tick(dt);
+
+        this->roll(this->mouseXRotation_ * dt);
+        if (this->bInvertYAxis_)
+            this->yaw(Radian(-this->mouseYRotation_ * dt));
+        else
+            this->yaw(Radian(this->mouseYRotation_ * dt));
+
+        if (this->acceleration_.x > 0)
+            this->tt_->setRate(emitterRate_);
+        else
+            this->tt_->setRate(0);
+
+/*
+        if (mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W))
+            this->moveForward(speed);
+        else
+            this->moveForward(0);
+
+        if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S))
+            this->brakeForward(speed);
+        else
+            this->brakeForward(speed/10);
+
+        if (mKeyboard->isKeyDown(OIS::KC_RIGHT) || mKeyboard->isKeyDown(OIS::KC_D))
+            this->loopRight(loop);
+        else
+            this->loopRight(0);
+
+        if (mKeyboard->isKeyDown(OIS::KC_LEFT) || mKeyboard->isKeyDown(OIS::KC_A))
+            this->loopLeft(loop);
+        else
+            this->loopLeft(0);
+
+        if(moved)
+        {
+            if (mouseY<=0)
+                this->rotateUp(-mouseY*rotate);
+            if (mouseY>0)
+                this->rotateDown(mouseY*rotate);
+            if (mouseX>0)
+                this->rotateRight(mouseX*rotate);
+            if (mouseX<=0)
+                this->rotateLeft(-mouseX*rotate);
+
+            mouseY = 0;
+            mouseX = 0;
+            moved = false;
+        }*/
+/*        else
+        {
+            this->rotateUp(0);
+            this->rotateDown(0);
+            this->rotateRight(0);
+            this->rotateLeft(0);
+        }*/
+/*
+        if(moveForward_ > 0)
+        {
+            accelerationForward_ = moveForward_;
+            if(speedForward_ < maxSpeedForward_)
+                speedForward_ += accelerationForward_*dt;
+            if(speedForward_ > maxSpeedForward_)
+                speedForward_ = maxSpeedForward_;
+        }
+
+        if(moveForward_ <= 0)
+        {
+            accelerationForward_ = -brakeForward_;
+            if(speedForward_ > 0)
+                speedForward_ += accelerationForward_*dt;
+            if(speedForward_ < 0)
+                speedForward_ = 0;
+        }
+
+        if(rotateUp_ > 0)
+        {
+            accelerationRotateUpDown_ = rotateUp_;
+            if(speedRotateUpDown_ < maxSpeedRotateUpDown_)
+                speedRotateUpDown_ += accelerationRotateUpDown_*dt;
+            if(speedRotateUpDown_ > maxSpeedRotateUpDown_)
+            speedRotateUpDown_ = maxSpeedRotateUpDown_;
+        }
+
+        if(rotateDown_ > 0)
+        {
+            accelerationRotateUpDown_ = rotateDown_;
+            if(speedRotateUpDown_ > -maxSpeedRotateUpDown_)
+                speedRotateUpDown_ -= accelerationRotateUpDown_*dt;
+            if(speedRotateUpDown_ < -maxSpeedRotateUpDown_)
+                speedRotateUpDown_ = -maxSpeedRotateUpDown_;
+        }
+
+        if(rotateUp_ == 0 && rotateDown_ == 0)
+        {
+            accelerationRotateUpDown_ = brakeRotate_;
+            if(speedRotateUpDown_ > 0)
+                speedRotateUpDown_ -= accelerationRotateUpDown_*dt;
+            if(speedRotateUpDown_ < 0)
+                speedRotateUpDown_ += accelerationRotateUpDown_*dt;
+            if(fabs(speedRotateUpDown_) < accelerationRotateUpDown_*dt)
+                speedRotateUpDown_ = 0;
+        }
+
+        if(rotateRight_ > 0)
+        {
+            accelerationRotateRightLeft_ = rotateRight_;
+            if(speedRotateRightLeft_ > -maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ -= accelerationRotateRightLeft_*dt;
+            if(speedRotateRightLeft_ < -maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ = -maxSpeedRotateRightLeft_;
+        }
+
+        if(rotateLeft_ > 0)
+        {
+            accelerationRotateRightLeft_ = rotateLeft_;
+            if(speedRotateRightLeft_ < maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ += accelerationRotateRightLeft_*dt;
+            if(speedRotateRightLeft_ > maxSpeedRotateRightLeft_)
+                speedRotateRightLeft_ = maxSpeedRotateRightLeft_;
+        }
+
+        if(rotateRight_ == 0 && rotateLeft_ == 0)
+        {
+            accelerationRotateRightLeft_ = brakeRotate_;
+            if(speedRotateRightLeft_ > 0)
+                speedRotateRightLeft_ -= accelerationRotateRightLeft_*dt;
+            if(speedRotateRightLeft_ < 0)
+                speedRotateRightLeft_ += accelerationRotateRightLeft_*dt;
+            if(fabs(speedRotateRightLeft_) < accelerationRotateRightLeft_*dt)
+                speedRotateRightLeft_ = 0;
+        }
+
+        if(loopRight_ > 0)
+        {
+            accelerationLoopRightLeft_ = loopRight_;
+            if(speedLoopRightLeft_ < maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ += accelerationLoopRightLeft_*dt;
+            if(speedLoopRightLeft_ > maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ = maxSpeedLoopRightLeft_;
+        }
+
+        if(loopLeft_ > 0)
+        {
+            accelerationLoopRightLeft_ = loopLeft_;
+            if(speedLoopRightLeft_ > -maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ -= accelerationLoopRightLeft_*dt;
+            if(speedLoopRightLeft_ < -maxSpeedLoopRightLeft_)
+                speedLoopRightLeft_ = -maxSpeedLoopRightLeft_;
+        }
+
+        if(loopLeft_ == 0 && loopRight_ == 0)
+        {
+            accelerationLoopRightLeft_ = brakeLoop_;
+            if(speedLoopRightLeft_ > 0)
+                speedLoopRightLeft_ -= accelerationLoopRightLeft_*dt;
+            if(speedLoopRightLeft_ < 0)
+                speedLoopRightLeft_ += accelerationLoopRightLeft_*dt;
+            if(fabs(speedLoopRightLeft_) < accelerationLoopRightLeft_*dt)
+                speedLoopRightLeft_ = 0;
+        }
+
+        Vector3 transVector = Vector3::ZERO;
+*/
+/*
+        transVector.z = 1;
+        this->translate(transVector*speedForward_*dt, Ogre::Node::TS_LOCAL);
+        this->pitch(Degree(speedRotateUpDown_*dt), Ogre::Node::TS_LOCAL);
+        this->yaw(Degree(speedRotateRightLeft_*dt), Ogre::Node::TS_LOCAL);
+        this->roll(Degree(speedLoopRightLeft_*dt), Ogre::Node::TS_LOCAL);
+*/
+/*
+        transVector.x = 1;
+        this->translate(transVector*speedForward_*dt, Ogre::Node::TS_LOCAL);
+        this->yaw(Degree(speedRotateUpDown_*dt), Ogre::Node::TS_LOCAL);
+        this->roll(Degree(speedRotateRightLeft_*dt), Ogre::Node::TS_LOCAL);
+        this->pitch(Degree(speedLoopRightLeft_*dt), Ogre::Node::TS_LOCAL);
+*/
+    }
+/*
+    void SpaceShip::moveForward(float moveForward) {
+        moveForward_ = moveForward;
+    }
+
+    void SpaceShip::rotateUp(float rotateUp) {
+        rotateUp_ = rotateUp;
+    }
+
+    void SpaceShip::rotateDown(float rotateDown) {
+        rotateDown_ = rotateDown;
+    }
+
+    void SpaceShip::rotateLeft(float rotateLeft) {
+        rotateLeft_ = rotateLeft;
+    }
+
+    void SpaceShip::rotateRight(float rotateRight) {
+        rotateRight_ = rotateRight;
+    }
+
+    void SpaceShip::loopLeft(float loopLeft) {
+        loopLeft_ = loopLeft;
+    }
+
+    void SpaceShip::loopRight(float loopRight) {
+        loopRight_ = loopRight;
+    }
+
+    void SpaceShip::brakeForward(float brakeForward) {
+        brakeForward_ = brakeForward;
+    }
+
+    void SpaceShip::brakeRotate(float brakeRotate) {
+        brakeRotate_ = brakeRotate;
+    }
+
+    void SpaceShip::brakeLoop(float brakeLoop) {
+        brakeLoop_ = brakeLoop;
+    }
+
+    void SpaceShip::maxSpeedForward(float maxSpeedForward) {
+        maxSpeedForward_ = maxSpeedForward;
+    }
+
+    void SpaceShip::maxSpeedRotateUpDown(float maxSpeedRotateUpDown) {
+        maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
+    }
+
+    void SpaceShip::maxSpeedRotateRightLeft(float maxSpeedRotateRightLeft) {
+        maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
+    }
+
+    void SpaceShip::maxSpeedLoopRightLeft(float maxSpeedLoopRightLeft) {
+        maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
+    }
+*/
+}
Index: code/trunk/src/orxonox/objects/SpaceShip.h
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShip.h	(revision 790)
+++ code/trunk/src/orxonox/objects/SpaceShip.h	(revision 790)
@@ -0,0 +1,80 @@
+#ifndef _SpaceShip_H__
+#define _SpaceShip_H__
+
+#include <OgrePrerequisites.h>
+#include <OIS/OISMouse.h>
+
+#include "../OrxonoxPrereqs.h"
+
+#include "Model.h"
+#include "../tools/BillboardSet.h"
+
+class TiXmlElement;          // Forward declaration
+
+namespace orxonox
+{
+    class ParticleInterface; // Forward declaration
+
+    class _OrxonoxExport SpaceShip : public Model, public OIS::MouseListener
+    {
+        public:
+            SpaceShip();
+            ~SpaceShip();
+            void setConfigValues();
+            virtual void loadParams(TiXmlElement* xmlElem);
+            virtual void tick(float dt);
+
+            bool mouseMoved(const OIS::MouseEvent &e);
+            bool mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id);
+            bool mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id);
+
+
+        private:
+            Vector3 testvector_;
+            bool bInvertYAxis_;
+            bool setMouseEventCallback_;
+            bool bLMousePressed_;
+            bool bRMousePressed_;
+
+            Ogre::SceneNode* camNode_;
+
+            ParticleInterface* tt_;
+
+            BillboardSet redBillboard_;
+            BillboardSet greenBillboard_;
+            Ogre::SceneNode* redNode_;
+            Ogre::SceneNode* greenNode_;
+            float blinkTime_;
+
+            BillboardSet crosshairNear_;
+            BillboardSet crosshairFar_;
+            Ogre::SceneNode* chNearNode_;
+            Ogre::SceneNode* chFarNode_;
+
+            float timeToReload_;
+            float reloadTime_;
+
+            float maxSideAndBackSpeed_;
+            float maxSpeed_;
+            float maxRotation_;
+            float translationAcceleration_;
+            float rotationAcceleration_;
+            float translationDamping_;
+            float rotationDamping_;
+
+            Radian maxRotationRadian_;
+            Radian rotationAccelerationRadian_;
+            Radian rotationDampingRadian_;
+            Radian zeroRadian_;
+            Radian mouseXRotation_;
+            Radian mouseYRotation_;
+
+            float mouseX_;
+            float mouseY_;
+
+            int emitterRate_;
+    };
+    ExportClass(SpaceShip, Orxonox);
+}
+
+#endif /* _SpaceShip_H__ */
Index: code/trunk/src/orxonox/objects/SpaceshipSteeringObject.cc
===================================================================
--- code/trunk/src/orxonox/objects/SpaceshipSteeringObject.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/SpaceshipSteeringObject.cc	(revision 790)
@@ -0,0 +1,92 @@
+/*
+ *   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:
+ *      ...
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+#include <OgreRoot.h>
+#include <OgreRenderWindow.h>
+
+#include <string>
+
+#include "../Orxonox.h"
+#include "../GraphicsEngine.h"
+#include "util/tinyxml/tinyxml.h"
+#include "util/Tokenizer.h"
+#include "util/String2Number.h"
+#include "../core/Debug.h"
+
+#include "SpaceshipSteeringObject.h"
+
+#include "../SpaceshipSteering.h"
+
+namespace orxonox
+{
+    CreateFactory(SpaceshipSteeringObject);
+
+    SpaceshipSteeringObject::SpaceshipSteeringObject()
+    {
+        RegisterObject(SpaceshipSteeringObject);
+    }
+
+    SpaceshipSteeringObject::~SpaceshipSteeringObject()
+    {
+    }
+
+    void SpaceshipSteeringObject::loadParams(TiXmlElement* xmlElem)
+    {
+      SpaceshipSteering* steering = orxonox::Orxonox::getSingleton()->getSteeringPointer();
+
+      if (xmlElem->Attribute("node") && xmlElem->Attribute("forward") && xmlElem->Attribute("rotateupdown") && xmlElem->Attribute("rotaterightleft") && xmlElem->Attribute("looprightleft"))
+      {
+        std::string nodeStr = xmlElem->Attribute("node");
+        std::string forwardStr = xmlElem->Attribute("forward");
+        std::string rotateupdownStr = xmlElem->Attribute("rotateupdown");
+        std::string rotaterightleftStr = xmlElem->Attribute("rotaterightleft");
+        std::string looprightleftStr = xmlElem->Attribute("looprightleft");
+
+        float forward, rotateupdown, rotaterightleft, looprightleft;
+        String2Number<float>(forward, forwardStr);
+        String2Number<float>(rotateupdown, rotateupdownStr);
+        String2Number<float>(rotaterightleft, rotaterightleftStr);
+        String2Number<float>(looprightleft, looprightleftStr);
+
+        steering = new SpaceshipSteering(forward, rotateupdown, rotaterightleft, looprightleft);
+
+        Ogre::SceneManager* mgr = orxonox::Orxonox::getSingleton()->getSceneManager();
+        Ogre::SceneNode* sceneNode = (Ogre::SceneNode*)mgr->getRootSceneNode()->getChild(nodeStr);
+
+        steering->addNode(sceneNode);
+
+
+
+
+        COUT(4) << "Loader: Initialized spaceship steering at node " << nodeStr << " values "<< forward << " " << rotateupdown << " "<< rotaterightleft << " "<< looprightleft << " "<< std::endl << std::endl;
+      }
+   }
+}
Index: code/trunk/src/orxonox/objects/SpaceshipSteeringObject.h
===================================================================
--- code/trunk/src/orxonox/objects/SpaceshipSteeringObject.h	(revision 790)
+++ code/trunk/src/orxonox/objects/SpaceshipSteeringObject.h	(revision 790)
@@ -0,0 +1,24 @@
+#ifndef _OBJECT_SPACESHIPSTEERING_H__
+#define _OBJECT_SPACESHIPSTEERING_H__
+
+#include "core/BaseObject.h"
+#include "util/tinyxml/tinyxml.h"
+
+namespace orxonox
+{
+    class SpaceshipSteeringObject : public BaseObject
+    {
+        public:
+            SpaceshipSteeringObject();
+            virtual ~SpaceshipSteeringObject();
+
+
+            void loadParams(TiXmlElement* xmlElem);
+
+        private:
+
+
+    };
+}
+
+#endif
Index: code/trunk/src/orxonox/objects/Test.h
===================================================================
--- code/trunk/src/orxonox/objects/Test.h	(revision 258)
+++ code/trunk/src/orxonox/objects/Test.h	(revision 790)
@@ -1,7 +1,34 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
 #ifndef _Test_H__
 #define _Test_H__
 
-#include "BaseObject.h"
-#include "../core/IdentifierIncludes.h"
+#include "core/BaseObject.h"
+#include "../core/CoreIncludes.h"
 
 namespace orxonox
Index: code/trunk/src/orxonox/objects/Tickable.h
===================================================================
--- code/trunk/src/orxonox/objects/Tickable.h	(revision 790)
+++ code/trunk/src/orxonox/objects/Tickable.h	(revision 790)
@@ -0,0 +1,87 @@
+/*
+ *   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:
+ *      ...
+ *
+ */
+
+/*!
+    @file Tickable.h
+    @brief Definition of the Tickable interface.
+
+    The Tickable interface provides a tick(dt) function, that gets called every frame.
+    float dt is the time since the last frame in seconds.
+
+    Attention:
+    Classes derived from a Tickable that want to have a tick(dt) function on their part, MUST call the
+    parent::tick(dt) function explicit in their implementation of tick(dt) because it's a virtual function.
+*/
+
+#ifndef _Tickable_H__
+#define _Tickable_H__
+
+#include <OgreFrameListener.h>
+
+#include "../OrxonoxPrereqs.h"
+
+#include "../core/CoreIncludes.h"
+
+namespace orxonox
+{
+    class TickFrameListener; // Forward declaration
+
+    //! The Tickable interface provides a tick(dt) function, that gets called every frame.
+    class _OrxonoxExport Tickable : virtual public OrxonoxClass
+    {
+        public:
+            /**
+                @brief Gets called every frame.
+                @param dt The time since the last frame in seconds
+            */
+            virtual void tick(float dt) = 0;
+
+        protected:
+            /**
+                @brief Constructor: Registers the object in the Tickable-list
+            */
+            Tickable() { RegisterRootObject(Tickable); }
+    };
+    ExportAbstractClass(Tickable, Orxonox);
+
+    //! The TickFrameListener calls the tick(dt) function of all Tickables every frame.
+    class _OrxonoxExport TickFrameListener : public Ogre::FrameListener
+    {
+        private:
+            /** @brief Gets called before a frame gets rendered. */
+            bool frameStarted(const Ogre::FrameEvent &evt)
+            {
+                // Iterate through all Tickables and call their tick(dt) function
+                for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; )
+                    (it++)->tick(evt.timeSinceLastFrame);
+
+                return FrameListener::frameStarted(evt);
+            }
+    };
+}
+
+#endif /* _Tickable_H__ */
Index: code/trunk/src/orxonox/objects/WorldEntity.cc
===================================================================
--- code/trunk/src/orxonox/objects/WorldEntity.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/WorldEntity.cc	(revision 790)
@@ -0,0 +1,185 @@
+/*
+ *   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 "OrxonoxStableHeaders.h"
+
+#include <string>
+#include <sstream>
+
+#include "util/tinyxml/tinyxml.h"
+#include "util/Tokenizer.h"
+#include "util/String2Number.h"
+#include "../core/CoreIncludes.h"
+#include "../Orxonox.h"
+#include "WorldEntity.h"
+
+namespace orxonox
+{
+    CreateFactory(WorldEntity);
+
+    unsigned int WorldEntity::worldEntityCounter_s = 0;
+
+    WorldEntity::WorldEntity()
+    {
+        RegisterObject(WorldEntity);
+
+        if (Orxonox::getSingleton()->getSceneManager())
+        {
+            std::ostringstream name;
+            name << (WorldEntity::worldEntityCounter_s++);
+            this->setName("WorldEntity" + name.str());
+            this->node_ = Orxonox::getSingleton()->getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
+        }
+        else
+        {
+            this->node_ = 0;
+        }
+
+        this->bStatic_ = true;
+        this->velocity_ = Vector3(0, 0, 0);
+        this->acceleration_ = Vector3(0, 0, 0);
+        this->rotationAxis_ = Vector3(0, 1, 0);
+        this->rotationRate_ = 0;
+        this->momentum_ = 0;
+    }
+
+    WorldEntity::~WorldEntity()
+    {
+    }
+
+    void WorldEntity::tick(float dt)
+    {
+        if (!this->bStatic_)
+        {
+            this->velocity_ += (dt * this->acceleration_);
+            this->translate(dt * this->velocity_, Ogre::Node::TS_LOCAL);
+
+            this->rotationRate_ += (dt * this->momentum_);
+            this->rotate(this->rotationAxis_, dt * this->rotationRate_);
+        }
+    }
+
+    void WorldEntity::loadParams(TiXmlElement* xmlElem)
+    {
+        BaseObject::loadParams(xmlElem);
+
+        if (xmlElem->Attribute("position"))
+        {
+            std::vector<std::string> pos = tokenize(xmlElem->Attribute("position"),",");
+            float x, y, z;
+            String2Number<float>(x, pos[0]);
+            String2Number<float>(y, pos[1]);
+            String2Number<float>(z, pos[2]);
+            this->setPosition(x, y, z);
+        }
+
+        if (xmlElem->Attribute("direction"))
+        {
+            std::vector<std::string> pos = tokenize(xmlElem->Attribute("direction"),",");
+            float x, y, z;
+            String2Number<float>(x, pos[0]);
+            String2Number<float>(y, pos[1]);
+            String2Number<float>(z, pos[2]);
+            this->setDirection(x, y, z);
+        }
+
+        if (xmlElem->Attribute("yaw") || xmlElem->Attribute("pitch") || xmlElem->Attribute("roll"))
+        {
+            float yaw = 0.0, pitch = 0.0, roll = 0.0;
+            if (xmlElem->Attribute("yaw"))
+                String2Number<float>(yaw,xmlElem->Attribute("yaw"));
+
+            if (xmlElem->Attribute("pitch"))
+                String2Number<float>(pitch,xmlElem->Attribute("pitch"));
+
+            if (xmlElem->Attribute("roll"))
+                String2Number<float>(roll,xmlElem->Attribute("roll"));
+
+            this->yaw(Degree(yaw));
+            this->pitch(Degree(pitch));
+            this->roll(Degree(roll));
+        }
+
+        if (xmlElem->Attribute("scale"))
+        {
+            std::string scaleStr = xmlElem->Attribute("scale");
+            float scale;
+            String2Number<float>(scale, scaleStr);
+            this->setScale(scale);
+        }
+
+        if (xmlElem->Attribute("rotationAxis"))
+        {
+            std::vector<std::string> pos = tokenize(xmlElem->Attribute("rotationAxis"),",");
+            float x, y, z;
+            String2Number<float>(x, pos[0]);
+            String2Number<float>(y, pos[1]);
+            String2Number<float>(z, pos[2]);
+            this->setRotationAxis(x, y, z);
+        }
+
+        if (xmlElem->Attribute("rotationRate"))
+        {
+            float rotationRate;
+            String2Number<float>(rotationRate, xmlElem->Attribute("rotationRate"));
+            this->setRotationRate(Degree(rotationRate));
+            if (rotationRate != 0)
+                this->setStatic(false);
+        }
+
+        create();
+
+    }
+
+    bool WorldEntity::create(){
+      registerAllVariables();
+      return true;
+    }
+
+    void WorldEntity::registerAllVariables()
+    {
+      // register coordinates
+      registerVar( (void*) &(this->getPosition().x), sizeof(this->getPosition().x), network::DATA);
+      registerVar( (void*) &(this->getPosition().y), sizeof(this->getPosition().y), network::DATA);
+      registerVar( (void*) &(this->getPosition().z), sizeof(this->getPosition().z), network::DATA);
+      // register orientation
+      registerVar( (void*) &(this->getOrientation().w), sizeof(this->getOrientation().w), network::DATA);
+      registerVar( (void*) &(this->getOrientation().x), sizeof(this->getOrientation().x), network::DATA);
+      registerVar( (void*) &(this->getOrientation().y), sizeof(this->getOrientation().y), network::DATA);
+      registerVar( (void*) &(this->getOrientation().z), sizeof(this->getOrientation().z), network::DATA);
+      // not needed at the moment, because we don't have prediction yet
+      /*// register velocity_
+      registerVar( (void*) &(this->getVelocity().x), sizeof(this->getVelocity().x), network::DATA);
+      registerVar( (void*) &(this->getVelocity().y), sizeof(this->getVelocity().y), network::DATA);
+      registerVar( (void*) &(this->getVelocity().z), sizeof(this->getVelocity().z), network::DATA);
+      // register rotationAxis/rate
+      registerVar( (void*) &(this->getRotationRate()), sizeof(this->getRotationRate()), network::DATA);
+      registerVar( (void*) &(this->getRotationAxis().x), sizeof(this->getRotationAxis().x), network::DATA);
+      registerVar( (void*) &(this->getRotationAxis().y), sizeof(this->getRotationAxis().y), network::DATA);
+      registerVar( (void*) &(this->getRotationAxis().z), sizeof(this->getRotationAxis().z), network::DATA);*/
+    }
+}
Index: code/trunk/src/orxonox/objects/WorldEntity.h
===================================================================
--- code/trunk/src/orxonox/objects/WorldEntity.h	(revision 790)
+++ code/trunk/src/orxonox/objects/WorldEntity.h	(revision 790)
@@ -0,0 +1,152 @@
+#ifndef _WorldEntity_H__
+#define _WorldEntity_H__
+
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+
+#include "../OrxonoxPrereqs.h"
+
+#include "util/Math.h"
+#include "network/Synchronisable.h"
+#include "util/tinyxml/tinyxml.h"
+#include "../core/CoreIncludes.h"
+#include "core/BaseObject.h"
+#include "Tickable.h"
+#include "../tools/Mesh.h"
+
+namespace orxonox
+{
+  class _OrxonoxExport WorldEntity : public BaseObject, public Tickable, public network::Synchronisable
+  {
+    public:
+      WorldEntity();
+      virtual ~WorldEntity();
+
+      virtual void tick(float dt);
+      virtual void loadParams(TiXmlElement* xmlElem);
+      bool create();
+
+      inline Ogre::SceneNode* getNode()
+          { return this->node_; }
+
+      inline void setNode(Ogre::SceneNode* node)
+          { this->node_ = node; }
+
+      inline void setPosition(const Vector3& pos)
+          { this->node_->setPosition(pos); }
+      inline void setPosition(Real x, Real y, Real z)
+          { this->node_->setPosition(x, y, z); }
+      inline const Vector3& getPosition() const
+          { return this->node_->getPosition(); }
+
+      inline void translate(const Vector3 &d, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
+          { this->node_->translate(d, relativeTo); }
+      inline void translate(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
+          { this->node_->translate(x, y, z, relativeTo); }
+      inline void translate(const Matrix3 &axes, const Vector3 &move, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
+          { this->node_->translate(axes, move, relativeTo); }
+      inline void translate(const Matrix3 &axes, Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
+          { this->node_->translate(axes, x, y, z, relativeTo); }
+
+      inline void yaw(const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
+          { this->node_->yaw(angle, relativeTo); }
+      inline void pitch(const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
+          { this->node_->pitch(angle, relativeTo); }
+      inline void roll(const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
+          { this->node_->roll(angle, relativeTo); }
+
+      inline const Ogre::Quaternion& getOrientation()
+        { return this->node_->getOrientation(); }
+      inline void setOrientation(const Ogre::Quaternion& quat)
+        { this->node_->setOrientation(quat); }
+      inline void rotate(const Vector3 &axis, const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
+        { this->node_->rotate(axis, angle, relativeTo); }
+      inline void setDirection(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
+        { this->node_->setDirection(x, y, z, relativeTo, localDirectionVector); }
+      inline void setDirection(const Vector3 &vec, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
+        { this->node_->setDirection(vec, relativeTo, localDirectionVector); }
+      inline void lookAt(const Vector3 &targetPoint, Ogre::Node::TransformSpace relativeTo, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
+        { this->node_->lookAt(targetPoint, relativeTo, localDirectionVector); }
+
+      inline void setScale(const Vector3 &scale)
+        { this->node_->setScale(scale); }
+      inline void setScale(Real x, Real y, Real z)
+        { this->node_->setScale(x, y, z); }
+      inline void setScale(Real scale)
+        { this->node_->setScale(scale, scale, scale); }
+      inline const Vector3& getScale(void) const
+        { return this->node_->getScale(); }
+      inline void scale(const Vector3 &scale)
+        { this->node_->scale(scale); }
+      inline void scale(Real x, Real y, Real z)
+        { this->node_->scale(x, y, z); }
+      inline void scale(Real scale)
+        { this->node_->scale(scale, scale, scale); }
+
+      inline void attachObject(Ogre::MovableObject *obj)
+        { this->node_->attachObject(obj); }
+      inline void attachObject(Mesh &mesh)
+        { this->node_->attachObject(mesh.getEntity()); }
+      inline void detachObject(Ogre::MovableObject *obj)
+        { this->node_->detachObject(obj); }
+      inline void detachAllObjects()
+        { this->node_->detachAllObjects(); }
+
+      inline void setVelocity(const Vector3& velocity)
+          { this->velocity_ = velocity; }
+      inline void setVelocity(Real x, Real y, Real z)
+          { this->velocity_.x = x; this->velocity_.y = y; this->velocity_.z = z; }
+      inline const Vector3& getVelocity() const
+          { return this->velocity_; }
+
+      inline void setAcceleration(const Vector3& acceleration)
+          { this->acceleration_ = acceleration; }
+      inline void setAcceleration(Real x, Real y, Real z)
+          { this->acceleration_.x = x; this->acceleration_.y = y; this->acceleration_.z = z; }
+      inline const Vector3& getAcceleration() const
+          { return this->acceleration_; }
+
+      inline void setRotationAxis(const Vector3& axis)
+          { this->rotationAxis_ = axis; }
+      inline void setRotationAxis(Real x, Real y, Real z)
+          { this->rotationAxis_.x = x; this->rotationAxis_.y = y; this->rotationAxis_.z = z; }
+      inline const Vector3& getRotationAxis() const
+          { return this->rotationAxis_; }
+
+      inline void setRotationRate(const Radian& angle)
+          { this->rotationRate_ = angle; }
+      inline void setRotationRate(const Degree& angle)
+          { this->rotationRate_ = angle; }
+      inline const Radian& getRotationRate() const
+          { return this->rotationRate_; }
+
+      inline void setMomentum(const Radian& angle)
+          { this->momentum_ = angle; }
+      inline void setMomentum(const Degree& angle)
+          { this->momentum_ = angle; }
+      inline const Radian& getMomentum() const
+          { return this->momentum_; }
+
+      inline void setStatic(bool bStatic)
+          { this->bStatic_ = bStatic; }
+      inline bool isStatic()
+          { return this->bStatic_; }
+
+    protected:
+      void registerAllVariables();
+
+      Vector3 velocity_;
+      Vector3 acceleration_;
+      Vector3 rotationAxis_;
+      Radian rotationRate_;
+      Radian momentum_;
+
+    private:
+      static unsigned int worldEntityCounter_s;
+      Ogre::SceneNode* node_;
+      bool bStatic_;
+  };
+  ExportClass(WorldEntity, Orxonox);
+}
+
+#endif /* _WorldEntity_H__ */
Index: code/trunk/src/orxonox/objects/test1.cc
===================================================================
--- code/trunk/src/orxonox/objects/test1.cc	(revision 258)
+++ code/trunk/src/orxonox/objects/test1.cc	(revision 790)
@@ -1,5 +1,35 @@
+/*
+ *   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 "test1.h"
 #include "test2.h"
 #include "test3.h"
+#include "util/tinyxml/tinyxml.h"
+#include "../Orxonox.h"
+#include <OgreSceneManager.h>
 
 namespace orxonox
@@ -18,4 +48,9 @@
     Test1::~Test1()
     {
+    }
+
+    void Test1::tick(float dt)
+    {
+        std::cout << "Test1: " << this << std::endl;
     }
 
@@ -37,8 +72,8 @@
     void Test1::setUsefullClass1(Identifier* identifier)
     {
-        std::cout << "\n";
-        std::cout << "Test1: usefullClass1->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
-        std::cout << "Test1: usefullClass1->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
-        std::cout << "Test1: usefullClass1->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        std::cout << std::endl;
+        std::cout << "Test1: usefullClass1->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << std::endl;
+        std::cout << "Test1: usefullClass1->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << std::endl;
+        std::cout << "Test1: usefullClass1->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << std::endl;
         this->usefullClass1_ = identifier;
     }
@@ -46,8 +81,8 @@
     void Test1::setUsefullClass2(Identifier* identifier)
     {
-        std::cout << "\n";
-        std::cout << "Test1: usefullClass2->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
-        std::cout << "Test1: usefullClass2->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
-        std::cout << "Test1: usefullClass2->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        std::cout << std::endl;
+        std::cout << "Test1: usefullClass2->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << std::endl;
+        std::cout << "Test1: usefullClass2->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << std::endl;
+        std::cout << "Test1: usefullClass2->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << std::endl;
         this->usefullClass2_ = identifier;
     }
@@ -55,9 +90,16 @@
     void Test1::setUsefullClassOfTypeTest3(Identifier* identifier)
     {
-        std::cout << "\n";
-        std::cout << "Test1: usefullClass3->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
-        std::cout << "Test1: usefullClass3->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
-        std::cout << "Test1: usefullClass3->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        std::cout << std::endl;
+        std::cout << "Test1: usefullClass3->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << std::endl;
+        std::cout << "Test1: usefullClass3->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << std::endl;
+        std::cout << "Test1: usefullClass3->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << std::endl;
         this->usefullClass3_ = identifier;
     }
+
+    void Test1::loadParams(TiXmlElement* xmlElem)
+    {
+
+
+
+    }
 }
Index: code/trunk/src/orxonox/objects/test1.h
===================================================================
--- code/trunk/src/orxonox/objects/test1.h	(revision 258)
+++ code/trunk/src/orxonox/objects/test1.h	(revision 790)
@@ -2,14 +2,18 @@
 #define _Test1_H__
 
-#include "BaseObject.h"
+#include "core/BaseObject.h"
+#include "Tickable.h"
 #include "test3.h"
+#include "util/tinyxml/tinyxml.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);
@@ -19,4 +23,6 @@
             void setUsefullClass2(Identifier* identifier);
             void setUsefullClassOfTypeTest3(Identifier* identifier);
+
+            void loadParams(TiXmlElement* xmlElem);
 
         private:
Index: code/trunk/src/orxonox/objects/test2.cc
===================================================================
--- code/trunk/src/orxonox/objects/test2.cc	(revision 258)
+++ code/trunk/src/orxonox/objects/test2.cc	(revision 790)
@@ -1,2 +1,29 @@
+/*
+ *   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 "test1.h"
 #include "test2.h"
@@ -14,8 +41,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" << std::endl;
+    }
+
+    void Test2::timerFunction2()
+    {
+        std::cout << "Test2: 5 Sekunden" << std::endl;
+    }
+
+    void Test2::timerFunction3()
+    {
+        std::cout << "Test2: 10 Sekunden sind um!" << std::endl;
     }
 
@@ -37,8 +83,8 @@
     void Test2::setUsefullClass1(Identifier* identifier)
     {
-        std::cout << "\n";
-        std::cout << "Test2: usefullClass1->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
-        std::cout << "Test2: usefullClass1->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
-        std::cout << "Test2: usefullClass1->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        std::cout << std::endl;
+        std::cout << "Test2: usefullClass1->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << std::endl;
+        std::cout << "Test2: usefullClass1->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << std::endl;
+        std::cout << "Test2: usefullClass1->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << std::endl;
         this->usefullClass1_ = identifier;
     }
@@ -46,8 +92,8 @@
     void Test2::setUsefullClass2(Identifier* identifier)
     {
-        std::cout << "\n";
-        std::cout << "Test2: usefullClass2->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
-        std::cout << "Test2: usefullClass2->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
-        std::cout << "Test2: usefullClass2->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        std::cout << std::endl;
+        std::cout << "Test2: usefullClass2->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << std::endl;
+        std::cout << "Test2: usefullClass2->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << std::endl;
+        std::cout << "Test2: usefullClass2->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << std::endl;
         this->usefullClass2_ = identifier;
     }
@@ -55,8 +101,8 @@
     void Test2::setUsefullClassOfTypeTest3(Identifier* identifier)
     {
-        std::cout << "\n";
-        std::cout << "Test2: usefullClass3->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << "\n";
-        std::cout << "Test2: usefullClass3->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << "\n";
-        std::cout << "Test2: usefullClass3->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << "\n";
+        std::cout << std::endl;
+        std::cout << "Test2: usefullClass3->isA(Class(Test1)): " << identifier->isA(Class(Test1)) << std::endl;
+        std::cout << "Test2: usefullClass3->isA(Class(Test2)): " << identifier->isA(Class(Test2)) << std::endl;
+        std::cout << "Test2: usefullClass3->isA(Class(Test3)): " << identifier->isA(Class(Test3)) << std::endl;
         this->usefullClass3_ = identifier;
     }
Index: code/trunk/src/orxonox/objects/test2.h
===================================================================
--- code/trunk/src/orxonox/objects/test2.h	(revision 258)
+++ code/trunk/src/orxonox/objects/test2.h	(revision 790)
@@ -2,5 +2,6 @@
 #define _Test2_H__
 
-#include "BaseObject.h"
+#include "core/BaseObject.h"
+#include "../tools/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;
     };
 }
Index: code/trunk/src/orxonox/objects/test3.cc
===================================================================
--- code/trunk/src/orxonox/objects/test3.cc	(revision 258)
+++ code/trunk/src/orxonox/objects/test3.cc	(revision 790)
@@ -1,2 +1,29 @@
+/*
+ *   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 "test1.h"
 #include "test2.h"
@@ -10,4 +37,22 @@
     {
         RegisterObject(Test3);
+
+        this->setConfigValues();
+    }
+
+    void Test3::setConfigValues()
+    {
+        SetConfigValue(value_int_, 1);
+        SetConfigValue(value_uint_, 1);
+        SetConfigValue(value_char_, 1);
+        SetConfigValue(value_uchar_, 1);
+        SetConfigValue(value_float_, 1);
+        SetConfigValue(value_double_, 1);
+        SetConfigValue(value_bool_, 1);
+        SetConfigValue(value_string_, "This is a test");
+        SetConfigValue(value_constchar_, "This is another test");
+        SetConfigValue(value_vector2_, Vector2(101, 202));
+        SetConfigValue(value_vector3_, Vector3(13, 26, 39));
+        SetConfigValue(value_colourvalue_, ColourValue(1.0, 0.5, 0.25, 0.887));
     }
 
@@ -15,19 +60,36 @@
     {
     }
-        #define testandcout(code) \
-          std::cout << #code << " " << code << "\n"
 
-    bool Test3::usefullClassesIsATest(Test1* test1)
+    void Test3::configOutput()
     {
-        std::cout << "\n";
-        std::cout << "Test1:\n";
+        std::cout << this->value_int_ << std::endl;
+        std::cout << this->value_uint_ << std::endl;
+        std::cout << (int)this->value_char_ << std::endl;
+        std::cout << (int)this->value_uchar_ << std::endl;
+        std::cout << this->value_float_ << std::endl;
+        std::cout << this->value_double_ << std::endl;
+        std::cout << this->value_bool_ << std::endl;
+        std::cout << this->value_string_ << std::endl;
+        std::cout << this->value_constchar_ << std::endl;
+        std::cout << this->value_vector2_ << std::endl;
+        std::cout << this->value_vector3_ << std::endl;
+        std::cout << this->value_colourvalue_ << std::endl;
+    }
+
+    #define testandcout(code) \
+      std::cout << #code << " " << code << std::endl
+
+    void Test3::usefullClassesIsATest(Test1* test1)
+    {
+        std::cout << std::endl;
+        std::cout << "Test1:" << std::endl;
         testandcout(test1->usefullClass1isA(Class(Test1)));
         testandcout(test1->usefullClass1isA(Class(Test2)));
         testandcout(test1->usefullClass1isA(Class(Test3)));
-        std::cout << "\n";
+        std::cout << std::endl;
         testandcout(test1->usefullClass2isA(Class(Test1)));
         testandcout(test1->usefullClass2isA(Class(Test2)));
         testandcout(test1->usefullClass2isA(Class(Test3)));
-        std::cout << "\n";
+        std::cout << std::endl;
         testandcout(test1->usefullClass3isA(Class(Test1)));
         testandcout(test1->usefullClass3isA(Class(Test2)));
@@ -35,16 +97,16 @@
     }
 
-    bool Test3::usefullClassesIsATest(Test2* test2)
+    void Test3::usefullClassesIsATest(Test2* test2)
     {
-        std::cout << "\n";
-        std::cout << "Test2:\n";
+        std::cout << std::endl;
+        std::cout << "Test2:" << std::endl;
         testandcout(test2->usefullClass1isA(Class(Test1)));
         testandcout(test2->usefullClass1isA(Class(Test2)));
         testandcout(test2->usefullClass1isA(Class(Test3)));
-        std::cout << "\n";
+        std::cout << std::endl;
         testandcout(test2->usefullClass2isA(Class(Test1)));
         testandcout(test2->usefullClass2isA(Class(Test2)));
         testandcout(test2->usefullClass2isA(Class(Test3)));
-        std::cout << "\n";
+        std::cout << std::endl;
         testandcout(test2->usefullClass3isA(Class(Test1)));
         testandcout(test2->usefullClass3isA(Class(Test2)));
Index: code/trunk/src/orxonox/objects/test3.h
===================================================================
--- code/trunk/src/orxonox/objects/test3.h	(revision 258)
+++ code/trunk/src/orxonox/objects/test3.h	(revision 790)
@@ -2,5 +2,5 @@
 #define _Test3_H__
 
-#include "BaseObject.h"
+#include "core/BaseObject.h"
 
 namespace orxonox
@@ -15,6 +15,24 @@
             virtual ~Test3();
 
-            bool usefullClassesIsATest(Test1* test1);
-            bool usefullClassesIsATest(Test2* test2);
+            void setConfigValues();
+
+            void usefullClassesIsATest(Test1* test1);
+            void usefullClassesIsATest(Test2* test2);
+
+            void configOutput();
+
+        private:
+            int                 value_int_;
+            unsigned int        value_uint_;
+            char                value_char_;
+            unsigned char       value_uchar_;
+            float               value_float_;
+            double              value_double_;
+            bool                value_bool_;
+            std::string         value_string_;
+            const char*         value_constchar_;
+            Vector2             value_vector2_;
+            Vector3             value_vector3_;
+            ColourValue         value_colourvalue_;
     };
 }
Index: code/trunk/src/orxonox/objects/weapon/AmmunitionDump.cc
===================================================================
--- code/trunk/src/orxonox/objects/weapon/AmmunitionDump.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/AmmunitionDump.cc	(revision 790)
@@ -0,0 +1,115 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include "orxonox/Orxonox.h"
+#include "BulletManager.h"
+#include "util/tinyxml/tinyxml.h"
+
+#include "AmmunitionDump.h"
+
+
+namespace orxonox {
+  CreateFactory(AmmunitionDump);
+
+  AmmunitionDump::AmmunitionDump()
+    : numberOfAmmos_(Orxonox::getSingleton()->getBulletMgr()->getNumberOfAmmos()),
+      stock_(new int[numberOfAmmos_]),
+      capacity_(new int[numberOfAmmos_])
+  {
+    RegisterObject(AmmunitionDump);
+
+    for (int i = 0; i < numberOfAmmos_; i++)
+    {
+      stock_[i] = 0;
+      capacity_[i] = 0;
+    }
+  }
+
+
+  AmmunitionDump::~AmmunitionDump()
+  {
+    if (stock_)
+      delete stock_;
+    if (capacity_)
+      delete capacity_;
+  }
+
+  void AmmunitionDump::setDumpSize(const std::string &name, int size)
+  {
+    if (size < 0)
+      return;
+    int id = Orxonox::getSingleton()->getBulletMgr()->getAmmunitionID(name);
+    if (id == -1)
+      return;
+    capacity_[id] = size;
+  }
+
+
+  int AmmunitionDump::store(const std::string &name, int quantity)
+  {
+    int id = Orxonox::getSingleton()->getBulletMgr()->getAmmunitionID(name);
+    if (id == -1)
+      return quantity;
+    stock_[id] += quantity;
+    if (stock_[id] > capacity_[id])
+    {
+      quantity = capacity_[id] - stock_[id];
+      stock_[id] = capacity_[id];
+      return quantity;
+    }
+    else
+      return 0;
+  }
+
+
+  int AmmunitionDump::getAmmunition(const std::string &name, int quantity)
+  {
+    int id = Orxonox::getSingleton()->getBulletMgr()->getAmmunitionID(name);
+    if (id == -1)
+      return 0;
+    if (stock_[id] >= quantity)
+      stock_[id] -= quantity;
+    else
+    {
+      quantity = stock_[id];
+      stock_[id] = 0;
+    }
+    return quantity;
+  }
+
+
+  int AmmunitionDump::getStockSize(const std::string &name)
+  {
+    int id = Orxonox::getSingleton()->getBulletMgr()->getAmmunitionID(name);
+    // FIXME changed = to ==, check if correct
+    if (id == -1)
+      return -1;
+    return stock_[id];
+  }
+}
Index: code/trunk/src/orxonox/objects/weapon/AmmunitionDump.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/AmmunitionDump.h	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/AmmunitionDump.h	(revision 790)
@@ -0,0 +1,71 @@
+/*
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+#ifndef _AmmunitionDump_H__
+#define _AmmunitionDump_H__
+
+#include <string>
+
+#include <OgrePrerequisites.h>
+
+#include "../../OrxonoxPrereqs.h"
+
+#include "network/Synchronisable.h"
+//#include "../core/CoreIncludes.h"
+#include "core/BaseObject.h"
+
+
+namespace orxonox {
+  class _OrxonoxExport AmmunitionDump : public BaseObject, public network::Synchronisable
+  {
+  public:
+    AmmunitionDump();
+	  ~AmmunitionDump();
+
+    void setDumpSize(const std::string &name, int size);
+
+    int store(const std::string &name, int quantiy);
+
+    int getAmmunition(const std::string &name, int quantity);
+
+    int getStockSize(const std::string &name);
+
+    virtual void loadParams(TiXmlElement* xmlElem) { BaseObject::loadParams(xmlElem); };
+
+
+  protected:
+    inline bool create() { return true; }
+
+    int numberOfAmmos_;
+    int *stock_;
+    int *capacity_;
+  };
+  ExportClass(AmmunitionDump, Orxonox);
+}
+
+#endif /* _AmmunitionDump_H__ */
Index: code/trunk/src/orxonox/objects/weapon/BarrelGun.cc
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BarrelGun.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/BarrelGun.cc	(revision 790)
@@ -0,0 +1,146 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include <OgreStringConverter.h>
+#include <OgreSceneNode.h>
+#include <OgreEntity.h>
+#include <OgreSceneManager.h>
+
+#include "util/Math.h"
+#include "Bullet.h"
+#include "BulletManager.h"
+#include "AmmunitionDump.h"
+#include "BaseWeapon.h"
+
+#include "BarrelGun.h"
+
+
+namespace orxonox {
+  CreateFactory(BarrelGun);
+
+  BarrelGun::BarrelGun()
+  {
+    RegisterObject(BarrelGun);
+
+    primaryFirePower_ = 100;
+    secondaryFirePower_ = 500;
+    primaryFiringRate_ = 1.0/7.0;
+    secondaryFiringRate_ = 1.0/2.0;
+    primaryBulletSpeed_ = 800;
+    secondaryBulletSpeed_ = 500;
+    magazineSize_ = 25;
+  }
+
+
+  BarrelGun::~BarrelGun()
+  {
+  }
+
+
+  void BarrelGun::primaryFire()
+  {
+    if (leftAmmo_ < 1)
+    {
+      currentState_ = IDLE;
+      return;
+    }
+
+    Ogre::SceneNode *temp = sceneMgr_->getRootSceneNode()->createChildSceneNode(
+          getNode()->getWorldPosition(),
+          getNode()->getWorldOrientation());
+
+    Ogre::Entity* bulletEntity = sceneMgr_->createEntity("BulletEntity"
+      + Ogre::StringConverter::toString(bulletCounter_++), "Barrel.mesh");
+
+    Vector3 speed = (temp->getOrientation() * Vector3(1, 0, 0))
+          .normalisedCopy() * primaryBulletSpeed_;
+    speed += getVelocity();
+
+	  temp->setScale(Vector3(1, 1, 1) * 1.5);
+    temp->roll(Degree(90));
+
+    Bullet* bullet = new Bullet();
+    bullet->setNode(temp);
+    bullet->attachObject(bulletEntity);
+    bullet->setVelocity(speed);
+	  bulletManager_->addBullet(bullet);
+
+    --leftAmmo_;
+  }
+
+
+  void BarrelGun::primaryFiring(float time)
+  {
+    if (time > primaryFiringRate_)
+    {
+      currentState_ = IDLE;
+    }
+  }
+
+
+  void BarrelGun::secondaryFire()
+  {
+    if (leftAmmo_ < 5)
+    {
+      currentState_ = IDLE;
+      return;
+    }
+
+    Ogre::SceneNode *temp = sceneMgr_->getRootSceneNode()->createChildSceneNode(
+          getNode()->getWorldPosition(),
+          getNode()->getWorldOrientation());
+
+    Ogre::Entity* bulletEntity = sceneMgr_->createEntity("BulletEntity"
+      + Ogre::StringConverter::toString(bulletCounter_++), "Barrel.mesh");
+
+    Vector3 speed = (temp->getOrientation() * Vector3(1, 0, 0))
+          .normalisedCopy() * secondaryBulletSpeed_*0.5;
+    speed += getVelocity();
+
+	  temp->setScale(Vector3(1, 1, 1) * 3);
+	  temp->roll(Degree(90));
+
+    Bullet* bullet = new Bullet();
+    bullet->setNode(temp);
+    bullet->attachObject(bulletEntity);
+    bullet->setVelocity(speed);
+	  bulletManager_->addBullet(bullet);
+
+
+    leftAmmo_ -= 5;
+  }
+
+
+  void BarrelGun::secondaryFiring(float time)
+  {
+    if (time > secondaryFiringRate_)
+      currentState_ = IDLE;
+  }
+
+}
Index: code/trunk/src/orxonox/objects/weapon/BarrelGun.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BarrelGun.h	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/BarrelGun.h	(revision 790)
@@ -0,0 +1,65 @@
+/*
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+#ifndef _BarrelGun_H__
+#define _BarrelGun_H__
+
+#include <OgrePrerequisites.h>
+
+#include "../../OrxonoxPrereqs.h"
+
+#include "BaseWeapon.h"
+
+
+namespace orxonox {
+  class _OrxonoxExport BarrelGun : public BaseWeapon
+  {
+ public:
+    BarrelGun();
+	  virtual ~BarrelGun();
+
+    //virtual void tick(float dt);
+
+  protected:
+    void primaryFire();
+
+    void primaryFiring(float);
+
+    void secondaryFire();
+
+    void secondaryFiring(float);
+
+  public:
+
+  protected:
+
+  };
+  ExportClass(BarrelGun, Orxonox);
+}
+
+#endif /* _BarrelGun_H__ */
Index: code/trunk/src/orxonox/objects/weapon/BaseWeapon.cc
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BaseWeapon.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/BaseWeapon.cc	(revision 790)
@@ -0,0 +1,185 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include <OgreStringConverter.h>
+#include <OgreSceneNode.h>
+#include <OgreEntity.h>
+#include <OgreSceneManager.h>
+
+#include "util/Math.h"
+#include "../../Orxonox.h"
+#include "Bullet.h"
+#include "BulletManager.h"
+#include "AmmunitionDump.h"
+
+#include "BaseWeapon.h"
+
+
+namespace orxonox {
+  float BaseWeapon::nextActionValidityPeriod_s = 0.5;
+
+  BaseWeapon::BaseWeapon()
+    : sceneMgr_(Orxonox::getSingleton()->getSceneManager()),
+      bulletCounter_(0),
+      bulletManager_(Orxonox::getSingleton()->getBulletMgr()),
+      ammoDump_(NULL),
+      primaryFireRequest_(false), secondaryFireRequest_(false),
+      totalTime_(0.0f), actionStartTime_(0.0f),
+      currentState_(IDLE), secondaryFired_(false),
+      nextAction_(NOTHING), actionAdded_(false),
+      timeSinceNextActionAdded_(0.0f),
+      leftAmmo_(0)
+  {
+    RegisterObject(BaseWeapon);
+  }
+
+
+  BaseWeapon::~BaseWeapon()
+  {
+  }
+
+
+  bool BaseWeapon::addAction(const Action act)
+  {
+    if (nextAction_ == NOTHING)
+    {
+      nextAction_ = act;
+      actionAdded_ = true;
+      return true;
+    }
+    else
+      return false;
+  }
+
+
+  void BaseWeapon::primaryFireRequest()
+  {
+    primaryFireRequest_ = true;
+  }
+
+
+  void BaseWeapon::secondaryFireRequest()
+  {
+    secondaryFireRequest_ = true;
+  }
+
+
+  void BaseWeapon::tick(float dt)
+  {
+    totalTime_ += dt;
+    // process action adder
+    if (actionAdded_)
+    {
+      timeSinceNextActionAdded_ = totalTime_;
+      actionAdded_ = false;
+    }
+
+    switch (currentState_)
+    {
+    case IDLE:
+      break;
+
+    case PRIMARY_FIRE:
+      primaryFiring(totalTime_ - actionStartTime_);
+      break;
+
+    case SECONDARY_FIRE:
+      secondaryFiring(totalTime_ - actionStartTime_);
+      break;
+
+    case RELOADING:
+      break;
+
+    case CHANGING_AMMO:
+      break;
+    }
+
+    if (currentState_ == IDLE)
+    {
+      // first, process next action
+      if (nextAction_ != NOTHING)
+      {
+        actionStartTime_ = totalTime_;
+        switch (nextAction_)
+        {
+        case RELOAD:
+          leftAmmo_ += ammoDump_->getAmmunition("Barrel", magazineSize_ - leftAmmo_);
+          break;
+
+        case CHANGE_AMMO:
+          break;
+
+        case SPECIAL:
+          break;
+
+        default:
+          break;
+        }
+
+        // pay attention when multithreaded!
+        nextAction_ = NOTHING;
+      }
+      else
+      {
+        // secondly, execute firing
+        if (primaryFireRequest_ && !(secondaryFired_ && secondaryFireRequest_))
+        {
+          actionStartTime_ = totalTime_;
+          currentState_ = PRIMARY_FIRE;
+          secondaryFired_ = false;
+          primaryFire();
+        }
+        else if (secondaryFireRequest_)
+        {
+          actionStartTime_ = totalTime_;
+          currentState_ = SECONDARY_FIRE;
+          secondaryFired_ = true;
+          secondaryFire();
+        }
+      }
+    }
+
+    primaryFireRequest_ = false;
+    secondaryFireRequest_ = false;
+
+    if (totalTime_ - timeSinceNextActionAdded_ > nextActionValidityPeriod_s)
+      nextAction_ = NOTHING;
+  }
+
+
+  int BaseWeapon::getAmmoState()
+  {
+    return leftAmmo_;
+  }
+
+  void BaseWeapon::setAmmoDump(AmmunitionDump* dump)
+  {
+    this->ammoDump_ = dump;
+  }
+}
Index: code/trunk/src/orxonox/objects/weapon/BaseWeapon.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BaseWeapon.h	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/BaseWeapon.h	(revision 790)
@@ -0,0 +1,127 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+#ifndef _BaseWeapon_H__
+#define _BaseWeapon_H__
+
+#include <OgrePrerequisites.h>
+
+#include "../../OrxonoxPrereqs.h"
+
+#include "../Model.h"
+
+
+namespace orxonox {
+  class _OrxonoxExport BaseWeapon : public Model
+  {
+  public:
+    enum Action {
+      NOTHING  = 0,
+      RELOAD   = 1,
+      CHANGE_AMMO  = 2,
+      SPECIAL  = 3
+    };
+
+  protected:
+    enum State {
+      IDLE = 0,
+      PRIMARY_FIRE = 1,
+      SECONDARY_FIRE = 2,
+      RELOADING = 3,
+      CHANGING_AMMO = 4,
+    };
+
+  public:
+    BaseWeapon();
+	  virtual ~BaseWeapon();
+
+    bool addAction(const Action);
+
+    void primaryFireRequest();
+
+    void secondaryFireRequest();
+
+    int getAmmoState();
+
+    void setAmmoDump(AmmunitionDump*);
+
+    inline virtual void loadParams(TiXmlElement* xmlElem) { Model::loadParams(xmlElem); };
+
+    virtual void tick(float dt);
+
+  protected:
+    virtual void primaryFire() = 0;
+
+    virtual void primaryFiring(float) = 0;
+
+    virtual void secondaryFire() = 0;
+
+    virtual void secondaryFiring(float) = 0;
+
+    virtual void registerAllVariables() { };
+
+  public:
+
+  protected:
+    Ogre::SceneManager *sceneMgr_;
+
+    int bulletCounter_;
+    BulletManager *bulletManager_;
+
+    AmmunitionDump *ammoDump_;
+
+    bool primaryFireRequest_;
+    bool secondaryFireRequest_;
+
+    float totalTime_;
+    float actionStartTime_;
+
+    State currentState_;
+    bool secondaryFired_;
+
+    Action nextAction_;
+    bool actionAdded_;
+    float timeSinceNextActionAdded_;
+    static float nextActionValidityPeriod_s;
+
+    // weapon properties
+    int leftAmmo_;
+    float primaryFirePower_;
+    float secondaryFirePower_;
+    float primaryFiringRate_;
+    float secondaryFiringRate_;
+    Real primaryBulletSpeed_;
+    Real secondaryBulletSpeed_;
+
+    int magazineSize_;
+
+  };
+  ExportAbstractClass(BaseWeapon, Orxonox);
+}
+
+#endif /* _BaseWeapon_H__ */
Index: code/trunk/src/orxonox/objects/weapon/Bullet.cc
===================================================================
--- code/trunk/src/orxonox/objects/weapon/Bullet.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/Bullet.cc	(revision 790)
@@ -0,0 +1,43 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include "Bullet.h"
+
+namespace orxonox {
+  CreateFactory(Bullet);
+
+  Bullet::Bullet()
+  {
+    RegisterObject(Bullet);
+  }
+
+  Bullet::~Bullet()
+  {
+  }
+}
Index: code/trunk/src/orxonox/objects/weapon/Bullet.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/Bullet.h	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/Bullet.h	(revision 790)
@@ -0,0 +1,52 @@
+/*
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+#ifndef _Bullet_H__
+#define _Bullet_H__
+
+#include <OgrePrerequisites.h>
+
+#include "../../OrxonoxPrereqs.h"
+
+#include "../Model.h"
+
+namespace orxonox {
+  class _OrxonoxExport Bullet : public Model
+  {
+  public:
+	  Bullet();
+	  ~Bullet();
+
+    virtual void tick(float dt) { }
+
+    inline virtual void loadParams(TiXmlElement* xmlElem) { Model::loadParams(xmlElem); };
+ };
+  ExportClass(Bullet, Orxonox);
+}
+
+#endif /* _Bullet_H__ */
Index: code/trunk/src/orxonox/objects/weapon/BulletManager.cc
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BulletManager.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/BulletManager.cc	(revision 790)
@@ -0,0 +1,104 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include "BulletManager.h"
+#include "Bullet.h"
+
+
+namespace orxonox {
+  CreateFactory(BulletManager);
+
+  BulletManager::BulletManager() : bulletsSize_(8), bulletsIndex_(0)
+  {
+    RegisterObject(BulletManager);
+    bullets_ = new Bullet*[bulletsSize_];
+  }
+
+
+  BulletManager::~BulletManager()
+  {
+    // clean up the bullet list
+    if (bullets_)
+    {
+      for (int i = 0; i < bulletsIndex_; i++)
+        delete bullets_[i];
+      delete bullets_;
+    }
+  }
+
+
+  void BulletManager::addBullet(Bullet *bullet)
+  {
+    // resize array if neccessary (double the size then)
+    if (bulletsIndex_ >= bulletsSize_)
+    {
+      // redimension the array
+      Bullet **tempArray = new Bullet*[2*bulletsSize_];
+      for (int i = 0; i < bulletsSize_; i++)
+        tempArray[i] = bullets_[i];
+      bulletsSize_ *= 2;
+      delete bullets_;
+      bullets_ = tempArray;
+    }
+
+    // add the bullet to the list
+    bullets_[bulletsIndex_++] = bullet;
+  }
+
+
+  void BulletManager::tick(float dt)
+  {
+    // update the bullet positions
+    for (int i = 0; i < bulletsIndex_; i++)
+    {
+      bullets_[i]->getNode()->translate(bullets_[i]->getVelocity()*dt);
+      //bullets_[i]->getNode()->yaw(Degree(dt*100));
+      //bullets_[i]->getNode()->roll(Degree(dt*300));
+    }
+  }
+
+  int BulletManager::getAmmunitionID(const std::string &ammoName)
+  {
+    std::string ammoTypes[] = { "Energy Cell", "Barrel", "Lead Shot" };
+    int ammoTypesLength = 3;
+
+    for (int i = 0; i < ammoTypesLength; i++)
+    {
+      if (ammoTypes[i] == ammoName)
+        return i;
+    }
+    return -1;
+  }
+
+  int BulletManager::getNumberOfAmmos()
+  {
+    return 3;
+  }
+
+}
Index: code/trunk/src/orxonox/objects/weapon/BulletManager.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BulletManager.h	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/BulletManager.h	(revision 790)
@@ -0,0 +1,72 @@
+/*
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+#ifndef _BulletManager_H__
+#define _BulletManager_H__
+
+#include <string>
+
+#include <OgrePrerequisites.h>
+
+#include "../../OrxonoxPrereqs.h"
+
+#include "network/Synchronisable.h"
+#include "util/tinyxml/tinyxml.h"
+#include "../../core/CoreIncludes.h"
+#include "core/BaseObject.h"
+#include "../Tickable.h"
+
+namespace orxonox {
+  class _OrxonoxExport BulletManager : public BaseObject, public network::Synchronisable, public Tickable
+  {
+  public:
+    BulletManager();
+	  virtual ~BulletManager();
+
+    void addBullet(Bullet*);
+
+    int getAmmunitionID(const std::string&);
+
+    int getNumberOfAmmos();
+
+    virtual void tick(float dt);
+
+    inline virtual void loadParams(TiXmlElement* xmlElem) { BaseObject::loadParams(xmlElem); };
+
+  protected:
+    inline bool create() { return true; }
+
+    // Bullet array
+	  Bullet **bullets_;
+	  int bulletsSize_;
+	  int bulletsIndex_;
+  };
+  ExportClass(BulletManager, Orxonox);
+}
+
+#endif /* _BulletManager_H__ */
Index: code/trunk/src/orxonox/objects/weapon/WeaponStation.cc
===================================================================
--- code/trunk/src/orxonox/objects/weapon/WeaponStation.cc	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/WeaponStation.cc	(revision 790)
@@ -0,0 +1,70 @@
+/*
+ *   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:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
+#include "BaseWeapon.h"
+#include "WeaponStation.h"
+
+
+namespace orxonox {
+  WeaponStation::WeaponStation(int stationSize)
+        : slots_(new BaseWeapon*[stationSize]),
+          lastActiveSlotIndex_(-1), stationSize_(stationSize)
+  {
+  	//slots_ = new BaseWeapon*[stationSize];
+  }
+
+
+  WeaponStation::~WeaponStation()
+  {
+    if (slots_)
+      delete slots_;
+    // when factory available: delete weapons too
+  }
+
+
+  bool WeaponStation::addWeapon(BaseWeapon *weapon)
+  {
+    if (lastActiveSlotIndex_ == stationSize_ - 1)
+      return false;
+
+    // this is ugly, but for the time being, it has to fit.
+    slots_[++lastActiveSlotIndex_] = weapon;
+    selectedSlot_ = slots_ + lastActiveSlotIndex_;
+    return true;
+  }
+
+
+  BaseWeapon* WeaponStation::selectWeapon(int slotNumber)
+  {
+    if (slotNumber < lastActiveSlotIndex_)
+      return NULL;
+    return slots_[slotNumber];
+  }
+
+}
Index: code/trunk/src/orxonox/objects/weapon/WeaponStation.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/WeaponStation.h	(revision 790)
+++ code/trunk/src/orxonox/objects/weapon/WeaponStation.h	(revision 790)
@@ -0,0 +1,65 @@
+/*
+ *   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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+
+#ifndef _WeaponStation_H__
+#define _WeaponStation_H__
+
+#include <OgrePrerequisites.h>
+
+#include "../../OrxonoxPrereqs.h"
+
+
+namespace orxonox {
+  class _OrxonoxExport WeaponStation
+  {
+  public:
+    WeaponStation(int slotSize);
+	  ~WeaponStation();
+
+    bool addWeapon(BaseWeapon*);
+
+    //bool removeCurrentWeapon();
+
+    // TODO: access every weapon by name
+    BaseWeapon* selectWeapon(int slotNumber);
+
+  protected:
+
+  public:
+
+  protected:
+    // slot management
+    BaseWeapon **slots_;
+    BaseWeapon **selectedSlot_;
+    int lastActiveSlotIndex_;
+    int stationSize_;
+
+  };
+}
+
+#endif /* _WeaponStation_H__ */
