Index: code/trunk/src/orxonox/objects/Ambient.cc
===================================================================
--- code/trunk/src/orxonox/objects/Ambient.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/Ambient.cc	(revision 1502)
@@ -47,5 +47,5 @@
 namespace orxonox
 {
-    ConsoleCommand(Ambient, setAmbientLightTest, AccessLevel::Offline, false).setDefaultValues(ColourValue(1, 1, 1, 1));
+    SetConsoleCommand(Ambient, setAmbientLightTest, false).setDefaultValues(ColourValue(1, 1, 1, 1)).setAccessLevel(AccessLevel::Offline);
 
     CreateFactory(Ambient);
@@ -66,5 +66,5 @@
     bool Ambient::create(){
       GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
-      return true;
+      return Synchronisable::create();
     }
     
Index: code/trunk/src/orxonox/objects/Ambient.h
===================================================================
--- code/trunk/src/orxonox/objects/Ambient.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/Ambient.h	(revision 1502)
@@ -47,5 +47,5 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void setAmbientLight(const ColourValue& colour);
-            bool create();
+            virtual bool create();
             void registerAllVariables();
 
Index: code/trunk/src/orxonox/objects/Camera.cc
===================================================================
--- code/trunk/src/orxonox/objects/Camera.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/Camera.cc	(revision 1502)
@@ -60,4 +60,5 @@
   {
     CameraHandler::getInstance()->releaseFocus(this);
+    GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
   }
 
@@ -75,10 +76,15 @@
   void Camera::tick(float dt)
   {
-    if(this->positionNode_ != NULL) {
+    if (this->positionNode_ != NULL)
+    {
       // this stuff here may need some adjustments
-      Vector3 offset = this->positionNode_->getWorldPosition() - this->cameraNode_->getPosition();
-      this->cameraNode_->translate(15*dt*offset);
+      Vector3 offset = this->positionNode_->getWorldPosition() - this->cameraNode_->getWorldPosition();
+      float coeff = 15.0f * dt;
+      if (coeff > 1.0f)
+        coeff = 1.0f;
 
-      this->cameraNode_->setOrientation(Quaternion::Slerp(0.7, this->positionNode_->getWorldOrientation(), this->cameraNode_->getWorldOrientation(), false));
+      this->cameraNode_->translate(coeff * offset);
+
+      this->cameraNode_->setOrientation(Quaternion::Slerp(7.0f * dt, this->positionNode_->getWorldOrientation(), this->cameraNode_->getWorldOrientation(), false));
     }
   }
Index: code/trunk/src/orxonox/objects/Camera.h
===================================================================
--- code/trunk/src/orxonox/objects/Camera.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/Camera.h	(revision 1502)
@@ -50,4 +50,6 @@
         void setTargetNode(Ogre::SceneNode* obj);
 
+        Ogre::Camera* cam_;
+
         void tick(float dt);
         void update();
@@ -63,5 +65,4 @@
         Ogre::SceneNode* cameraNode_;
         Ogre::Vector3 oldPos;
-        Ogre::Camera* cam_;
         bool bHasFocus_;
     };
Index: code/trunk/src/orxonox/objects/CameraHandler.cc
===================================================================
--- code/trunk/src/orxonox/objects/CameraHandler.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/CameraHandler.cc	(revision 1502)
@@ -26,10 +26,11 @@
  *
  */
+#include "OrxonoxStableHeaders.h"
+#include "CameraHandler.h"
+
 #include <OgreSceneManager.h>
 #include <OgreRenderWindow.h>
 
-#include "OrxonoxStableHeaders.h"
 #include "core/ObjectList.h"
-#include "CameraHandler.h"
 #include "Camera.h"
 #include "GraphicsEngine.h"
Index: code/trunk/src/orxonox/objects/Explosion.cc
===================================================================
--- code/trunk/src/orxonox/objects/Explosion.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/Explosion.cc	(revision 1502)
@@ -79,4 +79,10 @@
         }
     };
+    
+    /*bool Explosion::create(){
+      if(!WorldEntity::create())
+        return false;
+      classID=this->getIdentifier()->getNetworkID();
+    }*/
 
     void Explosion::destroyObject()
Index: code/trunk/src/orxonox/objects/Explosion.h
===================================================================
--- code/trunk/src/orxonox/objects/Explosion.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/Explosion.h	(revision 1502)
@@ -43,4 +43,5 @@
             virtual ~Explosion();
             void destroyObject();
+            virtual bool create(){return WorldEntity::create();}
 
         private:
Index: code/trunk/src/orxonox/objects/Model.cc
===================================================================
--- code/trunk/src/orxonox/objects/Model.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/Model.cc	(revision 1502)
@@ -34,4 +34,10 @@
 #include "GraphicsEngine.h"
 #include "core/XMLPort.h"
+
+#include <OgreEntity.h>
+#include <OgreMesh.h>
+#include <OgreHardwareVertexBuffer.h>
+#include <OgreMeshManager.h>
+
 
 namespace orxonox
@@ -77,4 +83,26 @@
         this->mesh_.setMesh(meshSrc_);
         this->attachObject(this->mesh_.getEntity());
