Index: /code/branches/FICN/bin/levels/sample.oxw
===================================================================
--- /code/branches/FICN/bin/levels/sample.oxw	(revision 607)
+++ /code/branches/FICN/bin/levels/sample.oxw	(revision 608)
@@ -24,13 +24,12 @@
   <!-- Keep a minimum distance of >100 to the object, otherwise the camara thinks it's in the object -->
   <!-- the value has to negative, as we want the camara behind the object -->
+<!--
+    <Camera name="Camera" pos="0,50,-150" lookat="0,20,0" node="2OgreHeadNode" />
+-->
   <world>
-    <SceneNode name="OgreHeadNode" pos="0,0,0" />
-    <Camera name="Camera" pos="0,50,-150" lookat="0,20,0" node="OgreHeadNode" />
     <Ambient colourvalue="1,1,1" />
     <Skybox src="Orxonox/StarfieldSkyBox" />
 
-
-    <SceneNode name="ShipNode" pos="0,0,0" node="OgreHeadNode" scale="10,10,10" yaw="-90" pitch="-90" />
-    <BaseEntity name="TheShip" src="assf3.mesh" node="ShipNode" />
+    <SpaceShip camera="true" position="0,0,0" scale="10" yaw="-90" pitch="-90" mesh="assf3.mesh"  forward="500" rotateupdown="200" rotaterightleft="200" looprightleft="200" />
 
     <Model position="200,0,500" scale="10" mesh="assf3.mesh" yaw="-90" pitch="-90" />
@@ -48,5 +47,5 @@
 
   <!-- Unused at the moment -->
-  <SpaceshipSteeringObject node="OgreHeadNode" forward="500" rotateupdown="200" rotaterightleft="200" looprightleft="200" />
+<!--  <SpaceshipSteeringObject node="OgreHeadNode" forward="500" rotateupdown="200" rotaterightleft="200" looprightleft="200" /> -->
 
   <scripts>
Index: /code/branches/FICN/src/orxonox/CMakeLists.txt
===================================================================
--- /code/branches/FICN/src/orxonox/CMakeLists.txt	(revision 607)
+++ /code/branches/FICN/src/orxonox/CMakeLists.txt	(revision 608)
@@ -28,8 +28,10 @@
     objects/Entity.cc
     objects/Camera.cc
-    objects/SpaceshipSteeringObject.cc
+#    objects/SpaceshipSteeringObject.cc
     objects/Model.cc
     objects/Mesh.cc
     objects/BaseEntity.cc
+    objects/SpaceShip.cc
+    objects/NPC.cc
   )
 ELSE(WIN32)
Index: /code/branches/FICN/src/orxonox/objects/CMakeLists.txt
===================================================================
--- /code/branches/FICN/src/orxonox/objects/CMakeLists.txt	(revision 607)
+++ /code/branches/FICN/src/orxonox/objects/CMakeLists.txt	(revision 608)
@@ -13,7 +13,8 @@
   Entity.cc
   Camera.cc
-  SpaceshipSteeringObject.cc
+#  SpaceshipSteeringObject.cc
   Model.cc
   Mesh.cc
+  SpaceShip.cc
   NPC.cc
 )
Index: /code/branches/FICN/src/orxonox/objects/Camera.cc
===================================================================
--- /code/branches/FICN/src/orxonox/objects/Camera.cc	(revision 607)
+++ /code/branches/FICN/src/orxonox/objects/Camera.cc	(revision 608)
@@ -59,5 +59,5 @@
     		std::string node = xmlElem->Attribute("node");
 
-		    Ogre::SceneNode* sceneNode = (Ogre::SceneNode*)mgr->getRootSceneNode()->getChild(node);
+		    Ogre::SceneNode* sceneNode = (Ogre::SceneNode*)mgr->getRootSceneNode()->createChildSceneNode(node); //getChild(node);
 		    sceneNode->attachObject((Ogre::MovableObject*)cam);
 
