Index: /trunk/src/world_entities/space_ships/turbine_hover.cc
===================================================================
--- /trunk/src/world_entities/space_ships/turbine_hover.cc	(revision 7000)
+++ /trunk/src/world_entities/space_ships/turbine_hover.cc	(revision 7000)
@@ -0,0 +1,390 @@
+/*
+   orxonox - the future of 3D-vertical-scrollers
+
+   Copyright (C) 2004 orx
+
+   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, or (at your option)
+   any later version.
+
+### File Specific:
+   main-programmer: Benjamin Grauer
+   co-programmer: ...
+
+*/
+
+#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WORLD_ENTITY
+
+#include "turbine_hover.h"
+
+#include "weapons/weapon_manager.h"
+#include "weapons/test_gun.h"
+#include "weapons/turret.h"
+#include "weapons/cannon.h"
+
+#include "factory.h"
+#include "key_mapper.h"
+#include "event_handler.h"
+#include "state.h"
+
+#include "graphics_engine.h"
+
+using namespace std;
+
+CREATE_FACTORY(TurbineHover, CL_TURBINE_HOVER);
+
+/**
+ *  destructs the turbine_hover, deletes alocated memory
+ */
+TurbineHover::~TurbineHover ()
+{
+  this->setPlayer(NULL);
+}
+
+/**
+ * loads a TurbineHover information from a specified file.
+ * @param fileName the name of the File to load the turbine_hover from (absolute path)
+ */
+TurbineHover::TurbineHover(const char* fileName)
+{
+  this->init();
+  TiXmlDocument doc(fileName);
+
+  if(!doc.LoadFile())
+  {
+    PRINTF(2)("Loading file %s failed for TurbineHover.\n", fileName);
+    return;
+  }
+
+  this->loadParams(doc.RootElement());
+}
+
+/**
+ *  creates a new Spaceship from Xml Data
+ * @param root the xml element containing spaceship data
+
+   @todo add more parameters to load
+*/
+TurbineHover::TurbineHover(const TiXmlElement* root)
+{
+  this->init();
+  if (root != NULL)
+    this->loadParams(root);
+
+  //weapons:
+  Weapon* wpRight = new TestGun(0);
+  wpRight->setName("testGun Right");
+  Weapon* wpLeft = new TestGun(1);
+  wpLeft->setName("testGun Left");
+  Weapon* cannon = dynamic_cast<Weapon*>(Factory::fabricate(CL_HYPERBLASTER));
+
+  cannon->setName("BFG");
+
+  this->addWeapon(wpLeft, 1, 0);
+  this->addWeapon(wpRight,1 ,1);
+  this->addWeapon(cannon, 0, 2);
+
+  this->getWeaponManager()->changeWeaponConfig(1);
+  dynamic_cast<Element2D*>(this->getWeaponManager()->getFixedTarget())->setVisibility( false);
+
+  this->loadModel("models/ships/hoverglider_mainbody.obj");
+}
+
+
+/**
+ * initializes a TurbineHover
+ */
+void TurbineHover::init()
+{
+  //  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
+  this->setClassID(CL_TURBINE_HOVER, "TurbineHover");
+
+  this->loadModel("models/ships/hoverglider_wing.obj", 1.0f, 3);
+  this->loadModel("models/ships/hoverglider_turbine.obj", 1.0f, 4);
+  this->loadModel("models/ships/hoverglider_turbine_rotors.obj", 1.0f, 5);
+
+  bForward = bBackward = bLeft = bRight = bAscend = bDescend = false;
+  mouseSensitivity = 0.005;
+
+  this->rotorSpeed = 1000.0f;
+  this->rotorCycle = 0.0f;
+  this->cameraLook = 0.0f;
+  this->rotation = 0.0f;
+  this->acceleration = 25.0f;
+  this->airFriction = 3.0f;
+
+  // camera - issue
+  this->cameraNode.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  this->cameraNode.addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
+  //this->cameraNode.setParentMode(PNODE_ROTATE_MOVEMENT);
+  this->cameraNode.setParent(this);
+
+  // rotors
+  this->wingNodeLeft.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT );
+  this->wingNodeLeft.addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
+  this->wingNodeLeft.setParent(this);
+  this->wingNodeLeft.setRelCoor(-1.5, -.3, -1.0);
+  this->rotorNodeLeft.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  this->rotorNodeLeft.setParent(&this->wingNodeLeft);
+  this->rotorNodeLeft.setRelCoor(0, 1.0, -2.3);
+
+  this->wingNodeRight.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  this->wingNodeRight.addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
+  this->wingNodeRight.setParent(this);
+  this->wingNodeRight.setRelCoor(-1.5, -0.3, 1.0);
+  this->rotorNodeRight.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  this->rotorNodeRight.setParent(&this->wingNodeRight);
+  this->rotorNodeRight.setRelCoor(0, 1.0, 2.3);
+
+  dynamic_cast<Element2D*>(this->getWeaponManager()->getFixedTarget())->setVisibility( false);
+
+
+  //add events to the eventlist
+  registerEvent(KeyMapper::PEV_FORWARD);
+  registerEvent(KeyMapper::PEV_BACKWARD);
+  registerEvent(KeyMapper::PEV_LEFT);
+  registerEvent(KeyMapper::PEV_RIGHT);
+  registerEvent(KeyMapper::PEV_UP);
+  registerEvent(KeyMapper::PEV_DOWN);
+  registerEvent(KeyMapper::PEV_FIRE1);
+  registerEvent(KeyMapper::PEV_NEXT_WEAPON);
+  registerEvent(KeyMapper::PEV_PREVIOUS_WEAPON);
+  registerEvent(EV_MOUSE_MOTION);
+
+
+  // WEAPON_MANAGER configuration
+  this->getWeaponManager()->setSlotCount(5);
+
+  this->getWeaponManager()->setSlotPosition(0, Vector(-0.28, 1.186, -2.750), &this->wingNodeLeft);
+  this->getWeaponManager()->setSlotCapability(0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+
+  this->getWeaponManager()->setSlotPosition(1, Vector(-0.28, 1.186, 2.750), &this->wingNodeRight);
+  this->getWeaponManager()->setSlotCapability(1, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+
+  this->getWeaponManager()->setSlotPosition(2, Vector(-1.63, .809, -.003));
+  this->getWeaponManager()->setSlotCapability(2, WTYPE_HEAVY);
+
+  /// TODO: THESE ARE TOO MUCH
+  this->getWeaponManager()->setSlotPosition(3, Vector(-1.63, .678, -.652));
+  this->getWeaponManager()->setSlotDirection(3, Quaternion(-24/180 * M_PI, Vector(1,0,0)));
+
+  this->getWeaponManager()->setSlotPosition(4, Vector(-1.63, .678, .652));
+  this->getWeaponManager()->setSlotDirection(4, Quaternion(24/180 * M_PI, Vector(1,0,0)));
+
+  this->cameraNode.setRelCoor(1,5,0);
+  this->getWeaponManager()->getFixedTarget()->setParent(&this->cameraNode);
+  this->getWeaponManager()->getFixedTarget()->setRelCoor(1000,0,0);
+}
+
+/**
+ * loads the Settings of a TurbineHover from an XML-element.
+ * @param root the XML-element to load the Spaceship's properties from
+ */
+void TurbineHover::loadParams(const TiXmlElement* root)
+{
+  WorldEntity::loadParams(root);
+}
+
+
+void TurbineHover::enter()
+{
+  dynamic_cast<Element2D*>(this->getWeaponManager()->getFixedTarget())->setVisibility( true);
+
+  State::getCamera()->setParentSoft(&this->cameraNode);
+  State::getCamera()->setRelCoorSoft(-10, 0,0);
+  State::getCameraTarget()->setParentSoft(&this->cameraNode);
+}
+
+void TurbineHover::leave()
+{
+  dynamic_cast<Element2D*>(this->getWeaponManager()->getFixedTarget())->setVisibility( false);
+  this->detachCamera();
+
+}
+
+
+/**
+ *  effect that occurs after the TurbineHover is spawned
+*/
+void TurbineHover::postSpawn ()
+{
+  //setCollision(new CollisionCluster(1.0, Vector(0,0,0)));
+}
+
+/**
+ *  the action occuring if the turbine_hover left the game
+*/
+void TurbineHover::leftWorld ()
+{}
+
+/**
+ *  this function is called, when two entities collide
+ * @param entity: the world entity with whom it collides
+ *
+ * Implement behaviour like damage application or other miscellaneous collision stuff in this function
+ */
+void TurbineHover::collidesWith(WorldEntity* entity, const Vector& location)
+{}
+
+
+
+/**
+ *  the function called for each passing timeSnap
+ * @param time The timespan passed since last update
+*/
+void TurbineHover::tick (float dt)
+{
+  Playable::tick(dt);
+
+  // spaceship controlled movement
+  this->movement(dt);
+  this->rotorCycle += this->rotorSpeed * dt;
+}
+
+/**
+ *  calculate the velocity
+ * @param time the timeslice since the last frame
+*/
+void TurbineHover::movement (float dt)
+{
+  Vector accel(0.0, 0.0, 0.0);
+  float rotSpeed = .3;
+
+  if( this->bForward )
+  {
+    accel += Vector(this->acceleration, 0, 0);
+  }
+
+  if( this->bBackward )
+  {
+    accel -= Vector(this->acceleration, 0, 0);
+  }
+  if( this->bLeft)
+  {
+    accel -= Vector(0, 0, this->acceleration);
+  }
+
+  if( this->bRight)
+  {
+    accel += Vector(0, 0, this->acceleration);
+  }
+
+  if (this->bAscend )
+  {
+    accel += Vector(0, this->acceleration, 0);
+  }
+  if (this->bDescend )
+  {
+    accel -= Vector(0, this->acceleration, 0);
+  }
+
+  Vector accelerationDir = this->getAbsDir().apply(accel * this->acceleration);
+
+  // this is the air friction (necessary for a smooth control)
+  Vector damping = (this->velocity * this->airFriction);
+
+
+  this->velocity += (accelerationDir - damping)* dt;
+
+  this->shiftCoor (this->velocity * dt);
+  this->rotation = 0.0f;
+
+  this->setRelDirSoft(this->direction * Quaternion(-cameraLook, Vector(0,0,1)), 5);
+
+  this->wingNodeLeft.setRelDirSoft(Quaternion(accel.z * .03 +this->rotation, Vector(1,0,0)), 5);
+  this->rotorNodeLeft.setRelDirSoft(Quaternion(-accel.x * .05+this->rotation + cameraLook, Vector(0,0,1)), 5);
+
+  this->wingNodeRight.setRelDirSoft(Quaternion(accel.z * .03 +this->rotation, Vector(1,0,0)), 5);
+  this->rotorNodeRight.setRelDirSoft(Quaternion(-accel.x*.05 -this->rotation + cameraLook, Vector(0,0,1)), 5);
+}
+
+
+void TurbineHover::draw() const
+{
+  Vector tmpRot;
+  WorldEntity::draw();
+
+  glPushMatrix();
+  /// LEFT SIDE
+  glTranslatef (this->wingNodeLeft.getAbsCoor ().x,
+                this->wingNodeLeft.getAbsCoor ().y,
+                this->wingNodeLeft.getAbsCoor ().z);
+  tmpRot = this->wingNodeLeft.getAbsDir().getSpacialAxis();
+  glRotatef (this->wingNodeLeft.getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
+  this->getModel(3)->draw();
+  glPopMatrix ();
+
+  glPushMatrix();
+  glTranslatef (this->rotorNodeLeft.getAbsCoor ().x,
+                this->rotorNodeLeft.getAbsCoor ().y,
+                this->rotorNodeLeft.getAbsCoor ().z);
+  tmpRot = this->rotorNodeLeft.getAbsDir().getSpacialAxis();
+  glRotatef (this->rotorNodeLeft.getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
+  this->getModel(4)->draw();
+  glRotatef(this->rotorCycle, 0,1,0);
+  this->getModel(5)->draw();
+  glPopMatrix ();
+
+  /// RIGHT SIDE
+  glPushMatrix();
+  glTranslatef (this->wingNodeRight.getAbsCoor ().x,
+                this->wingNodeRight.getAbsCoor ().y,
+                this->wingNodeRight.getAbsCoor ().z);
+  tmpRot = this->wingNodeRight.getAbsDir().getSpacialAxis();
+  glRotatef (this->wingNodeRight.getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
+  glScalef(1,1,-1);
+  this->getModel(3)->draw();
+  glPopMatrix ();
+
+  glPushMatrix();
+  glTranslatef (this->rotorNodeRight.getAbsCoor ().x,
+                this->rotorNodeRight.getAbsCoor ().y,
+                this->rotorNodeRight.getAbsCoor ().z);
+  tmpRot = this->rotorNodeRight.getAbsDir().getSpacialAxis();
+  glRotatef (this->rotorNodeRight.getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
+  glScalef(1,1,-1);
+  this->getModel(4)->draw();
+  glRotatef(this->rotorCycle, 0,1,0);
+  this->getModel(5)->draw();
+  glPopMatrix ();
+}
+
+/**
+ * @todo switch statement ??
+ */
+void TurbineHover::process(const Event &event)
+{
+  Playable::process(event);
+
+  if( event.type == KeyMapper::PEV_LEFT)
+    this->bLeft = event.bPressed;
+  else if( event.type == KeyMapper::PEV_RIGHT)
+    this->bRight = event.bPressed;
+  else if( event.type == KeyMapper::PEV_UP)
+    this->bAscend = event.bPressed; //this->shiftCoor(0,.1,0);
+  else if( event.type == KeyMapper::PEV_DOWN)
+    this->bDescend = event.bPressed; //this->shiftCoor(0,-.1,0);
+  else if( event.type == KeyMapper::PEV_FORWARD)
+    this->bForward = event.bPressed; //this->shiftCoor(0,.1,0);
+  else if( event.type == KeyMapper::PEV_BACKWARD)
+    this->bBackward = event.bPressed; //this->shiftCoor(0,-.1,0);
+  else if( event.type == EV_MOUSE_MOTION)
+  {
+    float xMouse, yMouse;
+    xMouse = event.xRel*mouseSensitivity;
+    yMouse = event.yRel*mouseSensitivity;
+
+    // rotate the Player around the y-axis
+    this->direction *= Quaternion(-M_PI/4.0*xMouse, Vector(0,1,0));
+    this->rotation += xMouse;
+
+    this->cameraLook += yMouse;
+    // rotate the Camera around the z-axis
+    if (cameraLook > M_PI_4)
+      cameraLook = M_PI_4;
+    else if (cameraLook < -M_PI_4)
+      cameraLook = -M_PI_4;
+    //this->cameraNode.setRelDirSoft(this->direction,10);
+  }
+}
Index: /trunk/src/world_entities/space_ships/turbine_hover.h
===================================================================
--- /trunk/src/world_entities/space_ships/turbine_hover.h	(revision 7000)
+++ /trunk/src/world_entities/space_ships/turbine_hover.h	(revision 7000)
@@ -0,0 +1,71 @@
+
+/*!
+ * @file turbine_hover.h
+ * Implements the Control of a TurbineHover
+ */
+
+#ifndef _TURBINE_HOVER_H
+#define _TURBINE_HOVER_H
+
+#include "playable.h"
+
+class TurbineHover : public Playable
+{
+  public:
+
+    TurbineHover(const char* fileName);
+    TurbineHover(const TiXmlElement* root = NULL);
+    virtual ~TurbineHover();
+
+    virtual void loadParams(const TiXmlElement* root);
+
+    virtual void enter();
+    virtual void leave();
+
+    virtual void postSpawn();
+    virtual void leftWorld();
+
+    virtual void collidesWith(WorldEntity* entity, const Vector& location);
+    virtual void tick(float dt);
+    virtual void draw() const;
+
+    virtual void process(const Event &event);
+
+  private:
+    void init();
+    void movement(float dt);
+
+  private:
+    bool                  bForward;           //!< forward button pressed.
+    bool                  bBackward;          //!< backward button pressed.
+    bool                  bLeft;              //!< left button pressed.
+    bool                  bRight;             //!< right button pressed.
+    bool                  bAscend;            //!< ascend button pressed.
+    bool                  bDescend;           //!< descend button presses.
+
+    int                   yInvert;
+    float                 mouseSensitivity;   //!< the mouse sensitivity
+
+    PNode                 wingNodeLeft;
+    PNode                 wingNodeRight;
+    PNode                 rotorNodeLeft;
+    PNode                 rotorNodeRight;
+
+    PNode                 cameraNode;
+    float                 cameraLook;
+    float                 rotation;
+
+    Vector                velocity;           //!< the velocity of the TurbineHover.
+    Quaternion            direction;          //!< the direction of the TurbineHover.
+    float                 travelSpeed;        //!< the current speed of the Hove (to make soft movement)
+    float                 acceleration;       //!< the acceleration of the TurbineHover.
+    float                 airFriction;        //!< AirFriction.
+
+    float                 rotorSpeed;         //!< the speed of the rotor.
+    float                 rotorCycle;         //!< The Cycle the rotor is in.
+
+    float                 airViscosity;
+
+};
+
+#endif /* _TURBINE_HOVERS_H */