+
+        //HACK!!
+        /*if ((this->meshSrc_ == "assff.mesh") || (this->meshSrc_ == "ast1.mesh") || (this->meshSrc_ == "ast2.mesh") || (this->meshSrc_ == "ast3.mesh") || (this->meshSrc_ == "ast4.mesh") ||(this->meshSrc_ == "ast5.mesh") || (this->meshSrc_ == "ast6.mesh"))
+        {
+          Ogre::MeshPtr pMesh = this->mesh_.getEntity()->getMesh();
+          //set Mesh to tangentspace 
+          unsigned short src, dest;
+          if (!pMesh->suggestTangentVectorBuildParams(Ogre::VES_TANGENT, src, dest))
+          {
+            pMesh->buildTangentVectors(Ogre::VES_TANGENT, src, dest);
+          }
+          if ((this->meshSrc_ == "assff.mesh"))
+          {
+            (this->mesh_.getEntity())->setMaterialName("Assff/BumpMap");
+          }
+          else
+          {
+            (this->mesh_.getEntity())->setMaterialName("Asteroid/BumpMap");
+          }
+
+
+        }*/
         COUT(4) << "Loader (Model.cc): Created model" << std::endl;
       }
Index: code/trunk/src/orxonox/objects/Model.h
===================================================================
--- code/trunk/src/orxonox/objects/Model.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/Model.h	(revision 1502)
@@ -45,5 +45,5 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             void setMesh(const std::string& meshname);
-            bool create();
+            virtual bool create();
 
         protected:
Index: code/trunk/src/orxonox/objects/NPC.cc
===================================================================
--- code/trunk/src/orxonox/objects/NPC.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/NPC.cc	(revision 1502)
@@ -67,8 +67,4 @@
   }
   
-  bool NPC::create(){
-    Model::create();
-    return true;
-  }
 
   /**
Index: code/trunk/src/orxonox/objects/NPC.h
===================================================================
--- code/trunk/src/orxonox/objects/NPC.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/NPC.h	(revision 1502)
@@ -53,5 +53,5 @@
       void setValues(Vector3 location, Vector3 speed, Vector3 acceleration, bool movable);
       void registerAllVariables();
-      bool create();
+      virtual bool create(){return Model::create();}
 
     private:
Index: code/trunk/src/orxonox/objects/Projectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/Projectile.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/Projectile.cc	(revision 1502)
@@ -30,4 +30,6 @@
 #include "Projectile.h"
 
+#include <OgreBillboard.h>
+
 #include "core/CoreIncludes.h"
 #include "core/Executor.h"
@@ -41,4 +43,6 @@
 {
     CreateFactory(Projectile);
+
+    float Projectile::speed_ = 0;
 
     Projectile::Projectile(SpaceShip* owner) :
@@ -63,5 +67,4 @@
 
         this->destroyTimer_.setTimer(this->lifetime_, false, this, createExecutor(createFunctor(&Projectile::destroyObject)));
-        this->classID = this->getIdentifier()->getNetworkID(); // TODO: remove this hack
 //        COUT(3) << this->classID << std::endl;
     }
@@ -92,5 +95,6 @@
                 if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))
                 {
-                    new Explosion(this);
+                    Explosion *exp = new Explosion(this);
+                    exp->create();
                     delete this;
                     return;
@@ -104,3 +108,8 @@
         delete this;
     }
+
+    void Projectile::setColour(const ColourValue& colour)
+    {
+        this->billboard_.getBillboardSet()->getBillboard(0)->setColour(colour);
+    }
 }
Index: code/trunk/src/orxonox/objects/Projectile.h
===================================================================
--- code/trunk/src/orxonox/objects/Projectile.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/Projectile.h	(revision 1502)
@@ -35,4 +35,5 @@
 #include "../tools/BillboardSet.h"
 #include "../tools/Timer.h"
+#include "util/Math.h"
 
 namespace orxonox
@@ -46,9 +47,16 @@
             void destroyObject();
             virtual void tick(float dt);
+            virtual bool create(){return WorldEntity::create();}
+            void setColour(const ColourValue& colour);
+
+            static float getSpeed()
+                { return Projectile::speed_; }
+
+        protected:
+            SpaceShip* owner_;
 
         private:
-            SpaceShip* owner_;
             BillboardSet billboard_;
-            float speed_;
+            static float speed_;
             float lifetime_;
             Timer<Projectile> destroyTimer_;
Index: code/trunk/src/orxonox/objects/RotatingProjectile.cc
===================================================================
--- code/trunk/src/orxonox/objects/RotatingProjectile.cc	(revision 1502)
+++ code/trunk/src/orxonox/objects/RotatingProjectile.cc	(revision 1502)
@@ -0,0 +1,82 @@
+/*
+ *   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 "RotatingProjectile.h"
+
+#include "core/CoreIncludes.h"
+#include "core/ConfigValueIncludes.h"
+#include <OgreBillboard.h>
+
+namespace orxonox
+{
+    CreateFactory(RotatingProjectile);
+
+    RotatingProjectile::RotatingProjectile(SpaceShip* owner) : Projectile(owner)
+    {
+        RegisterObject(RotatingProjectile);
+
+        this->time_ = 0;
+
+        if (/*this->owner_*/true)
+        {
+            this->rotatingBillboard1_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+            this->rotatingBillboard2_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+
+            this->rotatingNode1_ = this->getNode()->createChildSceneNode(this->getName() + "rotating1", Vector3(0, 50, 0));
+            this->rotatingNode2_ = this->getNode()->createChildSceneNode(this->getName() + "rotating2", Vector3(0, -50, 0));
+            this->rotatingNode1_->attachObject(this->rotatingBillboard1_.getBillboardSet());
+            this->rotatingNode2_->attachObject(this->rotatingBillboard2_.getBillboardSet());
+            this->rotatingNode1_->scale(0.3, 0.3, 0.3);
+            this->rotatingNode2_->scale(0.3, 0.3, 0.3);
+        }
+
+        this->setConfigValues();
+    }
+
+    RotatingProjectile::~RotatingProjectile()
+    {
+    }
+
+    void RotatingProjectile::setConfigValues()
+    {
+        SetConfigValue(colour_, ColourValue(1.0, 0.0, 0.0));
+
+        this->rotatingBillboard1_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+        this->rotatingBillboard2_.getBillboardSet()->getBillboard(0)->setColour(this->colour_);
+    }
+
+    void RotatingProjectile::tick(float dt)
+    {
+        this->time_ += dt;
+
+        this->rotatingNode1_->setPosition(0, 50 * sin(this->time_ * 20), 50 * cos(this->time_ * 20));
+        this->rotatingNode2_->setPosition(0, -50 * sin(this->time_ * 20), -50 * cos(this->time_ * 20));
+
+        Projectile::tick(dt);
+    }
+}
Index: code/trunk/src/orxonox/objects/RotatingProjectile.h
===================================================================
--- code/trunk/src/orxonox/objects/RotatingProjectile.h	(revision 1502)
+++ code/trunk/src/orxonox/objects/RotatingProjectile.h	(revision 1502)
@@ -0,0 +1,29 @@
+#ifndef _RotatingProjectile_H__
+#define _RotatingProjectile_H__
+
+#include "../OrxonoxPrereqs.h"
+#include "util/Math.h"
+#include "Projectile.h"
+
+namespace orxonox
+{
+    class _OrxonoxExport RotatingProjectile : public Projectile/*, public network::Synchronisable*/
+    {
+        public:
+            RotatingProjectile(SpaceShip* owner = 0);
+            virtual ~RotatingProjectile();
+            void setConfigValues();
+            virtual void tick(float dt);
+            virtual bool create(){return Projectile::create();}
+
+        private:
+            ColourValue colour_;
+            BillboardSet rotatingBillboard1_;
+            BillboardSet rotatingBillboard2_;
+            Ogre::SceneNode* rotatingNode1_;
+            Ogre::SceneNode* rotatingNode2_;
+            float time_;
+    };
+}
+
+#endif /* _RotatingProjectile_H__ */
Index: code/trunk/src/orxonox/objects/Skybox.cc
===================================================================
--- code/trunk/src/orxonox/objects/Skybox.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/Skybox.cc	(revision 1502)
@@ -90,5 +90,5 @@
     bool Skybox::create(){
       this->setSkybox(skyboxSrc_);
-      return true;
+      return Synchronisable::create();
     }
     