Index: /code/branches/FICN/src/orxonox/objects/SpaceShip.cc
===================================================================
--- /code/branches/FICN/src/orxonox/objects/SpaceShip.cc	(revision 608)
+++ /code/branches/FICN/src/orxonox/objects/SpaceShip.cc	(revision 608)
@@ -0,0 +1,436 @@
+/*
+ *   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 "SpaceShip.h"
+
+#include "../../tinyxml/tinyxml.h"
+#include "../../misc/String2Number.h"
+#include "../core/CoreIncludes.h"
+#include "../orxonox.h"
+
+#include "OgreCamera.h"
+#include <OgreRenderWindow.h>
+
+namespace orxonox
+{
+    CreateFactory(SpaceShip);
+
+    SpaceShip::SpaceShip()
+    {
+        RegisterObject(SpaceShip);
+
+        SetConfigValue(bInvertMouse_, true);
+
+        this->setMouseEventCallback_ = 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 (w)
+            delete w;
+        if (tt)
+            delete tt;
+    }
+
+    void SpaceShip::setMaxSpeedValues(float maxSpeedForward, float maxSpeedRotateUpDown, float maxSpeedRotateRightLeft, float maxSpeedLoopRightLeft)
+    {
+        this->maxSpeedForward_ = maxSpeedForward;
+        this->maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
+        this->maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
+        this->maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
+    }
+
+    void SpaceShip::loadParams(TiXmlElement* xmlElem)
+    {
+        Model::loadParams(xmlElem);
+
+        w = new particle::ParticleInterface(Orxonox::getSingleton()->getSceneManager(),"schuss" + this->getName(),"Orxonox/schuss");
+        w->particleSystem_->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));
+
+        Ogre::SceneNode* node1 = this->getNode()->createChildSceneNode(this->getName() + "particle1");
+        node1->setInheritScale(false);
+        w->addToSceneNode(node1);
+
+
+
+        tt = new particle::ParticleInterface(Orxonox::getSingleton()->getSceneManager(),"twinthruster" + this->getName(),"Orxonox/engineglow");
+        tt->particleSystem_->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));
+
+        Ogre::SceneNode* node2 = this->getNode()->createChildSceneNode(this->getName() + "particle2");
+        node2->setInheritScale(false);
+        tt->addToSceneNode(node2);
+
+
+
+        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 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;
+
+        return true;
+    }
+
+    void SpaceShip::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 (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/branches/FICN/src/orxonox/objects/SpaceShip.h
===================================================================
--- /code/branches/FICN/src/orxonox/objects/SpaceShip.h	(revision 608)
+++ /code/branches/FICN/src/orxonox/objects/SpaceShip.h	(revision 608)
@@ -0,0 +1,83 @@
+#ifndef _SpaceShip_H__
+#define _SpaceShip_H__
+
+#include <OIS/OIS.h>
+
+#include "Model.h"
+#include "../../tinyxml/tinyxml.h"
+#include "../particle/ParticleInterface.h"
+
+namespace orxonox
+{
+    class SpaceShip : public Model, public OIS::MouseListener
+    {
+        public:
+            SpaceShip();
+            ~SpaceShip();
+            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_;
+
+            particle::ParticleInterface *w;
+            particle::ParticleInterface *tt;
+
+            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;
+    };
+}
+
+#endif
Index: /code/branches/FICN/src/orxonox/orxonox.cc
===================================================================
--- /code/branches/FICN/src/orxonox/orxonox.cc	(revision 607)
+++ /code/branches/FICN/src/orxonox/orxonox.cc	(revision 608)
@@ -61,8 +61,4 @@
 #include "../audio/AudioManager.h"
 
-#include "spaceship_steering.h"
-
-#include "particle/ParticleInterface.h"
-
 #include "hud/HUD.h"
 
@@ -84,119 +80,35 @@
 
    // put this in seperate Class or solve the problem in another fashion
-  class OrxListener : public FrameListener, public OIS::MouseListener
+  class OrxListener : public FrameListener
   {
     public:
-      OrxListener(OIS::Keyboard *keyboard, OIS::Mouse *mouse, audio::AudioManager*  auMan, SpaceshipSteering* steering, gameMode mode)
-      : mKeyboard(keyboard), mMouse(mouse)
+      OrxListener(OIS::Keyboard *keyboard, audio::AudioManager*  auMan, gameMode mode)
       {
-
-
+        mKeyboard = keyboard;
         mode_=mode;
-        speed = 250;
-        loop = 100;
-        rotate = 10;
-        mouseX = 0;
-        mouseY = 0;
-        maxMouseX = 0;
-        minMouseX = 0;
-        moved = false;
-
-        steering_ = steering;
-
-        steering_->brakeRotate(rotate*10);
-        steering_->brakeLoop(loop);
-
-
-        mMouse->setEventCallback(this);
         auMan_ = auMan;
       }
+
       bool frameStarted(const FrameEvent& evt)
       {
-
         auMan_->update();
 
-        mKeyboard->capture();
-        mMouse->capture();
-        if (mKeyboard->isKeyDown(OIS::KC_UP) || mKeyboard->isKeyDown(OIS::KC_W))
-          steering_->moveForward(speed);
-        else
-          steering_->moveForward(0);
-        if(mKeyboard->isKeyDown(OIS::KC_DOWN) || mKeyboard->isKeyDown(OIS::KC_S))
-          steering_->brakeForward(speed);
-        else
-          steering_->brakeForward(speed/10);
-        if (mKeyboard->isKeyDown(OIS::KC_RIGHT) || mKeyboard->isKeyDown(OIS::KC_D))
-          steering_->loopRight(loop);
-        else
-          steering_->loopRight(0);
-        if (mKeyboard->isKeyDown(OIS::KC_LEFT) || mKeyboard->isKeyDown(OIS::KC_A))
-          steering_->loopLeft(loop);
-        else
-          steering_->loopLeft(0);
-
-        if(moved) {
-          if (mouseY<=0)
-            steering_->rotateUp(-mouseY*rotate);
-          if (mouseY>0)
-            steering_->rotateDown(mouseY*rotate);
-          if (mouseX>0)
-            steering_->rotateRight(mouseX*rotate);
-          if (mouseX<=0)
-            steering_->rotateLeft(-mouseX*rotate);
-          mouseY = 0;
-          mouseX = 0;
-          moved = false;
-        }
-        else {
-          steering_->rotateUp(0);
-          steering_->rotateDown(0);
-          steering_->rotateRight(0);
-          steering_->rotateLeft(0);
-        }
-
-  		steering_->tick(evt.timeSinceLastFrame);
-
-
-
-//      scenemanager->spacehip->tick(evt.timesincelastframe);
-        //if(mKeyboard->isKeyDown(OIS::KC_ESCAPE))
-          //cout << "maximal MouseX: " << maxMouseX << "\tminMouseX: " << minMouseX << endl;
         if(mode_==PRESENTATION)
-	  server_g->tick(evt.timeSinceLastFrame);
+          server_g->tick(evt.timeSinceLastFrame);
         else if(mode_==CLIENT)
           client_g->tick(evt.timeSinceLastFrame);
+
         usleep(10);
+
+        mKeyboard->capture();
         return !mKeyboard->isKeyDown(OIS::KC_ESCAPE);
       }
 
-      bool mouseMoved(const OIS::MouseEvent &e)
-      {
-        mouseX += e.state.X.rel;
-        mouseY += e.state.Y.rel;
-        if(mouseX>maxMouseX) maxMouseX = mouseX;
-        if(mouseX<minMouseX) minMouseX = mouseX;
-        //cout << "mouseX: " << mouseX << "\tmouseY: " << mouseY << endl;
-        moved = true;
-        return true;
-      }
-
-      bool mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id) { return true; }
-      bool mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id) { return true; }
-
     private:
       gameMode mode_;
-      float speed;
-      float rotate;
-      float loop;
-      float mouseY;
-      float mouseX;
-      float maxMouseX;
-      float minMouseX;
-      bool moved;
       OIS::Keyboard *mKeyboard;
-      OIS::Mouse *mMouse;
       audio::AudioManager*  auMan_;
-      SpaceshipSteering* steering_;
   };
+
   // init static singleton reference of Orxonox
   Orxonox* Orxonox::singletonRef_ = NULL;
@@ -207,6 +119,14 @@
   Orxonox::Orxonox()
   {
-    ogre_ = new GraphicsEngine();
-    dataPath_ = "";
+    this->ogre_ = new GraphicsEngine();
+    this->dataPath_ = "";
+    this->loader_ = 0;
+    this->auMan_ = 0;
+    this->singletonRef_ = 0;
+    this->keyboard_ = 0;
+    this->mouse_ = 0;
+    this->inputManager_ = 0;
+    this->frameListener_ = 0;
+    this->root_ = 0;
   }
 
@@ -240,5 +160,4 @@
     ar.checkArgument("ip", serverIp_, false);
     if(ar.errorHandling()) die();
-
     if(mode == std::string("server"))
     {
@@ -343,8 +262,8 @@
     createRenderWindow();
     initializeResourceGroups();
+    setupInputSystem();
+    Factory::createClassHierarchy();
     createScene();
     setupScene();
-    setupInputSystem();
-    Factory::createClassHierarchy();
     createFrameListener();
     try{
@@ -472,13 +391,10 @@
   void Orxonox::setupScene()
   {
-    SceneManager *mgr = ogre_->getSceneManager();
-
-
-    SceneNode* node = (SceneNode*)mgr->getRootSceneNode()->getChild("OgreHeadNode");
+//    SceneManager *mgr = ogre_->getSceneManager();
+
+
+//    SceneNode* node = (SceneNode*)mgr->getRootSceneNode()->getChild("OgreHeadNode");
 //     SceneNode *node = mgr->getRootSceneNode()->createChildSceneNode("OgreHeadNode", Vector3(0,0,0));
 
-
-    steering_ = new SpaceshipSteering(500, 200, 200, 200);
-    steering_->addNode(node);
 
 /*
@@ -489,21 +405,4 @@
     e->addToSceneNode(node);
 */