Index: code/trunk/src/orxonox/objects/Skybox.h
===================================================================
--- code/trunk/src/orxonox/objects/Skybox.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/Skybox.h	(revision 1502)
@@ -47,5 +47,5 @@
             void setSkybox(const std::string& skyboxname);
             
-            bool create();
+            virtual bool create();
             void registerAllVariables();
             void setSkyboxSrc(const std::string &src);
Index: code/trunk/src/orxonox/objects/SpaceShip.cc
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShip.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/SpaceShip.cc	(revision 1502)
@@ -45,15 +45,23 @@
 #include "particle/ParticleInterface.h"
 #include "Projectile.h"
+#include "RotatingProjectile.h"
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
 #include "network/Client.h"
+#include "hud/HUD.h"
 
 namespace orxonox
 {
-    ConsoleCommand(SpaceShip, setMaxSpeedTest, AccessLevel::Debug, false);
-    ConsoleCommand(SpaceShip, whereAmI, AccessLevel::User, true);
-    ConsoleCommandGeneric(test1, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed", AccessLevel::Debug), false);
-    ConsoleCommandGeneric(test2, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber", AccessLevel::Debug), false);
-    ConsoleCommandGeneric(test3, SpaceShip, createExecutor(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl", AccessLevel::Debug), false);
+    SetConsoleCommand(SpaceShip, setMaxSpeedTest, false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommand(SpaceShip, whereAmI, true).setAccessLevel(AccessLevel::User);
+    SetConsoleCommand(SpaceShip, moveLongitudinal, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveLateral, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveYaw, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, movePitch, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, moveRoll, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, 1.0f).setAxisParamIndex(0).setKeybindMode(KeybindMode::OnHold);
+    SetConsoleCommand(SpaceShip, fire, true).setAccessLevel(AccessLevel::User).setKeybindMode(KeybindMode::OnHold);
+    SetConsoleCommandGeneric(test1, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxSpeed"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test2, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setMaxBlubber"), false).setAccessLevel(AccessLevel::Debug);
+    SetConsoleCommandGeneric(test3, SpaceShip, createConsoleCommand(createFunctor(&SpaceShip::setMaxSpeedTest), "setRofl"), false).setAccessLevel(AccessLevel::Debug);
 
     CreateFactory(SpaceShip);
@@ -64,10 +72,10 @@
       Iterator<SpaceShip> it;
       for(it = ObjectList<SpaceShip>::start(); it; ++it){
-        if((it)->server_ || ( network::Client::getSingleton() && network::Client::getSingleton()->getShipID()==it->objectID ) )
+        if( (it)->myShip_ )
           return *it;
       }
       return NULL;
     }
-    
+
     SpaceShip::SpaceShip() :
       //testvector_(0,0,0),
@@ -103,5 +111,7 @@
       mouseY_(0.0f),
       emitterRate_(0.0f),
-      server_(false)
+      myShip_(false),
+      teamNr_(0),
+      health_(100)
     {
         RegisterObject(SpaceShip);
@@ -112,4 +122,10 @@
         this->setConfigValues();
 
+        initialDir_ = Vector3(1.0, 0.0, 0.0);
+        currentDir_ = initialDir_;
+        initialOrth_ = Vector3(0.0, 0.0, 1.0);
+        currentOrth_ = initialOrth_;
+
+        this->camName_ = this->getName() + "CamNode";
 
         this->setRotationAxis(1, 0, 0);
@@ -127,7 +143,16 @@
         if (this->cam_)
           delete this->cam_;
+        if (!Identifier::isCreatingHierarchy() && !myShip_ && &HUD::getSingleton()!=NULL)
+          //remove the radar object
+          HUD::getSingleton().removeRadarObject(this->getNode());
     }
 
     bool SpaceShip::create(){
+      if(!myShip_){
+        if(network::Client::getSingleton() && objectID == network::Client::getSingleton()->getShipID())
+          myShip_=true;
+        else
+          HUD::getSingleton().addRadarObject(this->getNode(), 3);
+      }
       if(Model::create())
         this->init();
@@ -153,14 +178,4 @@
     void SpaceShip::init()
     {
-        if ((server_ || ( network::Client::getSingleton() && network::Client::getSingleton()->getShipID()==objectID ) ))
-        {
-              if (!setMouseEventCallback_)
-              {
-                  InputManager::addMouseHandler(this, "SpaceShip");
-                  //InputManager::enableMouseHandler("SpaceShip");
-                  setMouseEventCallback_ = true;
-              }
-        }
-
         // START CREATING THRUSTER
         this->tt_ = new ParticleInterface(GraphicsEngine::getSingleton().getSceneManager(),"twinthruster" + this->getName(),"Orxonox/engineglow");
@@ -200,18 +215,21 @@
         // 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);
+        if (this->isExactlyA(Class(SpaceShip)))
+        {
+            // 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);
+        }
 
         createCamera();
@@ -237,4 +255,8 @@
         CameraHandler::getInstance()->requestFocus(cam_);
 
+    }
+
+    Camera* SpaceShip::getCamera(){
+        return cam_;
     }
 
@@ -295,7 +317,9 @@
         XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, mode);
         XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, mode);
-        server_=true; // TODO: this is only a hack
+        myShip_=true; // TODO: this is only a hack
+
         SpaceShip::create();
-        getFocus();
+        if (this->isExactlyA(Class(SpaceShip)))
+            getFocus();
     }
 
@@ -308,81 +332,4 @@
     }
 
-    void SpaceShip::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
-    {
-/*
-        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(-rel.x * 0.10));
-            this->camNode_->yaw(Degree(rel.y * 0.10));
-        }
-        else
-        {
-            float minDimension = clippingSize.y;
-            if (clippingSize.x < minDimension)
-                minDimension = clippingSize.x;
-
-            this->mouseX_ += rel.x;
-            if (this->mouseX_ < -minDimension)
-                this->mouseX_ = -minDimension;
-            if (this->mouseX_ > minDimension)
-                this->mouseX_ = minDimension;
-
-            this->mouseY_ += rel.y;
-            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);
-        }
-    }
-
-    void SpaceShip::mouseButtonPressed(MouseButton::Enum id)
-    {
-        if (id == MouseButton::Left)
-            this->bLMousePressed_ = true;
-        else if (id == MouseButton::Right)
-            this->bRMousePressed_ = true;
-    }
-
-    void SpaceShip::mouseButtonReleased(MouseButton::Enum id)
-    {
-        if (id == MouseButton::Left)
-            this->bLMousePressed_ = false;
-        else if (id == MouseButton::Right)
-        {
-            this->bRMousePressed_ = false;
-            this->camNode_->resetOrientation();
-        }
-    }
-
     std::string SpaceShip::whereAmI() {
 	return getConvertedValue<float, std::string>(SpaceShip::getLocalShip()->getPosition().x)
@@ -391,10 +338,10 @@
     }
 
-    Vector3 SpaceShip::getSPosition() {
-	return SpaceShip::getLocalShip()->getPosition();
-    }
-
-    Quaternion SpaceShip::getSOrientation() {
-	return SpaceShip::getLocalShip()->getOrientation();
+    Vector3 SpaceShip::getDir() {
+        return currentDir_;
+    }
+
+    Vector3 SpaceShip::getOrth(){
+        return currentOrth_;
     }
 
@@ -403,4 +350,7 @@
     void SpaceShip::tick(float dt)
     {
+        currentDir_ = getOrientation()*initialDir_;
+		currentOrth_ = getOrientation()*initialOrth_;
+
         if (this->cam_)
             this->cam_->tick(dt);
@@ -422,7 +372,15 @@
         if (this->bLMousePressed_ && this->timeToReload_ <= 0)
         {
-          
-            Projectile *p = new Projectile(this);
-            
+
+            Projectile *p;
+            if (this->isExactlyA(Class(SpaceShip)))
+                p = new RotatingProjectile(this);
+            else
+                p = new Projectile(this);
+            p->setColour(this->getProjectileColour());
+            p->create();
+            if(p->classID==0)
+              COUT(3) << "generated projectile with classid 0" <<  std::endl; // TODO: remove this output
+
             p->setBacksync(true);
             this->timeToReload_ = this->reloadTime_;
@@ -495,29 +453,4 @@
         }
 
-        if( (network::Client::getSingleton() &&  network::Client::getSingleton()->getShipID() == objectID) || server_ )
-        {
-          COUT(4) << "steering our ship: " << objectID << std::endl;
-          if (InputManager::isKeyDown(KeyCode::Up) || InputManager::isKeyDown(KeyCode::W))
-            this->acceleration_.x = this->translationAcceleration_;
-          else if(InputManager::isKeyDown(KeyCode::Down) || InputManager::isKeyDown(KeyCode::S))
-            this->acceleration_.x = -this->translationAcceleration_;
-          else
-            this->acceleration_.x = 0;
-
-          if (InputManager::isKeyDown(KeyCode::Right) || InputManager::isKeyDown(KeyCode::D))
-            this->acceleration_.y = -this->translationAcceleration_;
-          else if (InputManager::isKeyDown(KeyCode::Left) || InputManager::isKeyDown(KeyCode::A))
-            this->acceleration_.y = this->translationAcceleration_;
-          else
-            this->acceleration_.y = 0;
-
-          if (InputManager::isKeyDown(KeyCode::Delete) || InputManager::isKeyDown(KeyCode::Q))
-            this->momentum_ = Radian(-this->rotationAccelerationRadian_);
-          else if (InputManager::isKeyDown(KeyCode::PageDown) || InputManager::isKeyDown(KeyCode::E))
-            this->momentum_ = Radian(this->rotationAccelerationRadian_);
-          else
-            this->momentum_ = 0;
-        }/*else
-          COUT(4) << "not steering ship: " << objectID << " our ship: " << network::Client::getSingleton()->getShipID() << std::endl;*/
 
         WorldEntity::tick(dt);
@@ -533,5 +466,70 @@
         else
             this->tt_->setRate(0);
-    }
-
+
+        if( myShip_ )
+        {
+          COUT(4) << "steering our ship: " << objectID << std::endl;
+          this->acceleration_.x = 0;
+          this->acceleration_.y = 0;
+          this->momentum_ = 0;
+          this->mouseXRotation_ = Radian(0);
+          this->mouseYRotation_ = Radian(0);
+          this->bLMousePressed_ = false;
+        }/*else
+          COUT(4) << "not steering ship: " << objectID << " our ship: " << network::Client::getSingleton()->getShipID() << std::endl;*/
+    }
+
+    void SpaceShip::movePitch(float val)
+    {   getLocalShip()->setMovePitch(val);   }
+    void SpaceShip::moveYaw(float val)
+    {   getLocalShip()->setMoveYaw(val);   }
+    void SpaceShip::moveRoll(float val)
+    {   getLocalShip()->setMoveRoll(val);   }
+    void SpaceShip::moveLongitudinal(float val)
+    {   getLocalShip()->setMoveLongitudinal(val);   }
+    void SpaceShip::moveLateral(float val)
+    {   getLocalShip()->setMoveLateral(val);   }
+    void SpaceShip::fire()
+    {   getLocalShip()->doFire();   }
+
+    void SpaceShip::setMovePitch(float val)
+    {
+        val = -val * val * sgn(val) * this->rotationAcceleration_;
+        if (val > this->maxRotation_)
+            val = this->maxRotation_;
+        if (val < -this->maxRotation_)
+            val = -this->maxRotation_;
+        this->mouseYRotation_ = Radian(val);
+    }
+
+    void SpaceShip::setMoveYaw(float val)
+    {
+        val = -val * val * sgn(val) * this->rotationAcceleration_;
+        if (val > this->maxRotation_)
+            val = this->maxRotation_;
+        if (val < -this->maxRotation_)
+            val = -this->maxRotation_;
+        this->mouseXRotation_ = Radian(val);
+    }
+
+    void SpaceShip::setMoveRoll(float val)
+    {
+        this->momentum_ = Radian(-this->rotationAccelerationRadian_ * val);
+        //COUT(3) << "rotating val: " << val << " acceleration: " << this->rotationAccelerationRadian_.valueDegrees() << std::endl;
+    }
+
+    void SpaceShip::setMoveLongitudinal(float val)
+    {
+        this->acceleration_.x = this->translationAcceleration_ * val;
+    }
+
+    void SpaceShip::setMoveLateral(float val)
+    {
+        this->acceleration_.y = -this->translationAcceleration_ * val;
+    }
+
+    void SpaceShip::doFire()
+    {
+        this->bLMousePressed_ = true;
+    }
 }