-
-    particle::ParticleInterface *w = new particle::ParticleInterface(mgr,"schuss","Orxonox/schuss");
-    w->particleSystem_->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->addToSceneNode(node);
-
-    particle::ParticleInterface *tt = new particle::ParticleInterface(mgr,"twinthruster","Orxonox/engineglow");
-    tt->particleSystem_->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->addToSceneNode(node);
-
   }
 
@@ -542,5 +441,5 @@
 
     //if(mode_!=CLIENT) // just a hack ------- remove this in future
-      frameListener_ = new OrxListener(keyboard_, mouse_, auMan_, steering_, mode_);
+      frameListener_ = new OrxListener(keyboard_, auMan_, mode_);
     ogre_->getRoot()->addFrameListener(frameListener_);
   }
Index: /code/branches/FICN/src/orxonox/orxonox.h
===================================================================
--- /code/branches/FICN/src/orxonox/orxonox.h	(revision 607)
+++ /code/branches/FICN/src/orxonox/orxonox.h	(revision 608)
@@ -10,5 +10,4 @@
 //#include <OgreSingleton.h>
 #include <OgreSceneManager.h>
-
 #include <OIS/OIS.h>
 
@@ -29,5 +28,5 @@
     PRESENTATION
   };
-  
+
   class OrxListener;
 
@@ -42,6 +41,8 @@
       inline SceneManager* getSceneManager() { return ogre_->getSceneManager(); };
       inline GraphicsEngine* getOgrePointer() { return ogre_; };
-      inline SpaceshipSteering* getSteeringPointer() { return steering_; };
       inline audio::AudioManager* getAudioManagerPointer() { return auMan_; };
+      inline OIS::Keyboard* getKeyboard() { return this->keyboard_; }
+      inline OIS::Mouse* getMouse() { return this->mouse_; }
+
     private:
       Orxonox();
@@ -63,11 +64,10 @@
       void createFrameListener();
       void startRenderLoop();
+
     private:
-
       GraphicsEngine*       ogre_;      //!< our dearest graphics engine <3
       std::string           dataPath_;  //!< path to data
       loader::LevelLoader*  loader_;    //!< level loader builds the scene
       audio::AudioManager*  auMan_;     //!< audio manager
-      SpaceshipSteering* 	steering_;
       static Orxonox*       singletonRef_;
       OIS::Keyboard*        keyboard_;
@@ -76,5 +76,5 @@
       OrxListener*          frameListener_;
       Ogre::Root*           root_;
-      
+
       // this is used to identify the mode (server/client/...) we're in
       gameMode              mode_;