Index: code/trunk/src/orxonox/objects/SpaceShip.h
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShip.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/SpaceShip.h	(revision 1502)
@@ -41,13 +41,13 @@
 namespace orxonox
 {
-    class _OrxonoxExport SpaceShip : public Model, public MouseHandler
+    class _OrxonoxExport SpaceShip : public Model
     {
         public:
-          
+
             static SpaceShip *getLocalShip();
-            
+
             SpaceShip();
             ~SpaceShip();
-            bool create();
+            virtual bool create();
             void registerAllVariables();
             void init();
@@ -64,25 +64,49 @@
             void setTransDamp(float value);
             void setRotDamp(float value);
+            void getFocus();
 
-            void getFocus();
-            static SpaceShip* instance_s;
-            static Vector3 getSPosition();
-            static Quaternion getSOrientation();
             static std::string whereAmI();
             static void setMaxSpeedTest(float value)
                 { SpaceShip::instance_s->setMaxSpeed(value); }
 
-            void mouseButtonPressed (MouseButton::Enum id);
-            void mouseButtonReleased(MouseButton::Enum id);
-            void mouseButtonHeld    (MouseButton::Enum id) { }
-            void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
-            void mouseScrolled      (int abs, int rel) { }
+            static void movePitch(float value);
+            static void moveYaw(float value);
+            static void moveRoll(float value);
+            static void moveLongitudinal(float value);
+            static void moveLateral(float value);
+            static void fire();
+            void setMovePitch(float value);
+            void setMoveYaw(float value);
+            void setMoveRoll(float value);
+            void setMoveLongitudinal(float value);
+            void setMoveLateral(float value);
+            void doFire();
 
             float getMaxSpeed();
+            Vector3 getDir();
+            Vector3 getOrth();
+            Camera* getCamera();
+
+            int getTeamNr() const
+                { return this->teamNr_; }
+            int getHealth() const
+                { return this->health_; }
+
+            bool getMyShip(){return myShip_;}
+
+        protected:
+            void setTeamNr(int teamNr)
+                { this->teamNr_ = teamNr; }
 
         private:
             void createCamera();
+            virtual ColourValue getProjectileColour() const
+                { return ColourValue(1.0, 1.0, 0.5); }
 
             Vector3 testvector_;
+            Vector3 initialDir_;
+            Vector3 currentDir_;
+            Vector3 initialOrth_;
+            Vector3 currentOrth_;
             bool bInvertYAxis_;
             bool setMouseEventCallback_;
@@ -130,5 +154,12 @@
 
             float emitterRate_;
-            bool server_;
+
+        protected:
+            bool myShip_;
+
+            int teamNr_;
+            int health_;
+
+            static SpaceShip* instance_s;
     };
 }
Index: code/trunk/src/orxonox/objects/SpaceShipAI.cc
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShipAI.cc	(revision 1502)
+++ code/trunk/src/orxonox/objects/SpaceShipAI.cc	(revision 1502)
@@ -0,0 +1,293 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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 "SpaceShipAI.h"
+
+#include <OgreMath.h>
+#include "Projectile.h"
+#include "core/CoreIncludes.h"
+#include "core/Iterator.h"
+#include "core/Executor.h"
+#include "core/ConsoleCommand.h"
+#include "core/XMLPort.h"
+
+#define ACTION_INTERVAL 1.0f
+
+namespace orxonox
+{
+    SetConsoleCommand(SpaceShipAI, createEnemy, true).setDefaultValue(0, 1);
+    SetConsoleCommand(SpaceShipAI, killEnemies, true).setDefaultValue(0, 0);
+
+    CreateFactory(SpaceShipAI);
+
+    SpaceShipAI::SpaceShipAI()
+    {
+        RegisterObject(SpaceShipAI);
+
+        this->alive_ = true;
+        this->setPosition(Vector3(rnd(-1000, 1000), rnd(-1000, 1000), rnd(-1000, 0000)));
+        this->target_ = 0;
+        this->bShooting_ = 0;
+        this->bHasTargetPosition_ = false;
+
+        this->setTeamNr((int)rnd(NUM_AI_TEAMS) % NUM_AI_TEAMS + 1);
+
+        if (NUM_AI_TEAMS > 0)
+            this->teamColours_[1] = ColourValue(1, 0, 0, 1);
+        if (NUM_AI_TEAMS > 1)
+            this->teamColours_[2] = ColourValue(0, 1, 0, 1);
+        if (NUM_AI_TEAMS > 2)
+            this->teamColours_[3] = ColourValue(0, 0, 1, 1);
+
+        for (int i = 4; i <= NUM_AI_TEAMS; ++i)
+            this->teamColours_[i] = ColourValue(rnd(), rnd(), rnd(), 1);
+    }
+
+    void SpaceShipAI::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        SpaceShip::XMLPort(xmlelement, mode);
+        myShip_=true;
+
+        this->actionTimer_.setTimer(ACTION_INTERVAL, true, this, createExecutor(createFunctor(&SpaceShipAI::action)));
+    }
+
+    void SpaceShipAI::createEnemy(int num)
+    {
+        for (int i = 0; i < num; ++i)
+        {
+            SpaceShipAI* newenemy = new SpaceShipAI();
+            newenemy->setMesh("assff.mesh");
+//            newenemy->setPosition(0, 0, 0);
+            newenemy->setScale(10);
+            newenemy->setMaxSpeed(500);
+            newenemy->setMaxSideAndBackSpeed(50);
+            newenemy->setMaxRotation(1.0);
+            newenemy->setTransAcc(200);
+            newenemy->setRotAcc(3.0);
+            newenemy->setTransDamp(75);
+            newenemy->setRotDamp(1.0);
+            Element xmlelement;
+            newenemy->XMLPort(xmlelement, XMLPort::LoadObject);
+        }
+    }
+
+    void SpaceShipAI::killEnemies(int num)
+    {
+        int i = 0;
+        for (Iterator<SpaceShipAI> it = ObjectList<SpaceShipAI>::begin(); it; )
+        {
+            delete *(it++);
+            ++i;
+            if (num && i >= num)
+                break;
+        }
+    }
+
+    ColourValue SpaceShipAI::getProjectileColour() const
+    {
+        return this->teamColours_[this->getTeamNr()];
+    }
+
+    void SpaceShipAI::action()
+    {
+        float random;
+        float maxrand = 100.0f / ACTION_INTERVAL;
+
+        // search enemy
+        random = rnd(maxrand);
+//std::cout << "search enemy: " << random << std::endl;
+        if (random < 20 && (!this->target_))
+        {
+            this->searchNewTarget();
+        }
+
+        // forget enemy
+        random = rnd(maxrand);
+//std::cout << "forget enemy: " << random << std::endl;
+        if (random < 5 && (this->target_))
+        {
+            this->forgetTarget();
+        }
+
+        // next enemy
+        random = rnd(maxrand);
+//std::cout << "next enemy: " << random << std::endl;
+        if (random < 10 && (this->target_))
+        {
+            this->searchNewTarget();
+        }
+
+        // fly somewhere
+        random = rnd(maxrand);
+//std::cout << "fly somewhere: " << random << std::endl;
+        if (random < 40 && (!this->bHasTargetPosition_ && !this->target_))
+        {
+            this->searchNewTargetPosition();
+        }
+
+        // stop flying
+        random = rnd(maxrand);
+//std::cout << "stop flying: " << random << std::endl;
+        if (random < 10 && (this->bHasTargetPosition_ && !this->target_))
+        {
+            this->bHasTargetPosition_ = false;
+        }
+
+        // fly somewhere else
+        random = rnd(maxrand);
+//std::cout << "fly somewhere else: " << random << std::endl;
+        if (random < 30 && (this->bHasTargetPosition_ && !this->target_))
+        {
+            this->searchNewTargetPosition();
+        }
+
+        // shoot
+        random = rnd(maxrand);
+//std::cout << "shoot: " << random << std::endl;
+        if (random < 75 && (this->target_ && !this->bShooting_))
+        {
+            this->bShooting_ = true;
+        }
+
+        // stop shooting
+        random = rnd(maxrand);
+//std::cout << "stop shooting: " << random << std::endl;
+        if (random < 25 && (this->bShooting_))
+        {
+            this->bShooting_ = false;
+        }
+    }
+
+    void SpaceShipAI::tick(float dt)
+    {
+        if (this->target_)
+            this->aimAtTarget();
+
+        if (this->bHasTargetPosition_)
+            this->moveToTargetPosition(dt);
+
+        if (this->bShooting_ && this->isCloseAtTarget(2000) && this->isLookingAtTarget(Ogre::Math::PI / 10.0f))
+            this->doFire();
+
+        SpaceShip::tick(dt);
+    }
+
+    void SpaceShipAI::moveToTargetPosition(float dt)
+    {
+        static Radian RadianZERO(0);
+
+//        float dotprod = (this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(this->targetPosition_ - this->getPosition());
+        Quaternion rotation = (this->getOrientation() * Ogre::Vector3::UNIT_X).getRotationTo(this->targetPosition_ - this->getPosition());
+/*
+std::cout << "scalprod: " << dotprod << std::endl;
+std::cout << "dist: " << this->targetPosition_ - this->getPosition() << std::endl;
+std::cout << "yaw: " << rotation.getYaw().valueRadians() << std::endl;
+std::cout << "pitch: " << rotation.getPitch().valueRadians() << std::endl;
+std::cout << "roll: " << rotation.getRoll().valueRadians() << std::endl;
+*/
+        this->setMoveYaw(-rotation.getRoll().valueRadians());
+        this->setMovePitch(rotation.getYaw().valueRadians());
+
+        if ((this->targetPosition_ - this->getPosition()).length() > 100)
+        {
+            this->setMoveLongitudinal(1);
+        }
+
+    }
+
+    void SpaceShipAI::searchNewTargetPosition()
+    {
+        this->targetPosition_ = Vector3(rnd(-5000,5000), rnd(-5000,5000), rnd(-5000,5000));
+        this->bHasTargetPosition_ = true;
+    }
+
+    void SpaceShipAI::searchNewTarget()
+    {
+        this->targetPosition_ = this->getPosition();
+        this->forgetTarget();
+
+        for (Iterator<SpaceShip> it = ObjectList<SpaceShip>::begin(); it; ++it)
+        {
+            if (it->getTeamNr() != this->getTeamNr())
+            {
+                float speed = this->getVelocity().length();
+                Vector3 distanceCurrent = this->targetPosition_ - this->getPosition();
+                Vector3 distanceNew = it->getPosition() - this->getPosition();
+                if (!this->target_ || it->getPosition().squaredDistance(this->getPosition()) * (1.5f + acos((this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(distanceNew) / speed / distanceNew.length()) / (2 * Ogre::Math::PI))
+                        < this->targetPosition_.squaredDistance(this->getPosition()) * (1.5f + acos((this->getOrientation() * Ogre::Vector3::UNIT_X).dotProduct(distanceCurrent) / speed / distanceCurrent.length()) / (2 * Ogre::Math::PI)))
+                {
+                    this->target_ = (*it);
+                    this->targetPosition_ = it->getPosition();
+                }
+            }
+        }
+   }
+
+    void SpaceShipAI::forgetTarget()
+    {
+        this->target_ = 0;
+        this->bShooting_ = false;
+    }
+
+    void SpaceShipAI::aimAtTarget()
+    {
+        if (!this->target_)
+            return;
+/*
+        Vector3 enemymovement = this->target_->getVelocity();
+        Vector3 distance_normalised = this->target_->getPosition() - this->getPosition();
+        distance_normalised.normalise();
+
+        float scalarprod = enemymovement.dotProduct(distance_normalised);
+        float aimoffset = scalarprod*scalarprod + Projectile::getSpeed() * Projectile::getSpeed() - this->target_->getVelocity().squaredLength();
+        if (aimoffset < 0)
+        {
+            this->bHasTargetPosition_ = false;
+            return;
+        }
+        aimoffset = -scalarprod + sqrt(aimoffset);
+        this->targetPosition_ = enemymovement + distance_normalised * aimoffset;
+        this->bHasTargetPosition_ = true;
+
+        std::cout << "targetpos: " << this->targetPosition_ << std::endl;
+*/
+        this->targetPosition_ = this->target_->getPosition();
+        this->bHasTargetPosition_ = true;
+    }
+
+    bool SpaceShipAI::isCloseAtTarget(float distance)
+    {
+        return (this->getPosition().squaredDistance(this->targetPosition_) < distance*distance);
+    }
+
+    bool SpaceShipAI::isLookingAtTarget(float angle)
+    {
+        return (this->getOrientation() * Ogre::Vector3::UNIT_X).directionEquals(this->targetPosition_ - this->getPosition(), Radian(angle));
+    }
+}
Index: code/trunk/src/orxonox/objects/SpaceShipAI.h
===================================================================
--- code/trunk/src/orxonox/objects/SpaceShipAI.h	(revision 1502)
+++ code/trunk/src/orxonox/objects/SpaceShipAI.h	(revision 1502)
@@ -0,0 +1,76 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   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 _SpaceShipAI_H__
+#define _SpaceShipAI_H__
+
+#include "OrxonoxPrereqs.h"
+
+#include "SpaceShip.h"
+#include "tools/Timer.h"
+#include "util/Math.h"
+
+#define NUM_AI_TEAMS 3
+
+namespace orxonox
+{
+    class SpaceShipAI : public SpaceShip
+    {
+        public:
+            SpaceShipAI();
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            static void createEnemy(int num);
+            static void killEnemies(int num);
+
+        private:
+            virtual void tick(float dt);
+            virtual ColourValue getProjectileColour() const;
+
+            void action();
+
+            void moveToTargetPosition(float dt);
+            void searchNewTargetPosition();
+            void forgetTarget();
+            void searchNewTarget();
+            void aimAtTarget();
+            bool isCloseAtTarget(float distance);
+            bool isLookingAtTarget(float angle);
+
+            Timer<SpaceShipAI> actionTimer_;
+
+            bool alive_;
+            bool bHasTargetPosition_;
+            Vector3 targetPosition_;
+            SpaceShip* target_;
+            bool bShooting_;
+
+            ColourValue teamColours_[NUM_AI_TEAMS + 1];
+    };
+}
+
+#endif /* _SpaceShipAI_H__ */
Index: code/trunk/src/orxonox/objects/WorldEntity.cc
===================================================================
--- code/trunk/src/orxonox/objects/WorldEntity.cc	(revision 1407)
+++ code/trunk/src/orxonox/objects/WorldEntity.cc	(revision 1502)
@@ -85,4 +85,5 @@
             this->rotationRate_ += (dt * this->momentum_);
             this->rotate(this->rotationAxis_, dt * this->rotationRate_);
+            //COUT(3) << "rotationrate: " << this->rotationRate_.valueDegrees() << " momentum: " << this->momentum_.valueDegrees() << std::endl;
         }
     }
@@ -153,8 +154,8 @@
       registerVar( (void*) &(this->bStatic_), sizeof(this->bStatic_), network::DATA, 0x3);
       //register acceleration & momentum
-      registerVar( (void*) &(this->getAcceleration().x), sizeof(this->getAcceleration().x), network::DATA, 0x3);
-      registerVar( (void*) &(this->getAcceleration().y), sizeof(this->getAcceleration().y), network::DATA, 0x3);
-      registerVar( (void*) &(this->getAcceleration().z), sizeof(this->getAcceleration().z), network::DATA, 0x3);
-      registerVar( (void*) &(this->getMomentum()), sizeof(this->getMomentum()), network::DATA);
+//       registerVar( (void*) &(this->getAcceleration().x), sizeof(this->getAcceleration().x), network::DATA, 0x2);
+//       registerVar( (void*) &(this->getAcceleration().y), sizeof(this->getAcceleration().y), network::DATA, 0x2);
+//       registerVar( (void*) &(this->getAcceleration().z), sizeof(this->getAcceleration().z), network::DATA, 0x2);
+//       registerVar( (void*) &(this->getMomentum()), sizeof(this->getMomentum()), network::DATA, 0x2); // only backsync
     }
 
Index: code/trunk/src/orxonox/objects/WorldEntity.h
===================================================================
--- code/trunk/src/orxonox/objects/WorldEntity.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/WorldEntity.h	(revision 1502)
@@ -53,5 +53,5 @@
             virtual void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            inline bool create(){ return true; }
+            virtual inline bool create(){ return Synchronisable::create(); }
 
             void attachWorldEntity(WorldEntity* entity);
Index: code/trunk/src/orxonox/objects/weapon/AmmunitionDump.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/AmmunitionDump.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/weapon/AmmunitionDump.h	(revision 1502)
@@ -60,5 +60,5 @@
 
   protected:
-    inline bool create() { return true; }
+    inline bool create() { return Synchronisable::create(); }
     void registerAllVariables();
 
Index: code/trunk/src/orxonox/objects/weapon/BulletManager.h
===================================================================
--- code/trunk/src/orxonox/objects/weapon/BulletManager.h	(revision 1407)
+++ code/trunk/src/orxonox/objects/weapon/BulletManager.h	(revision 1502)
@@ -60,5 +60,5 @@
 
   protected:
-    inline bool create() { return true; }
+    inline bool create() { return Synchronisable::create(); }
     void registerAllVariables();
 
