Changeset 10362 in orxonox.OLD for branches/playability.new

Timestamp:

Jan 25, 2007, 3:05:01 AM (17 years ago)

Author:

patrick

Message:

merged playability. but got strange bug

Location:

branches/playability.new

Files:

• . (modified) (1 prop)
• ChangeLog (modified) (1 diff)
• src/lib/coord/p_node.h (modified) (2 diffs)
• src/lib/graphics/importer/vertex_array_model.cc (modified) (1 diff)
• src/lib/gui/gl/glgui_bar.cc (modified) (2 diffs)
• src/lib/gui/gl/glgui_box.cc (modified) (4 diffs)
• src/lib/gui/gl/glgui_widget.cc (modified) (1 diff)
• src/lib/gui/gl/glgui_widget.h (modified) (1 diff)
• src/lib/math/curve.cc (modified) (2 diffs)
• src/lib/math/curve.h (modified) (1 diff)
• src/lib/util/loading/fast_factory.cc (modified) (1 diff)
• src/story_entities/game_world.cc (modified) (1 diff)
• src/story_entities/menu/game_menu.cc (modified) (1 diff)
• src/util/Makefile.am (modified) (2 diffs)
• src/util/hud.cc (modified) (12 diffs)
• src/util/hud.h (modified) (5 diffs)
• src/util/state.h (modified) (2 diffs)
• src/util/track/track_manager.cc (modified) (14 diffs)
• src/util/track/track_manager.h (modified) (2 diffs)
• src/util/track/track_node.cc (modified) (2 diffs)
• src/util/track/track_node.h (modified) (2 diffs)
• src/world_entities/Makefile.am (modified) (1 diff)
• src/world_entities/WorldEntities.am (modified) (10 diffs)
• src/world_entities/camera.cc (modified) (6 diffs)
• src/world_entities/camera.h (modified) (5 diffs)
• src/world_entities/elements/glgui_energywidget.h (modified) (1 diff)
• src/world_entities/elements/glgui_radar.cc (modified) (1 diff)
• src/world_entities/particles/particle_emitter.h (modified) (2 diffs)
• src/world_entities/playable.cc (modified) (1 diff)
• src/world_entities/playable.h (modified) (3 diffs)
• src/world_entities/player.cc (modified) (4 diffs)
• src/world_entities/player.h (modified) (2 diffs)
• src/world_entities/projectiles/projectile.cc (modified) (5 diffs)
• src/world_entities/projectiles/projectile.h (modified) (4 diffs)
• src/world_entities/space_ships/space_ship.cc (modified) (16 diffs)
• src/world_entities/space_ships/space_ship.h (modified) (6 diffs)
• src/world_entities/space_ships/spacecraft_2d.cc (modified) (1 diff)
• src/world_entities/space_ships/spacecraft_2d.h (modified) (1 diff)
• src/world_entities/test_entity.cc (modified) (2 diffs)
• src/world_entities/weapons/weapon.cc (modified) (14 diffs)
• src/world_entities/weapons/weapon.h (modified) (7 diffs)
• src/world_entities/weapons/weapon_manager.cc (modified) (8 diffs)
• src/world_entities/weapons/weapon_manager.h (modified) (4 diffs)
• src/world_entities/world_entity.cc (modified) (9 diffs)
• src/world_entities/world_entity.h (modified) (6 diffs)

branches/playability.new

@@ -10 +10 @@
 autom4te.cache
 aclocal.m4
+tags
+test.bmp
+config.sub
+config.guess
+OrxonoxPlayability.kdevses
+OrxonoxPlayability.kdevelop.pcs

@@ -10 +10 @@
 autom4te.cache
 aclocal.m4
+tags
+test.bmp
+config.sub
+config.guess
+OrxonoxPlayability.kdevses
+OrxonoxPlayability.kdevelop.pcs

branches/playability.new/ChangeLog

@@ +1 @@
+2006-12-17 Nicolas Schlumberger <nicolasc@ee.ethz.ch>
+  Added guiding sysmte for swarm missile
+  updated drawing function, to draw in the correct direction
+
+2006-12-16  Marc Schärer <marcscha@ee.ethz.ch>
+  Addition trail system
+  Experiment with explosion class on SpaceShip.
+  Sadly, collision problems still persist. need to be solved until wednesday 2006-12-20
+
+2006-12-03  Nicolas Schlumberger <nicolasc@ee.ethz.ch>
+  Added Rotation to hbolt
+  Did some experimenting with test_entity2 (rotation, texturing)
+  Added textured versions of bolt, and hbolt
+
+2006-12-03  Marc Schärer <marcscha@ee.ethz.ch>
+  Added functionality to show / hide a crosshair to the weapon manager. No default crosshair anymore
+  Multiple weapons per ship added
+  Several small tweaks needed to make the above working added
+  Addition of SwarmMissile and SwarmProjectile
+
+2006-11-29  Nicolas Schlumbgerger <nicolasc@ee.ethz.ch>
+  Added bolt projectile for light blaster, copied of laser
+  Added hbolt projectile for heavy blaster, copied of laser
+  Added bolt model, currently untextured
+  Added hbolt model, currently untextured
+
+2006-11-28      Marc Schärer <marcscha@ee.ethz.ch>
+        Mapped primary weapon manager back to playable default weapon manager.
+        Addition of secondary weapon manager for special weapon. Currently uses Cannon to show and test this functionality.
+        Implementation of weapon energy regeneration. This needed some little modifications to the HUD class as well but now works :)
+        Addition of the second weapon manager to the HUD manager in util/hud .h .cc for our master of HUD ;-)
+
 2006-09-22      Benjamin Grauer <bensch@orxonox.net>
         Complete reimplementation of the ResourceManager.

branches/playability.new/src/lib/coord/p_node.h

@@ -98 +98 @@
   inline const Vector& getRelCoor () const { return this->prevRelCoordinate; };
   /** @returns the Relative Coordinate Destination */
-inline const Vector& getRelCoorSoft2D() const { return (this->toCoordinate)? *this->toCoordinate : this->relCoordinate; };
+  inline const Vector& getRelCoorSoft2D() const { return (this->toCoordinate)? *this->toCoordinate : this->relCoordinate; };
   void setAbsCoor (const Vector& absCoord);
   void setAbsCoor (float x, float y, float z);
@@ -133 +133 @@
   inline const Quaternion& getRelDir () const { return this->prevRelDirection; };
   /** @returns the Relative Directional Destination */
-inline const Quaternion& getRelDirSoft2D() const { return (this->toDirection)? *this->toDirection : this->relDirection; };
+  inline const Quaternion& getRelDirSoft2D() const { return (this->toDirection)? *this->toDirection : this->relDirection; };
   /** @returns a Vector pointing into the relative Direction */
   inline Vector getRelDirV() const { return this->prevRelDirection.apply(Vector(0,1,0)); };

branches/playability.new/src/lib/graphics/importer/vertex_array_model.cc

@@ -260 +260 @@
                             ((float)j - (float)resolutionY/2.0)/(float)resolutionY * sizeY);
           this->addNormal(0.0, 1, 0.0);
-          this->addTexCoor((float)i/(float)resolutionX, (float)j/(float)resolutionY);
+          this->addTexCoor((float)i/(float)(resolutionY-1), (float)j/(float)(resolutionX-1));
           this->addColor(1.0, 1.0, 1.0);
         }

branches/playability.new/src/lib/gui/gl/glgui_bar.cc

@@ -71 +71 @@
 
     this->_value = value;
-    this->_frontRect.setSize((this->getSizeX2D() - borderLeft() - borderRight()) * (_value -_minimum)/ (_minimum + _maximum)
+    this->_frontRect.setSize((this->getSizeX2D() - borderLeft() - borderRight()) * (_value - _minimum) / (_maximum -_minimum)
         ,this->getSizeY2D() - borderTop() - borderBottom());
   }
@@ -99 +99 @@
 
     this->_frontRect.setTopLeft(borderLeft(), borderTop());
-    this->_frontRect.setSize((this->getSizeX2D() - borderLeft() - borderRight()) * (_value -_minimum)/ (_minimum + _maximum)
-                             ,this->getSizeY2D() - borderTop() - borderBottom());
+    this->_frontRect.setSize((this->getSizeX2D() - borderLeft() - borderRight()) * (_value - _minimum) / (_maximum -_minimum)
+        ,this->getSizeY2D() - borderTop() - borderBottom());
 
   }

branches/playability.new/src/lib/gui/gl/glgui_box.cc

@@ -18 +18 @@
 #include "glgui_box.h"
 #include <cassert>
+#include <iostream>
 #include "debug.h"
+#include "network_log.h"
+
 
 namespace OrxGui
@@ -177 +180 @@
   void GLGuiBox::resize()
   {
-    if (orientation() == OrxGui::Vertical)
+    if (this->orientation() == OrxGui::Vertical)
     {
       float height = borderTop();
@@ -186 +189 @@
       for (widget = this->_children.begin(); widget != this->_children.end(); ++widget)
       {
-        (*widget)->setRelCoor2D(borderLeft(), height);
-        height += (*widget)->getSizeY2D();
-        width = fmax(width, (*widget)->getSizeX2D());
+        //float radDir = (*widget)->getAbsDir2D() * 2 * M_PI / 360;
+        //float realSizeX = fabsf((*widget)->getSizeX2D() * cosf(radDir)) + fabsf((*widget)->getSizeY2D() * sinf(radDir));
+        //float realSizeY = fabsf((*widget)->getSizeX2D() * sinf(radDir)) + fabsf((*widget)->getSizeY2D() * cosf(radDir));
+        float realSizeX, realSizeY;
+        int angleAbs = (int)(*widget)->getAbsDir2D();
+        int angleRel = (int)(*widget)->getRelDir2D();
+        //std::cout << "absangle: " << angleAbs << ", relangle: " << angleRel << '\n';
+        if ((*widget)->getAbsDir2D() == 0 || (*widget)->getAbsDir2D() == 180)
+        {
+          realSizeX = (*widget)->getSizeX2D();
+          realSizeY = (*widget)->getSizeY2D();
+          //std::cout<<"box vertical, widget 0or180";
+        }
+        else if ((*widget)->getAbsDir2D() == 90 || (*widget)->getAbsDir2D() == 270)
+        {
+          realSizeX = (*widget)->getSizeY2D();
+          realSizeY = (*widget)->getSizeX2D();
+          //std::cout<<"box vertical, widget 90or270";
+        }
+
+        (*widget)->setRelCoor2D(borderLeft(), height + borderTop());
+        height += realSizeY;
+        width = fmax(width, realSizeX);
       }
 
@@ -205 +228 @@
       for (widget = this->_children.begin(); widget != this->_children.end(); ++widget)
       {
+        //float radDir = (*widget)->getAbsDir2D() * 2 * M_PI / 360;
+        //std::cout << "size X: " << (*widget)->getSizeX2D() << "size Y: " << (*widget)->getSizeY2D() << '\n';
+        //float realSizeX = fabsf((*widget)->getSizeX2D() * cosf(radDir)) + fabsf((*widget)->getSizeY2D() * sinf(radDir));
+        //float realSizeY = fabsf((*widget)->getSizeX2D() * sinf(radDir)) + fabsf((*widget)->getSizeY2D() * cosf(radDir));
+        float realSizeX, realSizeY;
+        int angleAbs = (int)(*widget)->getAbsDir2D();
+        int angleRel = (int)(*widget)->getRelDir2D();
+        //std::cout << "absangle: " << angleAbs << ", relangle: " << angleRel << '\n';
+        if ((*widget)->getAbsDir2D() == 0 || (*widget)->getAbsDir2D() == 180)
+        {
+          realSizeX = (*widget)->getSizeX2D();
+          realSizeY = (*widget)->getSizeY2D();
+          //std::cout<<"box horicontal, widget 0or180";
+        }
+        else if ((*widget)->getAbsDir2D() == 90 || (*widget)->getAbsDir2D() == 270)
+        {
+          realSizeX = (*widget)->getSizeY2D();
+          realSizeY = (*widget)->getSizeX2D();
+          //std::cout<<"box horicontal, widget 90or270";
+        }
+
         (*widget)->setRelCoor2D(width, borderTop());
-        height = fmax(height, (*widget)->getSizeY2D());
-        width += (*widget)->getSizeX2D();
+        height = fmax(height, realSizeY);
+        width += realSizeX;
       }
 

branches/playability.new/src/lib/gui/gl/glgui_widget.cc

@@ -915 +915 @@
   }
 
+  void GLGuiWidget::beginDraw() const 
+  { 
+    glPushMatrix(); 
+    glTranslatef(this->getAbsCoor2D().x, this->getAbsCoor2D().y, 0);
+    glRotatef(this->getAbsDir2D(), 0, 0, 1);
+  }
+
 
 }

branches/playability.new/src/lib/gui/gl/glgui_widget.h

@@ -244 +244 @@
 
     /// RENDERING
-    inline void beginDraw() const { glPushMatrix(); glTranslatef(this->getAbsCoor2D().x, this->getAbsCoor2D().y, 0); };
+    void beginDraw() const;
     inline void endDraw() const { glPopMatrix(); };
 

branches/playability.new/src/lib/math/curve.cc

@@ -142 +142 @@
     tmpNode = tmpNode->next;
   return tmpNode->position;
+}
+
+/**
+ * This function returns an approximation of the length of the curve
+ *
+*/
+float Curve::getLength()
+{
+      float length = 0;
+      PathNode* tmpNode = this->firstNode;
+      for(int i = 1; i < this->nodeCount; i++)
+      {
+              length += Vector(tmpNode->next->position - tmpNode->position).len();
+      }
+      return length;
 }
 
@@ -273 +288 @@
 Vector BezierCurve::calcDir (float t)
 {
-  return this->dirCurve->calcPos(t);
+  return this->calcPos(t + 0.01) - this->calcPos(t);
+  //return this->dirCurve->calcPos(t);
 }
 

branches/playability.new/src/lib/math/curve.h

@@ -47 +47 @@
   /** @returns the directional Curve */
   Curve* getDirCurve() const { return this->dirCurve; };
+  float getLength();
 
   /** @param t the value on the curve [0-1] @returns Vector to the position */

branches/playability.new/src/lib/util/loading/fast_factory.cc

@@ -157 +157 @@
 void FastFactory::flush(bool hardFLUSH)
 {
+hardFLUSH = false; // HACK
   FastObjectMember* tmpMember = this->deadList, *delMember = NULL;
   while (tmpMember != NULL)

branches/playability.new/src/story_entities/game_world.cc

@@ -359 +359 @@
       this->dataTank->localPlayer->getPlayable()->setPlaymode(playmode))
   {
-    PRINTF(4)("Set Playmode to %d:%s\n", playmode, Playable::playmodeToString(playmode).c_str());
+    PRINTF(0)("Set Playmode to %d:%s\n", playmode, Playable::playmodeToString(playmode).c_str());
   }
   else
   {
-    PRINTF(2)("Unable to set Playmode %d:'%s'\n", playmode, Playable::playmodeToString(playmode).c_str());
+    PRINTF(0)("Unable to set Playmode %d:'%s'\n", playmode, Playable::playmodeToString(playmode).c_str());
   }
 }

branches/playability.new/src/story_entities/menu/game_menu.cc

@@ -111 +111 @@
 
   this->dataTank->localCamera->setRelCoor(this->cameraVector);
+  //this->dataTank->localCamera->setFovy(60);
 
   GraphicsEngine::getInstance()->displayFPS(false);

branches/playability.new/src/util/Makefile.am

@@ -26 +26 @@
                         animation/animation_player.cc \
                         \
-                        track/pilot_node.cc
-
-#                       track/track_manager.cc \
+                        track/pilot_node.cc \
+                        track/track.cc \
+                        track/track_manager.cc \
                         track/track_node.cc
 
@@ -52 +52 @@
                         animation/t_animation.h \
                         \
-                        track/pilot_node.h
+                        track/pilot_node.h \
+                        track/track.h \
+                        track/track_manager.h \
+                        track/track_node.h
 
-#                       track/track_manager.h \
-                        track/track_node.h

branches/playability.new/src/util/hud.cc

@@ -23 +23 @@
 #include "world_entities/weapons/weapon_manager.h"
 #include "glgui_widget.h"
+#include "glgui_box.h"
+#include "glgui_bar.h"
+#include "elements/glgui_energywidgetvertical.h"
 
 #include "glgui_inputline.h"
 #include "specials/glgui_notifier.h"
 #include "elements/glgui_radar.h"
+#include "world_entities/space_ships/space_ship.h"
 
 
@@ -45 +49 @@
   //this->setSize2D(
   this->weaponManager = NULL;
+  this->weaponManagerSecondary = NULL;
   this->energyWidget = NULL;
   this->shieldWidget = NULL;
   this->armorWidget = NULL;
+  //this->leftRect = NULL;
+  //this->rightRect = NULL;
   this->resX = 1;
   this->resY = 1;
+
+  this->overlayPercentage = 40;
+  this->overlayActive = false;
+  this->rightRect = new OrxGui::GLGuiImage();
+  this->leftRect = new OrxGui::GLGuiImage();
 
   this->inputLine = new OrxGui::GLGuiInputLine();
@@ -58 +70 @@
 
   this->_radar = new OrxGui::GLGuiRadar();
+  this->radarCenterNode = NULL;
 
   this->subscribeEvent(ES_ALL, EV_VIDEO_RESIZE);
   this->subscribeEvent(ES_ALL, SDLK_TAB);
 
-
+  //this->shipValuesBox = NULL;
 }
 
@@ -75 +88 @@
 
   delete this->_radar;
+  delete this->rightRect;
+  delete this->leftRect;
+  //if (this->shipValuesBox != NULL)
+    //delete this->shipValuesBox;
+
   // delete what has to be deleted here
 }
@@ -94 +112 @@
 void Hud::setEnergyWidget(OrxGui::GLGuiWidget* widget)
 {
+  //if (this->shipValuesBox == NULL)
+    //this->createShipValuesBox();
+
   // decopple old widget
   if (this->energyWidget != NULL)
@@ -103 +124 @@
   if (this->energyWidget != NULL)
   {
+    //this->energyWidget->shiftDir2D(270);
+    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setDisplayedName("Electronics");
+    //this->shipValuesBox->pack(this->energyWidget);
+    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setStandardSettings();
+    this->energyWidget->setParent2D(this->leftRect);
     this->energyWidget->show();
-    this->energyWidget->setBackgroundTexture( "hud_energy_background.png");
     /*    this->energyWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
         this->energyWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
@@ -113 +138 @@
 
 void Hud::setShiledWidget(OrxGui::GLGuiWidget* widget)
-{}
+{
+  /*
+  if (this->shipValuesBox == NULL)
+    this->createShipValuesBox();
+  */
+
+  // decopple old widget
+  if (this->shieldWidget != NULL)
+  {
+    this->shieldWidget->hide();
+  }
+
+  this->shieldWidget = widget;
+  if (this->shieldWidget != NULL)
+  {
+    //this->shieldWidget->shiftDir2D(270);
+    //this->shipValuesBox->pack(this->shieldWidget);
+    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->shieldWidget)->setStandardSettings();
+    this->shieldWidget->setParent2D(this->leftRect);
+    this->shieldWidget->show();
+    /*    this->shieldWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
+        this->shieldWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
+  }
+  else
+    printf("schild im hud nicht uebergeben!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+  this->updateResolution();
+}
 
 void Hud::setArmorWidget(OrxGui::GLGuiWidget* widget)
-{}
-
-void Hud::setWeaponManager(WeaponManager* weaponMan)
-{
+{
+  /*
+  if (this->shipValuesBox == NULL)
+    this->createShipValuesBox();
+  */
+
+// decopple old widget
+  if (this->armorWidget != NULL)
+  {
+    this->armorWidget->hide();
+  }
+
+  this->armorWidget = widget;
+  if (this->armorWidget != NULL)
+  {
+    //this->armorWidget->shiftDir2D(270);
+    //this->shipValuesBox->pack(this->armorWidget);
+    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->armorWidget)->setStandardSettings();
+    this->armorWidget->setParent2D(this->leftRect);
+    this->armorWidget->show();
+    /*    this->armorWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
+        this->armorWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
+  }
+
+  this->updateResolution();
+}
+
+void Hud::setWeaponManager(WeaponManager* weaponMan, WeaponManager* weaponManSec)
+{
+  //clearWeaponManager();
+
+  //Hide all widgets
   if (this->weaponManager != NULL)
   {
@@ -128 +208 @@
       {
         weapon->getEnergyWidget()->hide();
-        this->weaponsWidgets.remove(weapon->getEnergyWidget());
+        //this->weaponsWidgetsPrim.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
       }
     }
   }
 
+  if (this->weaponManagerSecondary != NULL)
+  {
+    for (unsigned int i = 0; i < this->weaponManagerSecondary->getSlotCount(); i++)
+    {
+      Weapon* weapon = this->weaponManagerSecondary->getWeapon(i);
+      if (weapon != NULL)
+      {
+        weapon->getEnergyWidget()->hide();
+        //this->weaponsWidgetsSec.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
+      }
+    }
+  }
+
   this->weaponManager = weaponMan;
+  this->weaponManagerSecondary = weaponManSec; 
 
   this->updateWeaponManager();
@@ -139 +233 @@
 }
 
+/*
+void Hud::clearWeaponManager()
+{
+  //Hide all widgets
+  if (this->weaponManager != NULL)
+  {
+    for (unsigned int i = 0; i < this->weaponManager->getSlotCount(); i++)
+    {
+      Weapon* weapon = this->weaponManager->getWeapon(i);
+      if (weapon != NULL)
+      {
+        weapon->getEnergyWidget()->hide();
+        //this->weaponsWidgetsPrim.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
+      }
+    }
+  }
+
+  if (this->weaponManagerSecondary != NULL)
+  {
+    for (unsigned int i = 0; i < this->weaponManagerSecondary->getSlotCount(); i++)
+    {
+      Weapon* weapon = this->weaponManagerSecondary->getWeapon(i);
+      if (weapon != NULL)
+      {
+        weapon->getEnergyWidget()->hide();
+        //this->weaponsWidgetsSec.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
+      }
+    }
+  }
+
+  //this->weaponsWidgetsPrim.clear();
+  //this->weaponsWidgetsSec.clear();
+}
+*/
+
 void Hud::updateWeaponManager()
 {
   // hide all the Widgets
-  std::list<OrxGui::GLGuiWidget*>::iterator weaponWidget;
-  for (weaponWidget = this->weaponsWidgets.begin(); weaponWidget != this->weaponsWidgets.end(); weaponWidget++)
+  
+  std::list<OrxGui::GLGuiEnergyWidgetVertical*>::iterator weaponWidget;
+  for (weaponWidget = this->weaponsWidgetsPrim.begin(); weaponWidget != this->weaponsWidgetsPrim.end(); weaponWidget++)
   {
     (*weaponWidget)->hide();
   }
-  this->weaponsWidgets.clear();
+  this->weaponsWidgetsPrim.clear();
+
+  for (weaponWidget = this->weaponsWidgetsSec.begin(); weaponWidget != this->weaponsWidgetsSec.end(); weaponWidget++)
+  {
+    (*weaponWidget)->hide();
+  }
+  this->weaponsWidgetsSec.clear();
+  
 
   // add all that we need again.
+
   if (this->weaponManager != NULL)
     for (unsigned int i = 0; i < this->weaponManager->getSlotCount(); i++)
@@ -157 +295 @@
       {
         //PRINTF(0)("WEAPON %s::%s in Slots\n", weapon->getClassCName(), weapon->getName());
+        weapon->getEnergyWidget()->setParent2D(this->rightRect);
         weapon->getEnergyWidget()->show();
         weapon->getEnergyWidget()->setBackgroundColor(Color(.8,.2,.11, 0.1));
         weapon->getEnergyWidget()->setFrontColor(Color( .2,.5,.7,.6));
-        //      weapon->getEnergyWidget()->frontMaterial().setTransparency(.6);
-        this->weaponsWidgets.push_back(weapon->getEnergyWidget());
+        weapon->getEnergyWidget()->setWidgetSize(120,30);
+        //weapon->getEnergyWidget()->frontMaterial().setTransparency(.6);
+        this->weaponsWidgetsPrim.push_back(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
       }
     }
+
+  if (this->weaponManagerSecondary != NULL)
+    for (unsigned int i = 0; i < this->weaponManagerSecondary->getSlotCount(); i++)
+    {
+      Weapon* weapon = this->weaponManagerSecondary->getWeapon(i);
+      if (weapon != NULL)
+      {
+        //PRINTF(0)("WEAPON %s::%s in Slots\n", weapon->getClassCName(), weapon->getName());
+        weapon->getEnergyWidget()->setParent2D(this->rightRect);
+        weapon->getEnergyWidget()->show();
+        weapon->getEnergyWidget()->setBackgroundColor(Color(.8,.2,.11, 0.1));
+        weapon->getEnergyWidget()->setFrontColor(Color( .2,.5,.7,.6));
+        weapon->getEnergyWidget()->setWidgetSize(150,50);
+        //weapon->getEnergyWidget()->frontMaterial().setTransparency(.6);
+        this->weaponsWidgetsSec.push_back(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
+      }
+    }
+
   this->updateResolution();
+
 }
 
@@ -182 +341 @@
   this->notifier->setWidgetSize(0.25 * this->resX, 0.6 * this->resY);
 
+  int overlayWidth = 0;
+  if (overlayPercentage >= 20)
+    overlayWidth = this->resX * (overlayPercentage)/(200);
+  else
+    overlayWidth = this->resX * 0.1;
+  //if (overlayWidth < 100)
+    //overlayWidth = 100;
+
+  this->rightRect->hide();
+  this->leftRect->hide();
+
+  this->leftRect->setParent2D(this);
+  this->leftRect->setWidgetSize(float(overlayWidth), float(this->resY));
+  this->leftRect->setAbsCoor2D(0,0);
+  this->leftRect->setBackgroundTexture(Texture());
+  this->leftRect->setBackgroundColor(Color(0,0,0.7,0.2));
+  this->leftRect->setForegroundTexture(Texture());
+  this->leftRect->setForegroundColor(Color(0,0,0,0));
+
+  this->rightRect->setParent2D(this);
+  this->rightRect->setWidgetSize(float(overlayWidth), float(this->resY));
+  this->rightRect->setAbsCoor2D(this->resX - overlayWidth,0);
+  this->rightRect->setBackgroundTexture(Texture());
+  this->rightRect->setBackgroundColor(Color(0,0,0.7,0.2));
+  this->rightRect->setForegroundTexture(Texture());
+  this->rightRect->setForegroundColor(Color(0,0,0,0));
+
+
+  if (this->overlayActive == true)
+  {
+    this->rightRect->show();
+    this->leftRect->show();
+  }
+
 
   if (State::getPlayer() && State::getPlayer()->getPlayable() && State::getObjectManager())
   {
     PRINTF(4)("UPDATING RADAR\n");
-    this->_radar->setCenterNode(State::getPlayer()->getPlayable());
-    this->_radar->addEntityList(&State::getObjectManager()->getEntityList((OM_LIST)(State::getPlayer()->getPlayable()->getOMListNumber()+1)), Color(.4, .4, 1.0));
-    this->_radar->addEntityList(&State::getObjectManager()->getEntityList(OM_GROUP_02), Color(1.0, .2, .2));
-    this->_radar->setAbsCoor2D(0.8 * this->resX, 0.01 * this->resY);
-    this->_radar->setWidgetSize(0.2 * this->resX, 0.2 * this->resY);
+    this->_radar->setParent2D(this->leftRect);
+    if (radarCenterNode == NULL)
+      this->_radar->setCenterNode(State::getPlayer()->getPlayable());
+    else
+      this->_radar->setCenterNode(this->radarCenterNode);
+
+    //this->_radar->addEntityList(&State::getObjectManager()->getEntityList((OM_LIST)(State::getPlayer()->getPlayable()->getOMListNumber()+1)), Color(.4, .4, 1.0));
+    this->_radar->addEntityList(&State::getObjectManager()->getEntityList(OM_GROUP_00), Color(1, 0, 0));
+    this->_radar->addEntityList(&State::getObjectManager()->getEntityList(OM_GROUP_01), Color(0, 0, 1));
+    this->_radar->setAbsCoor2D(0, 0.01 * this->resY);
+    this->_radar->setWidgetSize(overlayWidth, overlayWidth);
     this->_radar->setRange(300);
     this->_radar->show();
-  }
-
-
-  if (this->energyWidget != NULL)
-  {
-    this->energyWidget->setAbsCoor2D(0.0 * this->resX, 0.85 * this->resY);
-    this->energyWidget->setWidgetSize(.25 * this->resX, 0.1 * this->resY);
-  }
-
-
-  std::list<OrxGui::GLGuiWidget*>::iterator weaponWidget;
-  Vector2D pos(0.3, .9);
-  for (weaponWidget = this->weaponsWidgets.begin(); weaponWidget != this->weaponsWidgets.end(); weaponWidget++, pos.x+=.2)
-  {
-    if (pos.x > .8)
-    {
-      pos.x = 0.3;
-      pos.y -= .1;
-
-    }
-    (*weaponWidget)->setAbsCoor2D(pos.x*this->resX, pos.y*this->resY);
-    (*weaponWidget)->setWidgetSize(.02*this->resX, .1 *this->resY);
+    
+    int statWidgetsNumber = 0;
+    float expectedArmorSizeX = 0;
+    float expectedArmorSizeY = 0;
+    float newSizeY = 0; float newSizeX = 0;
+    float moduloWidth = 0;
+
+    if (this->armorWidget != NULL)
+    {
+      expectedArmorSizeX = 150;
+      expectedArmorSizeY = 50;
+      statWidgetsNumber++;
+    }
+
+    if (this->shieldWidget != NULL)
+      statWidgetsNumber++;
+    
+    if (this->energyWidget != NULL)
+      statWidgetsNumber++;
+
+    if (expectedArmorSizeY * statWidgetsNumber > overlayWidth)
+    {
+      newSizeY = overlayWidth / float(statWidgetsNumber);
+      newSizeX = expectedArmorSizeX;
+      PRINTF(0)("Statwidgets resized\n");
+    }
+    else
+    {
+      newSizeY = expectedArmorSizeY;
+      newSizeX = expectedArmorSizeX;
+      moduloWidth = int(overlayWidth) % int(expectedArmorSizeY * statWidgetsNumber);
+    }
+
+    float posY = overlayWidth + newSizeX;
+
+    if (this->armorWidget != NULL)
+    {
+      this->armorWidget->setSize2D(newSizeX, newSizeY);
+      this->armorWidget->setRelCoor2D((statWidgetsNumber - 1) * newSizeY + 3 * moduloWidth / (statWidgetsNumber + 1),posY);
+    }
+    if (this->shieldWidget != NULL)
+    {
+      this->shieldWidget->setSize2D(newSizeX, newSizeY);
+      this->shieldWidget->setRelCoor2D((statWidgetsNumber - 2) * newSizeY + 2 *moduloWidth / (statWidgetsNumber + 1),posY);
+    }
+    if (this->energyWidget != NULL)
+    {
+      this->energyWidget->setSize2D(newSizeX, newSizeY);
+      this->energyWidget->setRelCoor2D(moduloWidth / (statWidgetsNumber + 1),posY);
+    }
+
+    /*
+    if (this->armorWidget != NULL)
+      this->armorWidget->setRelCoor2D(100,0.2*this->resY + this->armorWidget->getSizeX2D());
+    if (this->shieldWidget != NULL)
+      this->shieldWidget->setRelCoor2D(60,0.2*this->resY + this->armorWidget->getSizeX2D());
+    if (this->energyWidget != NULL)
+      this->energyWidget->setRelCoor2D(20,0.2*this->resY + this->armorWidget->getSizeX2D());
+    */
+    //this->shieldWidget->setRelCoor2D(0.1*this->resX + this->armorWidget->getSizeX2D(),0);
+    //this->energyWidget->setRelCoor2D(0.1*this->resX + this->armorWidget->getSizeX2D() + this->shieldWidget->getSizeX2D(),0);
+  }
+
+  /*
+  if (this->shipValuesBox != NULL)
+  {
+    this->shipValuesBox->setAbsCoor2D(0.2 * this->resX, 0.4 * this->resY);
+    this->shipValuesBox->setWidgetSize(.4 * this->resX, 0.1 * this->resY);
+  }
+  else
+    createShipValuesBox();
+  */
+
+  std::list<OrxGui::GLGuiEnergyWidgetVertical*>::iterator weaponWidget;
+  Vector2D pos = Vector2D(overlayWidth, 0.4*this->resY);
+  float largestWidgetSizeX = 0;
+  //PRINTF(0)("Cur Pos: %f,%f\n",pos.x,pos.y);
+  // out of reasons i can't get behind, this version is segfaulting when calling getSizeX2D or getSizeY2D. the other
+  // element2D- related function works tough.. :s
+
+  for (weaponWidget = this->weaponsWidgetsPrim.begin(); weaponWidget != this->weaponsWidgetsPrim.end(); weaponWidget++)
+  {
+    float ySize = (*weaponWidget)->getSizeY2D();
+    float xSize = (*weaponWidget)->getSizeX2D();
+    if (xSize > largestWidgetSizeX)
+      largestWidgetSizeX = xSize;
+    if (pos.x < ySize)
+    {
+      pos.x = overlayWidth;
+      pos.y += largestWidgetSizeX;
+    }
+    pos.x -= ySize;
+    (*weaponWidget)->setAbsCoor2D(pos.x + this->rightRect->getAbsCoor2D().x, pos.y);
+    //(*weaponWidget)->setAbsCoor2D(0,100);
     (*weaponWidget)->show();
     //printf("update thing %s::%s\n", (*weaponWidget)->getClassCName(), (*weaponWidget)->getName());
   }
+  
+  weaponWidget = this->weaponsWidgetsSec.begin();
+  float expectedWidgetSizeY = 0;
+  if (weaponWidget != this->weaponsWidgetsSec.end())
+  {
+    expectedWidgetSizeY = (*weaponWidget)->getSizeY2D();
+  }
+  pos.y = resY - expectedWidgetSizeY * 0.6;
+  pos.x = overlayWidth + this->rightRect->getAbsCoor2D().x;
+
+  for (weaponWidget = this->weaponsWidgetsSec.begin(); weaponWidget != this->weaponsWidgetsSec.end(); weaponWidget++)
+  {
+    float ySize = (*weaponWidget)->getSizeY2D();
+    float xSize = (*weaponWidget)->getSizeX2D();
+    if (xSize > largestWidgetSizeX)
+      largestWidgetSizeX = xSize;
+    if (pos.x < ySize)
+    {
+      pos.x = overlayWidth;
+      pos.y -= largestWidgetSizeX + expectedWidgetSizeY * 0.6;
+    }
+    pos.x -= ySize;
+    //PRINTF(0)("secweaponwidget y-size: %f/n", (*weaponWidget)->getSizeY2D());
+    (*weaponWidget)->setAbsCoor2D(pos.x + this->rightRect->getAbsCoor2D().x, pos.y);
+    (*weaponWidget)->show();
+    //printf("update thing %s::%s\n", (*weaponWidget)->getClassCName(), (*weaponWidget)->getName());
+  }
+
 }
 
@@ -235 +534 @@
   //  this->inputLine->select();
   }
-
-
-}
-
-
+}
+
+/*
+void Hud::createShipValuesBox()
+{
+  this->shipValuesBox = new OrxGui::GLGuiBox(OrxGui::Vertical);
+  //this->shipValuesBox->setWidgetSize(1000,500);
+  //this->shipValuesBox->setBackgroundTexture("maps/gui_container_background.png");
+  this->shipValuesBox->setBackgroundTexture(Texture());
+  this->shipValuesBox->setBackgroundColor(Color(0,0,1,0.5));
+  this->shipValuesBox->setVisibility(true);
+}
+*/
+
+

branches/playability.new/src/util/hud.h

@@ -9 +9 @@
 #include "element_2d.h"
 #include "event_listener.h"
+#include "glgui_box.h"
+#include "elements/glgui_energywidgetvertical.h"
 
 
@@ -39 +41 @@
   void setShiledWidget(OrxGui::GLGuiWidget* widget);
   void setArmorWidget(OrxGui::GLGuiWidget* widget);
-  void setWeaponManager(WeaponManager* weaponMan);
+  inline OrxGui::GLGuiWidget* getEnergyWidget() {return this->energyWidget;};
+  inline OrxGui::GLGuiWidget* getShieldWidget() {return this->shieldWidget;};
+  inline OrxGui::GLGuiWidget* getArmorWidget() {return this->armorWidget;};
+
+  void setWeaponManager(WeaponManager* weaponMan, WeaponManager* weaponManSec = NULL);
+  inline void setRadarCenterNode(PNode* node) {this->radarCenterNode = node;};
 
   void addWeaponWidget(OrxGui::GLGuiWidget* widget);
@@ -47 +54 @@
 
   void updateWeaponManager();
+  //void clearWeaponManager();
+
+  inline void setOverlayPercentage(int perc) 
+  {
+    if (perc > 100) perc = 100;
+    else if (perc < 0) perc = 0;
+
+    this->overlayPercentage = perc;
+    updateResolution();
+  };
+
+  inline void setOverlayActive(bool b)
+  {
+    overlayActive = b;
+    updateResolution();
+  };
 
   void draw() const;
@@ -54 +77 @@
   private:
     void updateResolution();
+    //void createShipValuesBox();
 
 private:
   unsigned int             resX;
   unsigned int             resY;
+
+  float                    travelZoneWidth; //the percentage of the screen, the player has got for his movements. should always be a value between 0 and 1;
 
   OrxGui::GLGuiWidget*     energyWidget;
@@ -66 +92 @@
   OrxGui::GLGuiInputLine*  inputLine;
   OrxGui::GLGuiRadar*      _radar;
+  PNode*                   radarCenterNode;
+
+  OrxGui::GLGuiWidget*     rightRect;
+  OrxGui::GLGuiWidget*     leftRect;
+  bool                     overlayActive;
+  int                      overlayPercentage; //the percentage of the screen, the player has got for his movements. should always be a value between 0 and 1;
 
   WeaponManager*           weaponManager;
+  WeaponManager*           weaponManagerSecondary;
 
-  std::list<OrxGui::GLGuiWidget*> weaponsWidgets; //!< WeaponWidgets will be displayed one after another
+  std::list<OrxGui::GLGuiEnergyWidgetVertical*> weaponsWidgetsPrim; //!< WeaponWidgets will be displayed one after another
+  std::list<OrxGui::GLGuiEnergyWidgetVertical*> weaponsWidgetsSec;
 };
 

branches/playability.new/src/util/state.h

@@ -109 +109 @@
   static inline int getMenuID() { return State::menuID;}
 
+  ////////////////////////
+  /// Scroller-Control ///
+  ////////////////////////
+  /** sets the scroller-travelnode (center of the screen) */
+  static void setTravelNode(PNode* travelNode) {State::travelNode = travelNode;}
+  /** @returns the scroller-travelnode (center of the screen) */
+  static PNode* getTravelNode() { return State::travelNode; }
 
 
@@ -123 +130 @@
   static GameRules*             gameRules;          //!< A reference to the GameRules
   static Player*                player;             //!< A reference to the Player
+  static PNode*                 travelNode;         //!< A reference to the scroller-travelnode
 
   static SkyBox*                skyBox;            //!< The SkyBox used in the current world.

branches/playability.new/src/util/track/track_manager.cc

@@ -26 +26 @@
 #include "t_animation.h"
 
+#include <string.h>
+
 
 #include "parser/tinyxml/tinyxml.h"
@@ -32 +34 @@
 #include <stdarg.h>
 
+ObjectListDefinition(TrackElement);
 
 
@@ -39 +42 @@
 TrackElement::TrackElement()
 {
-  this->setClassID(CL_TRACK_ELEMENT, "TrackElement");
+  this->registerObject(this, TrackElement::_objectList);
+
 
   this->isFresh = true;
@@ -126 +130 @@
 {
   // return if Found.
-  if (this->getName() && !strcmp(this->getName(), trackName))
-    return this;
+//   if (this->getName() && !strcmp(this->getName(), trackName))
+//     return this;
   // search all children
   if (this->childCount > 0)
@@ -217 +221 @@
 void TrackElement::debug() const
 {
-  PRINT(0)("--== TrackElement:%i ==--", this->ID);
-  if(this->getName())
-    PRINT(0)("--++Name: %s++--", this->getName());
-  if(this->isFresh)
-    PRINT(0)("  -- has not jet eddited in any way --\n");
-  PRINT(0)("\n   TimeTable: startingTime=%f; endTime=%f; duration=%f; jumpTime=%f\n", this->startingTime, this->endTime, this->duration, this->jumpTime);
-  PRINT(0)("   consists of %d Points\n", this->nodeCount);
-  if (this->childCount == 0)
-    PRINT(0)("   has no child\n");
-  else if (this->childCount == 1)
-    PRINT(0)("   has 1 child: =%d=\n", this->getChild(0)->ID);
-  else if (this->childCount > 1)
-    {
-      PRINT(0)("   has %d children: ", this->childCount);
-      //TrackElement* enumElem = this->children->enumerate();
-      tIterator<TrackElement>* iterator = this->children->getIterator();
-      TrackElement* enumElem = iterator->firstElement();
-      while (enumElem)
-        {
-          PRINT(0)("=%d= ", enumElem->ID);
-          enumElem = iterator->nextElement();
-        }
-      delete iterator;
-      PRINT(0)("\n");
-    }
-
-  if(this->isHotPoint)
-    PRINT(0)("   is a special Point:\n");
-  if(this->isSavePoint)
-    PRINT(0)("    is a SavePoint\n");
-  if(this->isFork)
-    {
-      PRINT(0)("    is A Fork with with %d children.\n", this->childCount);
-    }
-  if(this->isJoined)
-    PRINT(0)("   is Joined at the End\n");
-
-  if(!this->backLoopCheck()) /* this should not happen */
-    PRINT(2)(" THERE IS A BACKLOOP TO THIS ELEMENT\n");
+//   PRINT(0)("--== TrackElement:%i ==--", this->ID);
+//   if(this->getName())
+//     PRINT(0)("--++Name: %s++--", this->getName());
+//   if(this->isFresh)
+//     PRINT(0)("  -- has not jet eddited in any way --\n");
+//   PRINT(0)("\n   TimeTable: startingTime=%f; endTime=%f; duration=%f; jumpTime=%f\n", this->startingTime, this->endTime, this->duration, this->jumpTime);
+//   PRINT(0)("   consists of %d Points\n", this->nodeCount);
+//   if (this->childCount == 0)
+//     PRINT(0)("   has no child\n");
+//   else if (this->childCount == 1)
+//     PRINT(0)("   has 1 child: =%d=\n", this->getChild(0)->ID);
+//   else if (this->childCount > 1)
+//     {
+//       PRINT(0)("   has %d children: ", this->childCount);
+//       //TrackElement* enumElem = this->children->enumerate();
+//       tIterator<TrackElement>* iterator = this->children->getIterator();
+//       TrackElement* enumElem = iterator->firstElement();
+//       while (enumElem)
+//         {
+//           PRINT(0)("=%d= ", enumElem->ID);
+//           enumElem = iterator->nextElement();
+//         }
+//       delete iterator;
+//       PRINT(0)("\n");
+//     }
+//
+//   if(this->isHotPoint)
+//     PRINT(0)("   is a special Point:\n");
+//   if(this->isSavePoint)
+//     PRINT(0)("    is a SavePoint\n");
+//   if(this->isFork)
+//     {
+//       PRINT(0)("    is A Fork with with %d children.\n", this->childCount);
+//     }
+//   if(this->isJoined)
+//     PRINT(0)("   is Joined at the End\n");
+//
+//   if(!this->backLoopCheck()) /* this should not happen */
+//     PRINT(2)(" THERE IS A BACKLOOP TO THIS ELEMENT\n");
 }
 
@@ -358 +362 @@
 TrackManager::TrackManager()
 {
-  this->setClassID(CL_TRACK_MANAGER, "TrackManager");
-  this->setName("TrackManager");
-
   TrackManager::singletonRef = this; // do this because otherwise the TrackNode cannot get The instance of the TrackManager
 
@@ -395 +396 @@
 void TrackManager::loadParams(const TiXmlElement* root)
 {
-  double x, y, z, d;
-
-  LOAD_PARAM_START_CYCLE(root, element);
-  {
-
-    LoadParam_CYCLE(element, "WorkOn", this, TrackManager, workOnS)
-        .describe("Selects a TrackElement (by name) to work on");
-
-    LoadParam_CYCLE(element, "Point", this, TrackManager, addPoint)
-        .describe("Adds a new Point to the currently selected TrackElement");
-
-    LoadParam_CYCLE(element, "Duration", this, TrackManager, setDuration)
-        .describe("Sets the Duration of the currently selected TrackElement");
-
-    LoadParam_CYCLE(element, "HotPoint", this, TrackManager, addHotPoint)
-        .describe("Sets a new Point that acts as a hot point. meaning, the curve will flow through this Point");
-
-    LoadParam_CYCLE(element, "SavePoint", this, TrackManager, setSavePointS)
-        .describe("Sets the current selected Point to a Savepoint, meaning that the curve will be ended and a new one starts, and that one starts again from this point on");
-
-    LoadParam_CYCLE(element, "Fork", this, TrackManager, forkS)
-        .describe("Forks the Path into multiple forked Path names seperated by ','");
-
-    LoadParam_CYCLE(element, "Join", this, TrackManager, joinS)
-        .describe("Joins multiple joining Path names seperated by ','");
+//   double x, y, z, d;
+//
+//   LOAD_PARAM_START_CYCLE(root, element);
+//   {
+//
+//     LoadParam_CYCLE(element, "WorkOn", this, TrackManager, workOnS)
+//         .describe("Selects a TrackElement (by name) to work on");
+//
+//     LoadParam_CYCLE(element, "Point", this, TrackManager, addPoint)
+//         .describe("Adds a new Point to the currently selected TrackElement");
+//
+//     LoadParam_CYCLE(element, "Duration", this, TrackManager, setDuration)
+//         .describe("Sets the Duration of the currently selected TrackElement");
+//
+//     LoadParam_CYCLE(element, "HotPoint", this, TrackManager, addHotPoint)
+//         .describe("Sets a new Point that acts as a hot point. meaning, the curve will flow through this Point");
+//
+//     LoadParam_CYCLE(element, "SavePoint", this, TrackManager, setSavePointS)
+//         .describe("Sets the current selected Point to a Savepoint, meaning that the curve will be ended and a new one starts, and that one starts again from this point on");
+//
+//     LoadParam_CYCLE(element, "Fork", this, TrackManager, forkS)
+//         .describe("Forks the Path into multiple forked Path names seperated by ','");
+//
+//     LoadParam_CYCLE(element, "Join", this, TrackManager, joinS)
+//         .describe("Joins multiple joining Path names seperated by ','");
 
       /*
@@ -445 +446 @@
         }
       */
-  }
-  LOAD_PARAM_END_CYCLE(element);
+
+//   }
+//   LOAD_PARAM_END_CYCLE(element);
 }
 
@@ -477 +479 @@
 void TrackManager::initChildren(unsigned int childCount, TrackElement* trackElem)
 {
-  if (!trackElem)
-    trackElem = this->currentTrackElem;
-
-  trackElem->childCount = childCount;
-  trackElem->mainJoin = true;  // this tells join, that this one is the Main Join, if it tries to join multiple Tracks
-  trackElem->children =  new tList<TrackElement>();
-  for (int i = 0; i < childCount; i++)
-    {
-      // create a new Element
-      TrackElement* newElem = new TrackElement();
-      // setting up the new ID
-      newElem->ID = ++trackElemCount;
-      // setting up the Time
-      newElem->startingTime = trackElem->endTime + trackElem->jumpTime;
-      // adds the conection Point
-      this->addPointV(trackElem->curve->getNode(trackElem->curve->getNodeCount()),
-                     newElem);
-      // add the new child to the childList.
-      trackElem->children->add(newElem);
-    }
-
-  // setting the Name of the new TrackElement to the name of the last one + _childI
-
-  if (trackElem->getName())
-    {
-      for (int i = 0; i < trackElem->childCount; i++)
-      {
-        char* childName = new char[strlen(trackElem->getName())+10];
-        sprintf(childName, "%s_child%d", trackElem->getName(), i);
-        trackElem->getChild(i)->setName(childName);
-      }
-    }
-  // select the first Child to work on.
-  this->currentTrackElem = trackElem->getChild(0);
+//   if (!trackElem)
+//     trackElem = this->currentTrackElem;
+//
+//   trackElem->childCount = childCount;
+//   trackElem->mainJoin = true;  // this tells join, that this one is the Main Join, if it tries to join multiple Tracks
+//   trackElem->children =  new tList<TrackElement>();
+//   for (int i = 0; i < childCount; i++)
+//     {
+//       // create a new Element
+//       TrackElement* newElem = new TrackElement();
+//       // setting up the new ID
+//       newElem->ID = ++trackElemCount;
+//       // setting up the Time
+//       newElem->startingTime = trackElem->endTime + trackElem->jumpTime;
+//       // adds the conection Point
+//       this->addPointV(trackElem->curve->getNode(trackElem->curve->getNodeCount()),
+//                      newElem);
+//       // add the new child to the childList.
+//       trackElem->children->add(newElem);
+//     }
+//
+//   // setting the Name of the new TrackElement to the name of the last one + _childI
+//
+//   if (trackElem->getName())
+//     {
+//       for (int i = 0; i < trackElem->childCount; i++)
+//       {
+//         char* childName = new char[strlen(trackElem->getName())+10];
+//         sprintf(childName, "%s_child%d", trackElem->getName(), i);
+//         trackElem->getChild(i)->setName(childName);
+//       }
+//     }
+//   // select the first Child to work on.
+//   this->currentTrackElem = trackElem->getChild(0);
 }
 
@@ -659 +661 @@
 void TrackManager::setSavePointS(const std::string& nextElementName)
 {
-  this->setSavePoint(NULL);
-  if (strcmp(nextElementName, ""))
-    this->firstTrackElem->findByID(this->trackElemCount)->setName(nextElementName);
+//   this->setSavePoint(NULL);
+//   if (strcmp(nextElementName, ""))
+//     this->firstTrackElem->findByID(this->trackElemCount)->setName(nextElementName);
 }
 
@@ -736 +738 @@
 void TrackManager::forkS(const std::string& forkString)
 {
-  SubString strings(forkString, ',');
-
-  int* trackIDs = new int[strings.getCount()];
-  this->forkV(strings.getCount(), trackIDs, NULL);
-
-  for(int i = 0; i < strings.getCount(); i++)
-    {
-      this->firstTrackElem->findByID(trackIDs[i])->setName(strings.getString(i));
-    }
-  delete []trackIDs;
+//   SubString strings(forkString, ',');
+//
+//   int* trackIDs = new int[strings.getCount()];
+//   this->forkV(strings.getCount(), trackIDs, NULL);
+//
+//   for(int i = 0; i < strings.getCount(); i++)
+//     {
+//       this->firstTrackElem->findByID(trackIDs[i])->setName(strings.getString(i));
+//     }
+//   delete []trackIDs;
 }
 
@@ -877 +879 @@
 void TrackManager::joinS(const std::string& joinString)
 {
-  SubString strings(joinString, ',');
-
-  int* trackIDs = new int[strings.getCount()];
-  this->joinV(strings.getCount(), trackIDs);
-
-  for(unsigned int i = 0; i < strings.getCount(); i++)
-    {
-      TrackElement* tmpElem = this->firstTrackElem->findByName(strings.getString(i).c_str());
-      if (tmpElem != NULL)
-        trackIDs[i] = tmpElem->ID;
-      else
-      {
-        PRINTF(1)("Trying to join a Track, of which the name does not exist: %s\n", strings.getString(i).c_str());
-        trackIDs[i] = -1;
-      }
-    }
-  this->joinV(strings.getCount(), trackIDs);
-  delete []trackIDs;
+//   SubString strings(joinString, ',');
+//
+//   int* trackIDs = new int[strings.getCount()];
+//   this->joinV(strings.getCount(), trackIDs);
+//
+//   for(unsigned int i = 0; i < strings.getCount(); i++)
+//     {
+//       TrackElement* tmpElem = this->firstTrackElem->findByName(strings.getString(i).c_str());
+//       if (tmpElem != NULL)
+//         trackIDs[i] = tmpElem->ID;
+//       else
+//       {
+//         PRINTF(1)("Trying to join a Track, of which the name does not exist: %s\n", strings.getString(i).c_str());
+//         trackIDs[i] = -1;
+//       }
+//     }
+//   this->joinV(strings.getCount(), trackIDs);
+//   delete []trackIDs;
 }
 
@@ -1073 +1075 @@
 void TrackManager::tick(float dt)
 {
-  PRINTF(4)("CurrentTrackID: %d, LocalTime is: %f, timestep is: %f\n", this->currentTrackElem->ID, this->localTime, dt);
-  if (this->localTime <= this->firstTrackElem->duration)
-    this->jumpTo(this->localTime);
-  if (this->localTime <= this->maxTime)
-    this->localTime += dt;
-  if (this->localTime > this->currentTrackElem->endTime
-      && this->currentTrackElem->children)
-    {
-      if (this->currentTrackElem->jumpTime != 0.0)
-        this->jumpTo(this->localTime + this->currentTrackElem->jumpTime);
-      // jump to the next TrackElement and also set the history of the new Element to the old one.
-      TrackElement* tmpHistoryElem = this->currentTrackElem;
-      this->currentTrackElem = this->currentTrackElem->getChild(this->choosePath(this->currentTrackElem));
-      this->currentTrackElem->history = tmpHistoryElem;
-      if (this->currentTrackElem->getName())
-        {
-          this->trackText->setText(this->currentTrackElem->getName());
-          this->textAnimation->replay();
-        }
-    }
-  if (this->bindSlave)
-    {
-      Vector tmp = this->calcPos();
-      Quaternion quat = Quaternion(this->calcDir(), Vector(this->currentTrackElem->curve->calcAcc((localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration).x,1,this->currentTrackElem->curve->calcAcc((localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration).z));
-
-      Vector v(0.0, 1.0, 0.0);
-      Quaternion q(-PI/2, v);
-      quat = quat * q;
-
-      this->bindSlave->setAbsCoor(tmp);
-      this->bindSlave->setAbsDir(quat);
-    }
+//   PRINTF(4)("CurrentTrackID: %d, LocalTime is: %f, timestep is: %f\n", this->currentTrackElem->ID, this->localTime, dt);
+//   if (this->localTime <= this->firstTrackElem->duration)
+//     this->jumpTo(this->localTime);
+//   if (this->localTime <= this->maxTime)
+//     this->localTime += dt;
+//   if (this->localTime > this->currentTrackElem->endTime
+//       && this->currentTrackElem->children)
+//     {
+//       if (this->currentTrackElem->jumpTime != 0.0)
+//         this->jumpTo(this->localTime + this->currentTrackElem->jumpTime);
+//       // jump to the next TrackElement and also set the history of the new Element to the old one.
+//       TrackElement* tmpHistoryElem = this->currentTrackElem;
+//       this->currentTrackElem = this->currentTrackElem->getChild(this->choosePath(this->currentTrackElem));
+//       this->currentTrackElem->history = tmpHistoryElem;
+//       if (this->currentTrackElem->getName())
+//         {
+//           this->trackText->setText(this->currentTrackElem->getName());
+//           this->textAnimation->replay();
+//         }
+//     }
+//   if (this->bindSlave)
+//     {
+//       Vector tmp = this->calcPos();
+//       Quaternion quat = Quaternion(this->calcDir(), Vector(this->currentTrackElem->curve->calcAcc((localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration).x,1,this->currentTrackElem->curve->calcAcc((localTime-this->currentTrackElem->startingTime)/this->currentTrackElem->duration).z));
+//
+//       Vector v(0.0, 1.0, 0.0);
+//       Quaternion q(-PI/2, v);
+//       quat = quat * q;
+//
+//       this->bindSlave->setAbsCoor(tmp);
+//       this->bindSlave->setAbsDir(quat);
+//     }
 }
 
@@ -1116 +1118 @@
 void TrackManager::jumpTo(float time)
 {
-  if (time == 0)
-    {
-      this->currentTrackElem = this->firstTrackElem;
-      if (this->currentTrackElem->getName())
-        {
-          this->trackText->setText(this->currentTrackElem->getName());
-          this->textAnimation->play();
-        }
-    }
-  this->localTime = time;
+//   if (time == 0)
+//     {
+//       this->currentTrackElem = this->firstTrackElem;
+//       if (this->currentTrackElem->getName())
+//         {
+//           this->trackText->setText(this->currentTrackElem->getName());
+//           this->textAnimation->play();
+//         }
+//     }
+//   this->localTime = time;
 }
 

branches/playability.new/src/util/track/track_manager.h

@@ -41 +41 @@
 class TrackElement : public BaseObject
 {
+  ObjectListDeclaration(TrackElement);
+
  public:
   TrackElement();
@@ -131 +133 @@
     \li TrackElement: A Part of A whole Track
 */
-class TrackManager : public BaseObject
+class TrackManager
 {
  public:

branches/playability.new/src/util/track/track_node.cc

@@ -17 +17 @@
 
 
-#include "track_node.h"
+#include "track/track_node.h"
 
-#include "track_manager.h"
+#include "track/track_manager.h"
 
 
-ObjectListDefinition(TracNode);
+ObjectListDefinition(TrackNode);
+
 /**
  *  standard constructor
@@ -28 +29 @@
 TrackNode::TrackNode ()
 {
-  this->registerObject(this, TracNode::_objectList);
-  this->setName("TrackNode");
+  this->registerObject(this, TrackNode::_objectList);
 
   PNode::getNullParent()->addChild(this);

branches/playability.new/src/util/track/track_node.h

@@ -14 +14 @@
 #include "p_node.h"
 
+
 /* FORWARD DECLARATION */
 class TrackManager;
@@ -20 +21 @@
 class TrackNode : public PNode
 {
-  ObjectListDeclaratrion(TracNode);
+  ObjectListDeclaration(TrackNode);
  public:
   TrackNode ();

branches/playability.new/src/world_entities/Makefile.am

@@ -6 +6 @@
 
 ## THESE ARE THE BASE CLASSES OF ALL WORLD_ENTITIES
-libORXwe_a_SOURCES = \
-                world_entity.cc \
-                \
-                camera.cc \
-                playable.cc \
-                player.cc \
-                \
-                npcs/npc.cc \
-                \
-                weapons/weapon_manager.cc \
-                weapons/crosshair.cc \
-                weapons/weapon.cc \
-                weapons/ammo_container.cc \
-                projectiles/projectile.cc \
-                \
-                extendable.cc \
-                power_ups/power_up.cc \
-                power_ups/param_power_up.cc \
-                power_ups/weapon_power_up.cc \
-                \
-                spawning_point.cc \
-                \
-                \
-                effects/explosion.cc \
-                effects/billboard.cc \
-                \
-                \
-                elements/glgui_energywidget.cc
+libORXwe_a_SOURCES = world_entity.cc\
+                     camera.cc\
+                     playable.cc\
+                     player.cc \
+                     npcs/npc.cc\
+                     weapons/weapon_manager.cc\
+                     weapons/crosshair.cc \
+                     weapons/weapon.cc\
+                     weapons/ammo_container.cc\
+                     projectiles/projectile.cc \
+                     extendable.cc\
+                     power_ups/power_up.cc\
+                     power_ups/param_power_up.cc \
+                     power_ups/weapon_power_up.cc\
+                     spawning_point.cc\
+                     effects/explosion.cc\
+                     effects/billboard.cc\
+                     effects/wobblegrid.cc\
+                     effects/trail.cc\
+                     elements/glgui_energywidget.cc\
+                     elements/glgui_energywidgetvertical.cc
 
 
-noinst_HEADERS  = \
-                world_entity.h \
-                \
-                camera.h \
-                extendable.h \
-                playable.h \
-                player.h \
-                \
-                npcs/npc.h \
-                \
-                weapons/weapon_manager.h \
-                weapons/crosshair.h \
-                weapons/weapon.h \
-                weapons/ammo_container.h \
-                projectiles/projectile.h \
-                \
-                power_ups/power_up.h \
-                power_ups/param_power_up.h \
-                power_ups/weapon_power_up.h \
-                \
-                spawning_point.h \
-                \
-                \
-                effects/explosion.h \
-                effects/billboard.h \
-                \
-                \
-                \
-                elements/glgui_energywidget.h \
-                \
-                \
-                $(WorldEntities_HEADERS_)
+noinst_HEADERS = world_entity.h \
+                 camera.h \
+                 extendable.h \
+                 playable.h \
+                 player.h \
+                 npcs/npc.h \
+                 weapons/weapon_manager.h \
+                 weapons/crosshair.h \
+                 weapons/weapon.h \
+                 weapons/ammo_container.h \
+                 projectiles/projectile.h \
+                 power_ups/power_up.h \
+                 power_ups/param_power_up.h \
+                 power_ups/weapon_power_up.h \
+                 spawning_point.h \
+                 effects/explosion.h \
+                 effects/billboard.h \
+                 effects/trail.h\
+                 effects/wobblegrid.h\
+                 elements/glgui_energywidget.h\
+                 elements/glgui_energywidgetvertical.h
 
 

branches/playability.new/src/world_entities/WorldEntities.am

@@ -1 @@
-
 ## THE SUBCLASSES. THESE MUST BE DYNAMICALLY LINKED OR COMPILED IN DIRECTLY
 WorldEntities_SOURCES_ = \
@@ -23 +22 @@
                 world_entities/character_attributes.cc \
                 world_entities/test_entity.cc \
+                world_entities/test_entity2.cc \
                 world_entities/planet.cc \
                 world_entities/bsp_entity.cc \
@@ -39 +39 @@
                 world_entities/weapons/fps_sniper_rifle.cc \
                 world_entities/weapons/boomerang_gun.cc \
-                \
+                world_entities/weapons/light_blaster.cc \
+                world_entities/weapons/medium_blaster.cc \
+                world_entities/weapons/heavy_blaster.cc \
+                world_entities/weapons/swarm_launcher.cc \
+                world_entities/weapons/spike_launcher.cc \
+                world_entities/weapons/spike_thrower.cc \
+                world_entities/weapons/acid_launcher.cc \
+                \
+                world_entities/projectiles/lbolt.cc \
+                world_entities/projectiles/mbolt.cc \
+                world_entities/projectiles/hbolt.cc \
+                world_entities/projectiles/swarm_projectile.cc \
                 world_entities/projectiles/bomb.cc \
                 world_entities/projectiles/laser.cc \
@@ -48 +59 @@
                 world_entities/projectiles/boomerang_projectile.cc \
                 world_entities/projectiles/hyperblast.cc \
+                world_entities/projectiles/spike.cc \
+                world_entities/projectiles/acid_splash.cc \
+                \
+                world_entities/projectiles/projectile_weapon.cc \
+                world_entities/projectiles/spike_ball.cc \
                 \
                 world_entities/power_ups/turret_power_up.cc \
@@ -83 +99 @@
                 world_entities/particles/box_emitter.cc \
                 world_entities/particles/plane_emitter.cc \
+                world_entities/particles/emitter_node.cc \
                 \
                 world_entities/particles/particle_system.cc \
@@ -129 +146 @@
                 character_attributes.h \
                 test_entity.h \
+                test_entity2.h \
                 planet.h \
                 bsp_entity.h \
@@ -145 +163 @@
                 weapons/aiming_system.h \
                 weapons/fps_sniper_rifle.h \
-                \
+                weapons/light_blaster.h \
+                weapons/medium_blaster.h \
+                weapons/heavy_blaster.h \
+                weapons/swarm_launcher.h \
+                weapons/spike_launcher.h \
+                weapons/spike_thrower.h \
+                weapons/acid_launcher.h \
+                \
+                projectiles/lbolt.h \
+                projectiles/mbolt.h \
+                projectiles/hbolt.h \
+                projectiles/swarm_projectile.h \
                 projectiles/bomb.h \
                 projectiles/laser.h \
@@ -154 +183 @@
                 projectiles/boomerang_projectile.h \
                 projectiles/hyperblast.h \
+                projectiles/spike.h \
+                projectiles/spike_ball.h \
+                projectiles/acid_splash.h \
+                \
+                projectiles/projectile_weapon.h \
+                projectiles/spike_ball.h \
                 \
                 power_ups/turret_power_up.h \
@@ -188 +223 @@
                 particles/box_emitter.h \
                 particles/plane_emitter.h \
+                particles/emitter_node.h \
                 \
                 particles/particle_system.h \
@@ -209 +245 @@
                 weather_effects/lense_flare.h
 
-

branches/playability.new/src/world_entities/camera.cc

@@ -18 +18 @@
 #include "key_mapper.h"
 #include "glincl.h"
+//#include "util/loading/load_param.h"
+#include "world_entity.h"
 
 ObjectListDefinition(Camera);
@@ -27 +29 @@
 {
   this->registerObject(this, Camera::_objectList);
+  this->init();
+}
+
+/*
+Camera::Camera(const TiXmlElement* root)
+{
+  this->registerObject(this, Camera::_objectList);
+  this->init();
+  this->loadParams(root);
+}
+*/
+
+/**
+ *  default destructor
+*/
+Camera::~Camera()
+{}
+
+void Camera::init()
+{
   this->setName("camera");
   this->target = new CameraTarget();
@@ -37 +59 @@
   this->subscribeEvent(ES_GAME, KeyMapper::PEV_VIEW5);
 
-  this->setFovy(90);
-  this->setAspectRatio(1.2f);
+  //this->setFovy(90);
+  this->setAspectRatio(1.33f);
   this->setClipRegion(.1, 10000);
+  
+  this->viewTopFovy = 60;
+  this->viewNormalFovy = 90;
+  this->viewFrontFovy = 120;
+  this->viewRightFovy = 90;
+  this->viewLeftFovy = 90;
+
+  this->viewTopDistance = 70;
+  this->viewNormalDistance = 10;
+  this->viewFrontDistance = 4;
+  this->viewRightDistance = 10;
+  this->viewLeftDistance = 10;
+
+  //this->loadParams(doc.RootElement());
 
   this->setViewMode(Camera::ViewNormal);
 
   this->setParentMode(PNODE_ALL);
-}
-
-/**
- *  default destructor
-*/
-Camera::~Camera()
-{}
+  this->eventHandling = true;
+}
 
 /**
@@ -100 +131 @@
     default:
     case Camera::ViewNormal:
-      this->toFovy = 60.0;
-      this->setRelCoorSoft(-10, 5, 0);
+    {
+      this->fovy = viewNormalFovy;
+      this->toFovy = viewNormalFovy;
+      //this->fovy = 60;
+      //this->toFovy = 60;
+      this->setRelCoorSoft(-2.0/3.0 * this->viewNormalDistance, 1.0/3.0 * this->viewNormalDistance, 0);
       this->target->setRelCoorSoft(0,0,0);
       break;
+    }
     case Camera::ViewBehind:
       break;
     case Camera::ViewFront:
-      this->toFovy = 120.0;
-      this->setRelCoorSoft(4, 0, 0, 5);
+    {
+      this->fovy = viewFrontFovy;
+      this->toFovy = viewFrontFovy;
+      this->setRelCoorSoft(this->viewFrontDistance, 0, 0, 5);
       this->target->setRelCoorSoft(Vector(10,0,0), 5);
       break;
+    }
     case Camera::ViewLeft:
-      this->toFovy = 90;
-      this->setRelCoorSoft(0, 1, -10, .5);
+    {
+      this->fovy = viewLeftFovy;
+      this->toFovy = viewLeftFovy;
+      this->setRelCoorSoft(0, 1, -viewLeftDistance, .5);
       this->target->setRelCoorSoft(0,0,0);
       break;
+    }
     case Camera::ViewRight:
-      this->toFovy = 90;
-      this->setRelCoorSoft(Vector(0, 1, 10));
+    {
+      this->fovy = viewRightFovy;
+      this->toFovy = viewRightFovy;
+      this->setRelCoorSoft(Vector(0, 1, viewRightDistance), 0.5);
       this->target->setRelCoorSoft(0,0,0);
       break;
+    }
     case Camera::ViewTop:
-      this->toFovy= 120;
-      this->setRelCoorSoft(Vector(30, 50, 0));
-      this->target->setRelCoorSoft(35,0,0);
+    {
+      this->fovy= viewTopFovy;
+      this->toFovy = viewTopFovy;
+      this->setRelCoor(Vector(-0.05, this->viewTopDistance , 0));
+      this->target->setRelCoor(0,0,0);
+    }
   }
 }
@@ -143 +191 @@
 
   float tmpFovy = (this->toFovy - this->fovy);
-  if (tmpFovy > 0.01)
+  if (fabsf(tmpFovy) > 0.01)
     this->fovy += tmpFovy * fabsf(dt);
 }
@@ -192 +240 @@
 void Camera::process(const Event &event)
 {
-  if( event.type == KeyMapper::PEV_VIEW0)
+  if (eventHandling == true)
   {
-    this->setViewMode(Camera::ViewNormal);
+    if( event.type == KeyMapper::PEV_VIEW0)
+    {
+      this->setViewMode(Camera::ViewNormal);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW1)
+    {
+      this->setViewMode(Camera::ViewBehind);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW2)
+    {
+      this->setViewMode(Camera::ViewFront);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW3)
+    {
+      this->setViewMode(Camera::ViewLeft);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW4)
+    {
+      this->setViewMode(Camera::ViewRight);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW5)
+    {
+      this->setViewMode(Camera::ViewTop);
+    }
   }
-  else if( event.type == KeyMapper::PEV_VIEW1)
-  {
-    this->setViewMode(Camera::ViewBehind);
-  }
-  else if( event.type == KeyMapper::PEV_VIEW2)
-  {
-    this->setViewMode(Camera::ViewFront);
-  }
-  else if( event.type == KeyMapper::PEV_VIEW3)
-  {
-    this->setViewMode(Camera::ViewLeft);
-  }
-  else if( event.type == KeyMapper::PEV_VIEW4)
-  {
-    this->setViewMode(Camera::ViewRight);
-  }
-  else if( event.type == KeyMapper::PEV_VIEW5)
-  {
-    this->setViewMode(Camera::ViewTop);
-  }
+}
+
+/*
+void Camera::loadParams(const TiXmlElement* root)
+{
+  // Do the PNode loading stuff
+  PNode::loadParams(root);
+
+  LoadParam(root, "viewTopFovy", this, Camera, setViewTopFovy);
+  LoadParam(root, "viewFrontFovy", this, Camera, setViewFrontFovy);
+  LoadParam(root, "viewLeftFovy", this, Camera, setViewLeftFovy);
+  LoadParam(root, "viewRightFovy", this, Camera, setViewRightFovy);
+  LoadParam(root, "viewBehindFovy", this, Camera, setViewBehindFovy);
+  LoadParam(root, "viewNormalFovy", this, Camera, setViewNormalFovy);
+
+  LoadParam(root, "viewTopDistance", this, Camera, setViewTopDistance);
+  LoadParam(root, "viewFrontDistance", this, Camera, setViewFrontDistance);
+  LoadParam(root, "viewLeftDistance", this, Camera, setViewLeftDistance);
+  LoadParam(root, "viewRightDistance", this, Camera, setViewRightDistance);
+  LoadParam(root, "viewBehindDistance", this, Camera, setViewBehindDistance);
+  LoadParam(root, "viewNormalDistance", this, Camera, setViewNormalDistance);
+}
+*/
+
+void Camera::setViewTopFovy(float fovy)
+{
+  this->viewTopFovy = fovy;
+}
+
+void Camera::setViewFrontFovy(float fovy)
+{
+  this->viewFrontFovy = fovy;
+}
+
+void Camera::setViewLeftFovy(float fovy)
+{
+  this->viewLeftFovy = fovy;
+}
+
+void Camera::setViewRightFovy(float fovy)
+{
+  this->viewRightFovy = fovy;
+}
+
+void Camera::setViewBehindFovy(float fovy)
+{
+  this->viewBehindFovy = fovy;
+}
+
+void Camera::setViewNormalFovy(float fovy)
+{
+  this->viewNormalFovy = fovy;
+}
+
+void Camera::setViewTopDistance(float Distance)
+{
+  this->viewTopDistance = Distance;
+}
+
+void Camera::setViewFrontDistance(float Distance)
+{
+  this->viewFrontDistance = Distance;
+}
+
+void Camera::setViewLeftDistance(float Distance)
+{
+  this->viewLeftDistance = Distance;
+}
+
+void Camera::setViewRightDistance(float Distance)
+{
+  this->viewRightDistance = Distance;
+}
+
+void Camera::setViewBehindDistance(float Distance)
+{
+  this->viewBehindDistance = Distance;
+}
+
+void Camera::setViewNormalDistance(float Distance)
+{
+  this->viewNormalDistance = Distance;
 }
 

branches/playability.new/src/world_entities/camera.h

@@ -36 +36 @@
 
   Camera();
+  Camera(const TiXmlElement* root);
   virtual ~Camera();
 
@@ -43 +44 @@
 
   void setAspectRatio(float aspectRatio);
+  inline float getAspectRatio() {return this->aspectRatio;};
+
   void setClipRegion(float nearClip, float farClip);
 
   /** @param fovy new field of view factor (in degrees) */
-  void setFovy(float fovy) { this->fovy = fovy; };
+  inline void setFovy(float fovy) 
+  { 
+    this->fovy = fovy; 
+    this->toFovy = fovy;
+  };
+
+  inline float getFovy() {return this->fovy;};
   /** @param fovy new field of view factor (in degrees) to iterate to */
   void setToFovy(float toFovy) { this->toFovy = toFovy; };
@@ -58 +67 @@
   inline float distance(const PNode* node) const { return distance(node->getAbsCoor()); }
 
+  inline void setEventHandling(bool b) {this->eventHandling = b;}
+  inline bool getEventHandling() {return this->eventHandling;}
+
   void tick(float dt);
   void apply ();
@@ -64 +76 @@
   void process(const Event &event);
 
+  //virtual void loadParams(const TiXmlElement* root);
+
+  void              setViewTopFovy(float fovy);
+  void              setViewLeftFovy(float fovy);
+  void              setViewRightFovy(float fovy);
+  void              setViewBehindFovy(float fovy);
+  void              setViewFrontFovy(float fovy);
+  void              setViewNormalFovy(float fovy);
+
+  void              setViewTopDistance(float Distance);
+  void              setViewLeftDistance(float Distance);
+  void              setViewRightDistance(float Distance);
+  void              setViewBehindDistance(float Distance);
+  void              setViewFrontDistance(float Distance);
+  void              setViewNormalDistance(float Distance);
+
 private:
+
+  void              init();
+
   CameraTarget*     target;          //!< The Target of the Camera (where this Camera Looks at)
+
+  bool              eventHandling;    //!< True, if the Camera handles the processing of events itself. Set false to overwrite the standard handling.
 
   float             fovy;            //!< The field of view Angle (in degrees).
@@ -79 +112 @@
   Vector            viewVector;      //!< the direction of the camera view
   Vector            upVector;        //!< direction of the up vector
+
+  float             viewTopFovy;
+  float             viewLeftFovy;
+  float             viewRightFovy;
+  float             viewBehindFovy;
+  float             viewFrontFovy;
+  float             viewNormalFovy;
+
+  float             viewTopDistance;
+  float             viewLeftDistance;
+  float             viewRightDistance;
+  float             viewBehindDistance;
+  float             viewFrontDistance;
+  float             viewNormalDistance;
+  
 };
 

branches/playability.new/src/world_entities/elements/glgui_energywidget.h

@@ -26 +26 @@
     void setValue(float value);
 
+    inline GLGuiWidget* getNameWidget() {return &this->_name;};
+    inline GLGuiWidget* getValueWidget() {return &this->_valueText;};
+    inline GLGuiWidget* getBarWidget() {return &this->_bar;};
+
   protected:
     virtual void resize();

branches/playability.new/src/world_entities/elements/glgui_radar.cc

@@ -122 +122 @@
           this->_dotLists[i].positions.push_back(Vector2D(((*it)->getAbsCoor().x - _centerNode->getAbsCoor().x) * this->getSizeX2D() ,
                                                  ((*it)->getAbsCoor().z - _centerNode->getAbsCoor().z) * this->getSizeY2D()  )
-                                                 / (2.0f * _range));
+                                                 / (3.0f * _range));
         }
 

branches/playability.new/src/world_entities/particles/particle_emitter.h

@@ -36 +36 @@
   void start();
   void stop();
-  void tick(float dt);
+  virtual void tick(float dt);
 
   void setSystem(ParticleSystem* system);
@@ -74 +74 @@
   float           momentumRandom;    //!< The random variation of the Momentum.
 
-private:
+//private:
   ParticleSystem* system;            //!< The ParticleSystem this Emitter Emits into.
   float           saveTime;          //!< The time that was missing by the last Tick (otherwise there would be no emission when framefate is too big).

branches/playability.new/src/world_entities/playable.cc

@@ -44 +44 @@
 
 Playable::Playable()
-    : weaponMan(this),
-    supportedPlaymodes(Playable::Full3D),
+    : weaponMan(this)
+    ,supportedPlaymodes(Playable::Full3D),
     playmode(Playable::Full3D)
 {

branches/playability.new/src/world_entities/playable.h

@@ -71 +71 @@
   void setCameraMode(unsigned int cameraMode = 0);
   bool playmodeSupported(Playable::Playmode playmode) const { return this->supportedPlaymodes & playmode; };
-  bool setPlaymode(Playable::Playmode playmode);
+  virtual bool setPlaymode(Playable::Playmode playmode);
   Playable::Playmode getPlaymode() const { return this->playmode; };
   virtual void setPlayDirection(const Quaternion& rot, float speed = 0.0f) = 0;
@@ -117 +117 @@
   void unregisterEvent(int eventType);
 
+protected:
+  WeaponManager         weaponMan;          //!< the weapon manager: managing a list of weapon to wepaon-slot mapping
+  bool                  bFire;              //!< If the Ship is firing.
+  short                 supportedPlaymodes; //!< What Playmodes are Supported in this Playable.
+  Playable::Playmode    playmode;           //!< The current playmode.
+
 private:
-  WeaponManager         weaponMan;          //!< the weapon manager: managing a list of weapon to wepaon-slot mapping
   std::vector<int>      events;             //!< A list of Events, that are captured for this playable
 
   Player*               currentPlayer;      //!< The Player currently connected to this Playable (the one that has controll) otherwise NULL
 
-  bool                  bFire;              //!< If the Ship is firing.
   int                   oldFlags;           //!< Used for synchronisation
 
@@ -131 +135 @@
 
   bool                  bDead;
-  short                 supportedPlaymodes; //!< What Playmodes are Supported in this Playable.
-  Playable::Playmode    playmode;           //!< The current playmode.
 
   float                 enterRadius;        //!< How far one can be away from the Playable to enter it.

branches/playability.new/src/world_entities/player.cc

@@ -16 +16 @@
 #include "player.h"
 #include "playable.h"
+#include "space_ships/space_ship.h"
 
 #include "event_handler.h"
@@ -73 +74 @@
     PRINTF(4)("Enter new Playable\n");
     this->playable = playable;
-    this->_hud.setEnergyWidget(this->playable->getHealthWidget());
-    this->_hud.setWeaponManager(&this->playable->getWeaponManager());
+    this->_hud.setArmorWidget(this->playable->getHealthWidget());
+    if (dynamic_cast<SpaceShip*>(this->playable) != 0)
+      this->_hud.setWeaponManager(&this->playable->getWeaponManager(), &dynamic_cast<SpaceShip*>(this->playable)->getWeaponManagerSecondary());
+    else
+      this->_hud.setWeaponManager(&this->playable->getWeaponManager());
 
     this->playable->setPlayer(this);
@@ -94 +98 @@
 void Player::weaponConfigChanged()
 {
-  this->_hud.updateWeaponManager();
+  //this->_hud.updateWeaponManager();
+
+  if (dynamic_cast<SpaceShip*>(this->playable) != 0)
+      this->_hud.setWeaponManager(&this->playable->getWeaponManager(), &dynamic_cast<SpaceShip*>(this->playable)->getWeaponManagerSecondary());
+    else
+      this->_hud.setWeaponManager(&this->playable->getWeaponManager());
 }
 
@@ -128 +137 @@
 }
 
+

branches/playability.new/src/world_entities/player.h

@@ -1 @@
-/*!
+ /*!
  * @file player.h
  * Implements a basic playable WorldEntity
@@ -46 +46 @@
   private:
     Playable*         playable;                 //!< The one we controll or NULL if none
-    Hud               _hud;                      //!< The HUD to be displayed for this Player.
+    Hud               _hud;                     //!< The HUD to be displayed for this Player.
 };
 

branches/playability.new/src/world_entities/projectiles/projectile.cc

@@ -25 +25 @@
 #include "playable.h"
 
+#include <cmath>
+
 #include "debug.h"
 
@@ -46 +48 @@
   this->subscribeReaction( CoRe::CREngine::CR_PHYSICS_FULL_WALK, Playable::staticClassID());
 
+  this->physDamage = 0.0f;
+  this->elecDamage = 0.0f;
   //this->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
 }
@@ -60 +64 @@
   */
   //delete this->projectileModel;
+}
+
+Projectile::Projectile (float pDamage, float eDamage, PNode* target) : WorldEntity()
+{
+  this->registerObject(this, Projectile::_objectList);
+
+  this->lifeCycle = 0.0;
+  this->lifeSpan = 1.0f; /* sec */
+  this->removeNode();
+
+  /* character attributes */
+  this->setHealth(1.0f);
+  this->setDamage(1.0f); // default damage of a projectile set to 100.0 damage points
+
+  this->physDamage = pDamage;
+  this->elecDamage = eDamage;
+  this->target = target;
+
+  //this->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+}
+
+void Projectile::initialize(float pDamage, float eDamage, PNode* target)
+{
+  /* character attributes*/
+  this->physDamage = pDamage;
+  this->elecDamage = eDamage;
+  this->target = target;
 }
 
@@ -124 +155 @@
 
 
+void Projectile::collidesWith (WorldEntity* target, const Vector& location)
+{
+  dynamic_cast<SpaceShip*>(target)->damage(this->getPhysDamage(),this->getElecDamage());
+//   this->destroy(NULL);
+  this->destroy(target);
+}
+
+
+
 /**
  * signal tick, time dependent things will be handled here
@@ -130 +170 @@
 void Projectile::tick (float dt)
 {
-  Vector v = this->velocity * (dt);
-  this->shiftCoor(v);
-
   if (this->tickLifeCycle(dt))
     this->destroy( NULL );

branches/playability.new/src/world_entities/projectiles/projectile.h

@@ -12 +12 @@
 #include "world_entity.h"
 #include "loading/fast_factory.h"
+#include "space_ships/space_ship.h"
 
 #include "sound_source.h"
@@ -22 +23 @@
     Projectile ();
     virtual ~Projectile ();
+
+    /** @brief Constructor with variable passing*/
+    Projectile (float pDamage, float eDamage, PNode* target);
+    /** @brief for void construction; setting values later - needed for FastFactory*/
+    virtual void initialize(float pDamage, float eDamage, PNode* target);
 
     void setFlightDirection(const Quaternion& flightDirection);
@@ -44 +50 @@
     virtual void destroy (WorldEntity* killer);
 
+    virtual void collidesWith (WorldEntity* target, const Vector& location);  //!< collision handler; used against SpaceShip as most target will be
+
+
     virtual void tick (float dt);
     /** @brief convenience function
@@ -50 +59 @@
     inline bool tickLifeCycle(float dt ) { this->lifeCycle += dt/this->lifeSpan;  return(unlikely(this->lifeCycle >= 1)); }
 
+    inline float getPhysDamage() { return this->physDamage; };
+    inline float getElecDamage() { return this->elecDamage; };
+
+    inline void setPhysDamage( float dmg) {this->physDamage = dmg; };
+    inline void setElecDamage( float dmg) {this->elecDamage = dmg; };
 
   protected:
     // energy
-    float                  energyMin;                 //!< The minimal Energy a Projectile needs to be emitted.
-    bool                   bChargeable;               //!< if the Projectile is Charegeable
+    int                origList;                        //!< FIXME currently a fix around the collision seg fault
+    float                   energyMin;                //!< The minimal Energy a Projectile needs to be emitted.
+    bool                    bChargeable;              //!< if the Projectile is Charegeable
 
-    float                  lifeCycle;                 //!< The percentage of the Lifetime done [0-1]
-    float                  lifeSpan;                  //!< The entire lifespan of the Shoot. in seconds
+    float                   lifeCycle;                //!< The percentage of the Lifetime done [0-1]
+    float                   lifeSpan;                 //!< The entire lifespan of the Shoot. in seconds
 
-    Vector                 flightDirection;           //!< DOF direction in which the shoot flighs
+    float                   physDamage;               //!< damage to shield and armor
+    float                   elecDamage;               //!< damage to elctronic
+    float                   turningSpeed;             //!< degrees per tick
 
-    Vector                 velocity;                  //!< velocity of the projectile.
+    Vector                  flightDirection;          //!< DOF direction in which the shoot flighs
 
-    PNode*                 target;                    //!< A target for guided Weapons.
+    Vector                  velocity;                 //!< velocity of the projectile.
+
+    PNode*                  target;                   //!< A target for guided Weapons.
 
     OrxSound::SoundSource  soundSource;

branches/playability.new/src/world_entities/space_ships/space_ship.cc

@@ -23 +23 @@
 
 #include "weapons/test_gun.h"
+#include "weapons/light_blaster.h"
+#include "weapons/medium_blaster.h"
+#include "weapons/heavy_blaster.h"
+#include "weapons/swarm_launcher.h"
+#include "weapons/spike_launcher.h"
+#include "weapons/spike_thrower.h"
+#include "weapons/acid_launcher.h"
+#include "weapons/boomerang_gun.h"
 #include "weapons/turret.h"
 #include "weapons/cannon.h"
 
+#include "elements/glgui_energywidgetvertical.h"
+#include "glgui_bar.h"
+
 #include "particles/dot_emitter.h"
+#include "particles/emitter_node.h"
 #include "particles/sprite_particles.h"
+#include "effects/trail.h"
+
+#include "effects/wobblegrid.h"
 
 #include "util/loading/factory.h"
@@ -44 +59 @@
 #include "state.h"
 #include "player.h"
+#include "camera.h"
+
 
 #include "util/loading/load_param.h"
+#include "time.h"
+
+#include "track/track.h"
+#include "math.h"
 
 
 // #include "lib/gui/gl_gui/glgui_bar.h"
 // #include "lib/gui/gl_gui/glgui_pushbutton.h"
-
 
 
@@ -70 +90 @@
                         ->addMethod("getAbsCoorY", Executor0ret<PNode, lua_State*, float>(&PNode::getAbsCoorY))
                         ->addMethod("getAbsCoorZ", Executor0ret<PNode, lua_State*, float>(&PNode::getAbsCoorZ))
+                        //->addMethod("setCameraSpeed", Executor1<SpaceShip, lua_State*, float>(&SpaceShip::setCameraSpeed))
                        );
 
@@ -85 +106 @@
  */
 SpaceShip::SpaceShip(const std::string& fileName)
+    : secWeaponMan(this) //,
+    //supportedPlaymodes(Playable::Vertical) ,
+    //playmode(Playable::Vertical)
 {
   this->init();
@@ -105 +129 @@
 */
 SpaceShip::SpaceShip(const TiXmlElement* root)
+    : secWeaponMan(this) //,
+    //supportedPlaymodes(Playable::Vertical) ,
+    //playmode(Playable::Vertical)
 {
   this->init();
+  //this->setParentMode(PNODE_REPARENT_DELETE_CHILDREN);
   if (root != NULL)
     this->loadParams(root);
@@ -118 +146 @@
 void SpaceShip::init()
 {
+
+  srand(time(0));   //initialize Random Nomber Generator
+
   //  this->setRelDir(Quaternion(M_PI, Vector(1,0,0)));
   this->registerObject(this, SpaceShip::_objectList);
-
   PRINTF(4)("SPACESHIP INIT\n");
-
+  this->weaponMan.setParentEntity( this);
   //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_CANNON));
-
-  //cannon->setName("BFG");
-
-  this->addWeapon(wpLeft, 1, 0);
-  this->addWeapon(wpRight,1 ,1);
-  //this->addWeapon(cannon, 0, 6);
-
-  this->getWeaponManager().changeWeaponConfig(1);
-
-  bUp = bDown = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = false;
-
-  xMouse = yMouse = 0;
-  yInvert = 1;
-  mouseSensitivity = 0.001;
-  airViscosity = 0.9;
-  controlVelocityX = 25;
-  controlVelocityY = 150;
-  shipInertia = 1.5;
-  //  cycle = 0.0;
-
-  this->setHealthMax(100);
-  this->setHealth(80);
-
-  travelSpeed = 0.0;
-  acceleration = 3;
-  this->velocity = this->getAbsDirX()*travelSpeed;
-  this->mouseDir = this->getAbsDir();
-  this->pitchDir = this->getAbsDir();
-
-  //   GLGuiButton* button = new GLGuiPushButton();
-  //    button->show();
-  //    button->setLabel("orxonox");
-  //    button->setBindNode(this);
-  //     GLGuiBar* bar = new GLGuiBar();
-  //     bar->show();
-  //     bar->setValue(7.0);
-  //     bar->setMaximum(10);
-  //     bar->setSize2D( 20, 100);
-  //     bar->setAbsCoor2D( 10, 200);
+  
+  Weapon* wpRight1 = new LightBlaster ();
+  wpRight1->setName( "LightBlaster");
+  Weapon* wpLeft1 = new LightBlaster ();
+  wpLeft1->setName( "LightBlaster");
+
+  Weapon* wpRight2 = new MediumBlaster ();
+  wpRight2->setName( "MediumBlaster");
+  Weapon* wpLeft2 = new MediumBlaster ();
+  wpLeft2->setName( "MediumBlaster");
+
+  Weapon* wpRight3 = new HeavyBlaster (1);
+  wpRight3->setName( "HeavyBlaster");
+  Weapon* wpLeft3 = new HeavyBlaster (0);
+  wpLeft3->setName( "HeavyBlaster");
+
+  Weapon* cannon = new SwarmLauncher();
+  cannon->setName( "SwarmLauncher");
+
+  Weapon* spike = new SpikeThrower();
+  spike->setName( "SpikeThrower" );
+
+
+  Weapon* acid0 = new AcidLauncher();
+  acid0->setName( "AcidSplasher" );
+
+  Weapon* acid1 = new AcidLauncher();
+  acid1->setName( "AcidSplasher" );
+
+
+  this->weaponMan.addWeapon( wpLeft1, 0, 0);
+  this->weaponMan.addWeapon( wpRight1, 0, 1);
+
+  this->weaponMan.addWeapon( wpLeft2, 1, 2);
+  this->weaponMan.addWeapon( wpRight2, 1, 3);
+
+  this->weaponMan.addWeapon( wpLeft3, 2, 4);
+  this->weaponMan.addWeapon( wpRight3, 2, 5);
+/*
+  this->weaponMan.addWeapon( wpLeft1, 3, 0);
+  this->weaponMan.addWeapon( wpRight1, 3, 1);
+
+  this->weaponMan.addWeapon( wpLeft2, 3, 2);
+  this->weaponMan.addWeapon( wpRight2, 3, 3);
+
+  this->weaponMan.addWeapon( wpLeft3, 3, 4);
+  this->weaponMan.addWeapon( wpRight3, 3, 5);
+*/
+
+  this->weaponMan.addWeapon( acid0, 3, 0);
+  this->weaponMan.addWeapon( acid1, 3, 1);
+
+
+  this->secWeaponMan.addWeapon( cannon, 0, 2);
+  this->secWeaponMan.addWeapon( spike, 1, 3);
+//   this->secWeaponMan.addWeapon( acid0, 2, 2);
+//   this->secWeaponMan.addWeapon( acid1, 2, 3);
+
+
+  this->weaponMan.changeWeaponConfig(3);
+  this->secWeaponMan.changeWeaponConfig(1);
+
+  curWeaponPrimary    = 0;
+  curWeaponSecondary  = 1;
+
+  Playable::weaponConfigChanged();
+
+  reactorOutput     = 10;
+
+  weaponEnergyRegen = 10;       // 10 einheiten pro Sekunde
+  engineSpeedBase   = 5;
+  shieldRegen       = 2;
+
+  shieldEnergyShare = 0.3;
+  weaponEnergyShare = 0.3;
+  engineEnergyShare = 0.4;
+
+  shieldCur         = 20;
+  shieldMax         = 100;
+  shieldTH          = .2 * shieldMax;   // shield power must be 20% before shield kicks in again
+
+  this->setHealth( 20);
+  this->setHealthMax( 100);
+
+  electronicCur = 50;
+  electronicMax = 50;
+  electronicRegen   = 3;
+  electronicTH      = .7 * electronicMax; // 30% of eDamage can be handled by the ship
+
+
+  this->loadModel("models/ships/mantawing.obj");
+  //this->setVisibiliy(false);
+
+  bForward = bBackward = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = bFire = bSecFire = false;
+
+  this->setHealthMax(shieldMax);
+  this->setHealth(shieldCur);
+
+  this->travelNode = new PNode();
+
+  // camera - issue
+  this->cameraNode.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  this->cameraNode.addNodeFlags(PNODE_PROHIBIT_CHILD_DELETE);
+
+  // widget handling
+  /*
+  this->electronicWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+  this->electronicWidget->setDisplayedName(std::string(this->getClassName()) + " Electronics:");
+  this->electronicWidget->setSize2D(30,400);
+  this->electronicWidget->setAbsCoor2D(150,200);
+  this->electronicWidget->shiftDir2D(270);
+  this->updateElectronicWidget();
+  this->shieldWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+  this->shieldWidget->setDisplayedName(std::string(this->getClassName()) + " Shield:");
+  this->shieldWidget->setSize2D(30,400);
+  this->shieldWidget->setAbsCoor2D(200,200);
+  this->shieldWidget->shiftDir2D(270);
+  this->updateShieldWidget();
+  if (this->hasPlayer())
+  {
+    State::getPlayer()->hud().setShiledWidget(this->shieldWidget);
+    State::getPlayer()->hud().setEnergyWidget(this->electronicWidget);
+  }
+  */
+  this->electronicWidget = NULL;
+  this->shieldWidget = NULL;
 
   //add events to the eventlist
@@ -177 +289 @@
   //registerEvent(SDLK_e);
   registerEvent(KeyMapper::PEV_FIRE1);
+  registerEvent(KeyMapper::PEV_FIRE2);                  // Added for secondary weapon support
   registerEvent(KeyMapper::PEV_NEXT_WEAPON);
   registerEvent(KeyMapper::PEV_PREVIOUS_WEAPON);
@@ -183 +296 @@
   registerEvent(EV_MOUSE_MOTION);
 
-  this->getWeaponManager().setSlotCount(7);
-
-  this->getWeaponManager().setSlotPosition(0, Vector(-2.6, .1, -3.0));
-  this->getWeaponManager().setSlotCapability(0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
-
-  this->getWeaponManager().setSlotPosition(1, Vector(-2.6, .1, 3.0));
-  this->getWeaponManager().setSlotCapability(1, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
-
-  this->getWeaponManager().setSlotPosition(2, Vector(-1.5, .5, -.5));
-  this->getWeaponManager().setSlotDirection(2, Quaternion(-M_PI_4*.5, Vector(1,0,0)));
-
-  this->getWeaponManager().setSlotPosition(3, Vector(-1.5, .5, .5));
-  this->getWeaponManager().setSlotDirection(3, Quaternion(M_PI_4*.5, Vector(1,0,0)));
-
-  this->getWeaponManager().setSlotPosition(4, Vector(-1.5, -.5, .5));
-  this->getWeaponManager().setSlotDirection(4, Quaternion(-M_PI_4*.5+M_PI, Vector(1,0,0)));
-
-  this->getWeaponManager().setSlotPosition(5, Vector(-1.5, -.5, -.5));
-  this->getWeaponManager().setSlotDirection(5, Quaternion(+M_PI_4*.5-M_PI, Vector(1,0,0)));
-  //
-  this->getWeaponManager().setSlotPosition(6, Vector(-1, 0.0, 0));
-  this->getWeaponManager().setSlotCapability(6, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
-  //
-  //   this->getWeaponManager().setSlotPosition(8, Vector(-2.5, -0.3, -2.0));
-  //   this->getWeaponManager().setSlotDirection(8, Quaternion(-M_PI, Vector(1,0,0)));
-  //
-  //   this->getWeaponManager().setSlotPosition(9, Vector(-2.5, -0.3, 2.0));
-  //   this->getWeaponManager().setSlotDirection(9, Quaternion(+M_PI, Vector(1,0,0)));:
-
-  this->getWeaponManager().getFixedTarget()->setParent(this);
-  this->getWeaponManager().getFixedTarget()->setRelCoor(100000,0,0);
-
-  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
-
-  this->burstEmitter = new DotEmitter(200, 0.0, .01);
-  this->burstEmitter->setParent(this);
-  this->burstEmitter->setRelCoor(-1, .5, 0);
-  this->burstEmitter->setName("SpaceShip_Burst_emitter");
+  this->weaponMan.setParentEntity( this);
+  this->secWeaponMan.setParentEntity( this);
+
+  this->weaponMan.setSlotCount(8);
+
+  this->weaponMan.setSlotPosition(0, Vector(0.0, 0, -3.0));
+  this->weaponMan.setSlotCapability(0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+
+  this->weaponMan.setSlotPosition(1, Vector(0.0, 0, 3.0));
+  this->weaponMan.setSlotCapability(1, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+
+  this->weaponMan.setSlotPosition(2, Vector(1.0, 0, -1.5));
+  this->weaponMan.setSlotDirection(2, Quaternion(-M_PI_4*.5, Vector(1,0,0)));
+
+  this->weaponMan.setSlotPosition(3, Vector(1.0, 0, 1.5));
+  this->weaponMan.setSlotDirection(3, Quaternion(M_PI_4*.5, Vector(1,0,0)));
+
+  this->weaponMan.setSlotPosition(4, Vector(1.5, 0, .5));
+  this->weaponMan.setSlotDirection(4, Quaternion(-M_PI_4*.5+M_PI, Vector(1,0,0)));
+
+  this->weaponMan.setSlotPosition(5, Vector(1.5, 0, -.5));
+  this->weaponMan.setSlotDirection(5, Quaternion(+M_PI_4*.5-M_PI, Vector(1,0,0)));
+
+  this->weaponMan.setSlotPosition(6, Vector(0.5, 0, 2.5));
+  this->weaponMan.setSlotDirection(6, Quaternion(-M_PI_4*.5+M_PI, Vector(1,0,0)));
+
+  this->weaponMan.setSlotPosition(7, Vector(0.5, 0, -2.5));
+  this->weaponMan.setSlotDirection(7, Quaternion(+M_PI_4*.5-M_PI, Vector(1,0,0)));
 
   this->burstSystem = new SpriteParticles(1000);
@@ -236 +339 @@
   this->burstSystem->setColor(1.0, .8,.8,.8,.0);
 
-  registerVar( new SynchronizeableVector( &velocity, &velocity, "velocity", PERMISSION_MASTER_SERVER ) );
-  registerVar( new SynchronizeableQuaternion( &mouseDir, &mouseDir, "mousedir", PERMISSION_OWNER ) );
-
-  registerVar( new SynchronizeableBool( &bUp, &bUp, "bUp", PERMISSION_OWNER ) );
-  registerVar( new SynchronizeableBool( &bDown, &bDown, "bDown", PERMISSION_OWNER ) );
+  this->secWeaponMan.setSlotPosition(0, Vector(1.5, 0, 0));
+  this->secWeaponMan.setSlotCapability(0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+
+  this->secWeaponMan.setSlotPosition(1, Vector(2.6, 0, 3.0));
+  this->secWeaponMan.setSlotCapability(1, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+
+  this->secWeaponMan.setSlotPosition(2, Vector(1.5, 0, -.5));
+  this->secWeaponMan.setSlotDirection(2, Quaternion(-M_PI_4*.5, Vector(1,0,0)));
+
+  this->secWeaponMan.setSlotPosition(3, Vector(1.5, 0, .5));
+  this->secWeaponMan.setSlotDirection(3, Quaternion(M_PI_4*.5, Vector(1,0,0)));
+
+  this->secWeaponMan.setSlotPosition(4, Vector(1.5, 0, .5));
+  this->secWeaponMan.setSlotDirection(4, Quaternion(-M_PI_4*.5+M_PI, Vector(1,0,0)));
+
+  this->secWeaponMan.setSlotPosition(5, Vector(1.5, 0, -.5));
+  this->secWeaponMan.setSlotDirection(5, Quaternion(+M_PI_4*.5-M_PI, Vector(1,0,0)));
+
+
+  this->weaponMan.getFixedTarget()->setParent(this);
+  this->weaponMan.getFixedTarget()->setRelCoor(100000,0,0);
+
+  
+  this->secWeaponMan.getFixedTarget()->setParent(this);
+  this->secWeaponMan.getFixedTarget()->setRelCoor(100000,0,0);
+  this->secWeaponMan.setRotationSpeed(0);
+
+  dynamic_cast<Element2D*>(this->weaponMan.getFixedTarget())->setVisibility( false);
+
+
+  registerVar( new SynchronizeableBool( &bForward, &bForward, "bForward", PERMISSION_OWNER ) );
+  registerVar( new SynchronizeableBool( &bBackward, &bBackward, "bBackward", PERMISSION_OWNER ) );
   registerVar( new SynchronizeableBool( &bLeft, &bLeft, "bLeft", PERMISSION_OWNER ) );
   registerVar( new SynchronizeableBool( &bRight, &bRight, "bRight", PERMISSION_OWNER ) );
-  registerVar( new SynchronizeableBool( &bAscend, &bAscend, "bAscend", PERMISSION_OWNER ) );
-  registerVar( new SynchronizeableBool( &bDescend, &bDescend, "bDescend", PERMISSION_OWNER ) );
-  registerVar( new SynchronizeableBool( &bRollL, &bRollL, "bRollL", PERMISSION_OWNER ) );
-  registerVar( new SynchronizeableBool( &bRollR, &bRollR, "bRollR", PERMISSION_OWNER ) );
+  registerVar( new SynchronizeableFloat( &cameraLook, &cameraLook, "cameraLook", PERMISSION_OWNER ) );
+  registerVar( new SynchronizeableFloat( &rotation, &rotation, "rotation", PERMISSION_OWNER ) );
+  registerVar( new SynchronizeableBool( &bFire, &bFire, "bSecFire", PERMISSION_OWNER));
+  registerVar( new SynchronizeableVector( &velocity, &velocity, "velocity", PERMISSION_MASTER_SERVER ) );
+
+  //this->airFriction = 0.5f;
+  //this->travelDistancePlus = Vector2D(38.0, 43.0);
+  //this->travelDistanceMinus = Vector2D(-38.0, -43.0);
+  this->travelDistancePlus = Vector2D(50,50);
+  this->travelDistanceMinus = Vector2D(-50,-50);
+  this->isTravelDistanceInit = true;
+  this->actionWidthPercentage = 1;
+
+  this->cameraSpeed = 40;
+  this->cameraLook = 0.0f;
+  //this->airFriction = 0.0f;
+
+  srand(time(0));  //initaialize RNG
+
+  this->travelNode->debugDraw();
+
+  this->setSupportedPlaymodes(Playable::Horizontal | Playable::Vertical);
+
+  /// FIXME
+  this->trail = new Trail( 5, 10, .2, this);
+  this->trail->setTexture( "maps/engine.png");
+
+  this->trailL = new Trail( 5, 10, .2, this);
+  this->trailL->setTexture( "maps/engine.png");
+
+  this->trailR = new Trail( 5, 10, .2, this);
+  this->trailR->setTexture( "maps/engine.png");
+
+
+  this->toList(OM_GROUP_00);
+
+  //FIXME Just testaddition to show the wobblegrid
+/*
+  this->test  = new Wobblegrid(5);
+  test->setTexture("maps/blub.png");
+  
+  test->setAbsCoor( this->getAbsCoor() + Vector(0, 2, 0));
+  test->setParent( this);
+*/
+  
 }
 
@@ -257 +428 @@
 {
   Playable::loadParams(root);
-}
-
-void SpaceShip::setPlayDirection(const Quaternion& quat, float speed)
-{
-  this->mouseDir = quat;
-}
-
+
+  LoadParam(root, "playmode", this, SpaceShip, setPlaymodeXML);
+  LoadParam(root, "cameraDistance", this, SpaceShip, setCameraDistance);
+  LoadParam(root, "cameraFovy", this, SpaceShip, setCameraFovy);
+  LoadParam(root, "actionWidthPercentage", this, SpaceShip, setActionWidthPercentage);
+
+  State::getCamera()->setViewMode(Camera::ViewTop);
+}
+
+
+void SpaceShip::setPlayDirection(const Quaternion& rot, float speed)
+{
+  //this->direction = Quaternion (rot.getHeading(), Vector(0,1,0));
+}
 
 void SpaceShip::reset()
 {
-  bUp = bDown = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = false;
-
-  xMouse = yMouse = 0;
+  bForward = bBackward = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = bFire = bSecFire = false;
+
+  //xMouse = yMouse = 0;
 
   this->setHealth(80);
@@ -278 +456 @@
 void SpaceShip::enter()
 {
-  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( true);
-  this->attachCamera();
+  this->secWeaponMan.showCrosshair();
+  this->toList( OM_GROUP_01 );
+  State::getPlayer()->hud().setRadarCenterNode(this->travelNode);
+  State::getPlayer()->hud().setOverlayActive(true);
+  //dynamic_cast <OrxGui::GLGuiEnergyWidgetVertical*> (State::getPlayer()->hud().getArmorWidget())->setDisplayedName("Armor");
+  //dynamic_cast<Element2D*>(this->secWeaponMan.getFixedTarget())->setVisibility( true);
+  //this->attachCamera();
+ // this->setPlaymode(Playable::Horizontal);
 }
 
 void SpaceShip::leave()
 {
-  dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( false);
-  this->detachCamera();
+  this->secWeaponMan.hideCrosshair();
+  this->toList( OM_GROUP_00);
+  State::getPlayer()->hud().setOverlayActive(false);
+  State::getCamera()->setEventHandling(true);
+  State::getPlayer()->hud().setRadarCenterNode(NULL);
+  //dynamic_cast<Element2D*>(this->secWeaponMan.getFixedTarget())->setVisibility( false);
+  //this->detachCamera();
 }
 
@@ -294 +483 @@
 void SpaceShip::postSpawn ()
 {
+  if(this->hasPlayer())
+    Playable::postSpawn();
+
   //setCollision(new CollisionCluster(1.0, Vector(0,0,0)));
 }
@@ -301 +493 @@
 */
 void SpaceShip::leftWorld ()
-{}
+{
+
+}
 
 WorldEntity* ref = NULL;
-/**
- *  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 SpaceShip::collidesWith(WorldEntity* entity, const Vector& location)
-{
-}
 
 /**
@@ -321 +506 @@
   WorldEntity::draw();
 
+  glMatrixMode(GL_MODELVIEW);
+  glPushMatrix();
+
+  float matrix[4][4];
+  glTranslatef (this->getAbsCoor ().x-1, this->getAbsCoor ().y-.2, this->getAbsCoor ().z);
+  this->getAbsDir().matrix (matrix);
+  glMultMatrixf((float*)matrix);
+  //glScalef(2.0, 2.0, 2.0);  // no double rescale
+        // FIXME
+  this->trail->draw();
+  
+  glTranslatef(0,0,-.5);
+  this->trailL->draw();
+
+  glTranslatef(0,0,1);
+  this->trailR->draw();
+
+  glPopMatrix();
   //this->debug(0);
 }
@@ -330 +533 @@
 void SpaceShip::tick (float time)
 {
-  Playable::tick(time);
-
-  if( ( xMouse != 0 || yMouse != 0 ) && this->getOwner() == SharedNetworkData::getInstance()->getHostID() )
-  {
-    if (xMouse > controlVelocityX) xMouse = controlVelocityX;
-    else if (xMouse < -controlVelocityX) xMouse = -controlVelocityX;
-    if (yMouse > controlVelocityY) yMouse = controlVelocityY;
-    else if (yMouse < -controlVelocityY) yMouse = -controlVelocityY;
-
-    pitchDir = (Quaternion(xMouse*mouseSensitivity*0.5, Vector(1,0,0)));
-
-    mouseDir *= (Quaternion(-M_PI/4*xMouse*mouseSensitivity, Vector(0,1,0))*Quaternion(-M_PI/4*yMouse*mouseSensitivity*yInvert, Vector(0,0,1))*pitchDir);
-    xMouse = yMouse = 0;
-  }
-
-
-  //   if( this != State::getPlayer()->getControllable())
-  //     return;
-
-  // spaceship controlled movement fire(bool bF){ this->bFire = bF;}
-  //if (this->getOwner() == this->getHostID())
-  this->calculateVelocity(time);
-
-
-  Vector move = velocity*time;
-
-  //orient the velocity in the direction of the spaceship.
-  travelSpeed = velocity.len();
-  velocity += ((this->getAbsDirX())*travelSpeed-velocity)*airViscosity;
-  velocity = (velocity.getNormalized())*travelSpeed;
-  this->burstEmitter->setEmissionRate(travelSpeed);
-  this->burstEmitter->setEmissionVelocity(travelSpeed*.5, travelSpeed *.1);
+  // Playable::tick(time);
+
+ // this->test->tick(time);
+
+  // Own Tick Setup, as a different fire routine is used on the weapon manager
+  this->weaponMan.tick(time);
+  this->secWeaponMan.tick(time);
+
+  if( this->systemFailure() )
+    bFire = bSecFire = false;
+
+  // fire reqeust/release for primary weapons
+  if( this->bFire)
+    this->weaponMan.fire();
+  else
+    this->weaponMan.releaseFire();
+
+  // fire reqeust/release for secondary weapons
+  if( this->bSecFire)
+    this->secWeaponMan.fire();
+  else
+    this->secWeaponMan.releaseFire();
+    
+  // Tracktick
+  if(this->entityTrack)
+    this->entityTrack->tick(time);
+
+
+  // Shield Regeneration and other regular calculations on the ship 
+  this->regen(time);
+
+  // Weapon Regeneration and other regular calculations on the ship
+  this->weaponRegen(time);
+
+  // current engine speed output
+  this->engineSpeedCur = this->engineSpeedBase + this->reactorOutput * this->engineEnergyShare;
+
+  // calculation of maxSpeed and acceleration:
+  this->travelSpeed = this->engineSpeedCur * 5;
+  this->acceleration = this->travelSpeed * 2;
+
+  this->movement(time);
+
+   // TRYING TO FIX PNode.
+  this->cameraNode.setAbsCoorSoft(this->getAbsCoor() + Vector(0.0f, 5.0f, 0.0f), 30.0f);
+  this->cameraNode.setRelDirSoft(this->getAbsDir(), 30.0f);
+
+  
+  this->velocity  = (this->getAbsCoor() - this->oldPos) / time;
+  this->oldPos    = this->getAbsCoor();
+
+//FIXME
+  this->trail->tick(time);
+  this->trailL->tick(time);
+  this->trailR->tick(time);
+
+  if (!this->isTravelDistanceInit)
+  {
+    this->updateTravelDistance();
+    //this->isTravelDistanceInit = true;
+  }
 
   //orient the spaceship in direction of the mouse
+  /*
   rotQuat = Quaternion::quatSlerp( this->getAbsDir(), mouseDir, 0.5);//fabsf(time)*shipInertia);
   if (this->getAbsDir().distance(rotQuat) > 0.00000000000001)
     this->setAbsDir( rotQuat);
   //this->setAbsDirSoft(mouseDir,5);
-
-  // this is the air friction (necessary for a smooth control)
-  if(travelSpeed >= 120) velocity -= velocity.getNormalized()*travelSpeed*travelSpeed*0.0001;
-  else if (travelSpeed <= 80) velocity -= velocity.getNormalized()*travelSpeed*0.001;
-
-  //other physics (gravity)
-  //if(travelSpeed < 120)
-  //move += Vector(0,-1,0)*60*time + Vector(0,1,0)*travelSpeed/2*time;
-
-  //hoover effect
-  //cycle += time;
-  //this->shiftCoor(Vector(0,1,0)*cos(this->cycle*2.0)*0.02);
-
-  //readjust
-  //if (this->getAbsDirZ().y > 0.1) this->shiftDir(Quaternion(time*0.3, Vector(1,0,0)));
-  //else if (this->getAbsDirZ().y < -0.1) this->shiftDir(Quaternion(-time*0.3, Vector(1,0,0)));
-
-  //SDL_WarpMouse(GraphicsEngine::getInstance()->getResolutionX()/2, GraphicsEngine::getInstance()->getResolutionY()/2);
-
+  */
+  /*
   this->shiftCoor(move);
+  */
 
   //   PRINTF(0)("id of %s is: %i\n", this->getName(), this->getOMListNumber());
 
-}
-
-/**
- *  calculate the velocity
- * @param time the timeslice since the last frame
-*/
-void SpaceShip::calculateVelocity (float time)
-{
-  Vector accel(0.0, 0.0, 0.0);
-  /*
-  Vector rot(0.0, 0.0, 0.0); // wird ben�igt fr Helicopter
-  */
-  //float rotVal = 0.0;
-  /* FIXME: calculating the direction and orthDirection every timeSlice is redundant! save it somewhere */
-  /* calculate the direction in which the craft is heading  */
-
-  //Plane plane(Vector(0,1,0), Vector(0,0,0));
-
-  if( this->bUp )
-  {
-    //this->shiftCoor(this->getAbsDirX());
-    //accel += (this->getAbsDirX())*2;
-    accel += (this->getAbsDirX())*acceleration;
-
-  }
-
-  if( this->bDown )
-  {
-    //this->shiftCoor((this->getAbsDirX())*-1);
-    //accel -= (this->getAbsDirX())*2;
-    //if(velocity.len() > 50)
-    accel -= (this->getAbsDirX())*0.5*acceleration;
-
-
-
-  }
-
-  if( this->bLeft/* > -this->getRelCoor().z*2*/)
-  {
-    this->shiftDir(Quaternion(time, Vector(0,1,0)));
-    //    accel -= rightDirection;
-    //velocityDir.normalize();
-    //rot +=Vector(1,0,0);
-    //rotVal -= .4;
-  }
-  if( this->bRight /* > this->getRelCoor().z*2*/)
-  {
-    this->shiftDir(Quaternion(-time, Vector(0,1,0)));
-
-    //    accel += rightDirection;
-    //velocityDir.normalize();
-    //rot += Vector(1,0,0);
-    //rotVal += .4;
-  }
-
-
-  if( this->bRollL /* > -this->getRelCoor().z*2*/)
-  {
-    mouseDir *= Quaternion(-time*2, Vector(1,0,0));
-    //    accel -= rightDirection;
-    //velocityDir.normalize();
-    //rot +=Vector(1,0,0);
-    //rotVal -= .4;
-  }
-  if( this->bRollR /* > this->getRelCoor().z*2*/)
-  {
-    mouseDir *= Quaternion(time*2, Vector(1,0,0));
-
-    //    accel += rightDirection;
-    //velocityDir.normalize();
-    //rot += Vector(1,0,0);
-    //rotVal += .4;
-  }
-  if (this->bAscend )
-  {
-    this->shiftDir(Quaternion(time, Vector(0,0,1)));
-
-    //    accel += upDirection;
-    //velocityDir.normalize();
-    //rot += Vector(0,0,1);
-    //rotVal += .4;
-  }
-  if (this->bDescend )
-  {
-    this->shiftDir(Quaternion(-time, Vector(0,0,1)));
-
-    //    accel -= upDirection;
-    //velocityDir.normalize();
-    //rot += Vector(0,0,1);
-    //rotVal -= .4;
-  }
-
-  velocity += accel*time*10;
-  //rot.normalize();
-  //this->setRelDirSoft(Quaternion(rotVal, rot), 5);
 }
 
@@ -493 +615 @@
 void SpaceShip::process(const Event &event)
 {
-  Playable::process(event);
-
+  //Playable::process(event);
+  
   if( event.type == KeyMapper::PEV_LEFT)
-    this->bRollL = event.bPressed;
+    this->bLeft = event.bPressed;
   else if( event.type == KeyMapper::PEV_RIGHT)
-    this->bRollR = event.bPressed;
+  {
+    this->bRight = event.bPressed;
+    printf("ShipCoorX: %f \n", this->getRelCoor().x);
+  }
   else if( event.type == KeyMapper::PEV_FORWARD)
-    this->bUp = event.bPressed; //this->shiftCoor(0,.1,0);
+  {
+    this->bForward = event.bPressed; //this->shiftCoor(0,.1,0);
+    
+  }
   else if( event.type == KeyMapper::PEV_BACKWARD)
-    this->bDown = event.bPressed; //this->shiftCoor(0,-.1,0);
+    this->bBackward = event.bPressed; //this->shiftCoor(0,-.1,0);
+  else if( event.type == KeyMapper::PEV_FIRE2)
+    this->bSecFire = event.bPressed;
+  else if( event.type == KeyMapper::PEV_FIRE1)
+    this->bFire = event.bPressed;
+  else if( event.type == KeyMapper::PEV_NEXT_WEAPON && event.bPressed)
+  {
+    this->nextWeaponConfig();
+  }
+  else if ( event.type == KeyMapper::PEV_PREVIOUS_WEAPON && event.bPressed)
+    this->previousWeaponConfig();
+
+  if (!(State::getCamera()->getEventHandling()))
+  {
+    if( event.type == KeyMapper::PEV_VIEW0)
+    {
+      State::getCamera()->setViewMode(Camera::ViewNormal);
+      State::getCameraTargetNode()->setParent(this);
+      State::getCamera()->setParent(this);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW1)
+    {
+      State::getCamera()->setViewMode(Camera::ViewBehind);
+      State::getCameraTargetNode()->setParent(this);
+      State::getCamera()->setParent(this);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW2)
+    {
+      State::getCamera()->setViewMode(Camera::ViewFront);
+      State::getCameraTargetNode()->setParent(this);
+      State::getCamera()->setParent(this);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW3)
+    {
+      State::getCamera()->setViewMode(Camera::ViewLeft);
+      State::getCameraTargetNode()->setParent(this);
+      State::getCamera()->setParent(this);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW4)
+    {
+      State::getCamera()->setViewMode(Camera::ViewRight);
+      State::getCameraTargetNode()->setParent(this);
+      State::getCamera()->setParent(this);
+    }
+    else if( event.type == KeyMapper::PEV_VIEW5)
+    {
+      State::getCamera()->setViewMode(Camera::ViewTop);
+      State::getCameraTargetNode()->setParent(this->travelNode);
+      State::getCamera()->setParent(this->travelNode);
+    }
+  }
+
+
+  /*
   else if( event.type == EV_MOUSE_MOTION)
   {
+
     this->xMouse += event.xRel;
     this->yMouse += event.yRel;
   }
+  */
 }
 
 void SpaceShip::destroy( WorldEntity* killer )
 {
-  PRINTF(0)("spaceship destroy\n");
+  if(this->hasPlayer())
+    Playable::destroy( killer);
+
+  PRINTF(5)("spaceship destroy\n");
+
+  EmitterNode* node  = NULL;
+  DotEmitter* emitter = NULL;
+  SpriteParticles*  explosionParticles  = NULL;
+
+  explosionParticles = new SpriteParticles(200);
+  explosionParticles->setName("SpaceShipExplosionParticles");
+  explosionParticles->setLifeSpan(.2, .3);
+  explosionParticles->setRadius(0.0, 10.0);
+  explosionParticles->setRadius(.5, 6.0);
+  explosionParticles->setRadius(1.0, 3.0);
+  explosionParticles->setColor(0.0, 1,1,1,.9);
+  explosionParticles->setColor(0.1,  1,1,0,.9);
+  explosionParticles->setColor(0.5, .8,.4,0,.5);
+  explosionParticles->setColor(1.0, .2,.2,.2,.5);
+
+  
+  emitter = new DotEmitter( 2000, 70, 360);
+  //emitter->setSpread( 0, M_2_PI);
+  emitter->setEmissionRate( 200.0);
+  //emitter->setEmissionVelocity( 200.0);
+  //emitter->setSystem( explosionParticles);
+  //emitter->setAbsCoor( this->getAbsCoor());
+
+  node  = new EmitterNode( .1f);
+  node->setupParticle( emitter, explosionParticles);
+  node->setAbsDir( this->getAbsDir());
+  node->setVelocity( this->getVelocity() * .9f);
+  node->setAbsCoor( this->getAbsCoor());
+  if( !node->start())
+    PRINTF(0)("Explosion node not correctly started!");
+/*
+  PNode* node          = new PNode();
+  node->setAbsCoor(this->getAbsCoor());
+  Explosion* explosion = new Explosion();
+  explosion->explode( node, Vector(5,5,5));
+*/
+/*
+  if( this->hasPlayer())
+  {
+        this->setAbsCoor(Vector(-10000,10000,10000));
+        this->hide();
+  }
+  else
+  {*/
+    this->setAbsCoor( this->getAbsCoor() + Vector(100,0,0) + Vector(1,0,0) * VECTOR_RAND(150).dot(Vector(1,0,0)));
+  //}
+
 }
 
 void SpaceShip::respawn( )
 {
-  toList( OM_PLAYERS );
-}
-
-
-
-
+  Playable::respawn();
+}
+
+
+void SpaceShip::damage(float pDamage, float eDamage){
+  PRINTF(5)("ship hit for (%f,%f) \n",pDamage,eDamage);
+
+  if( this->shieldActive) {
+    if( this->shieldCur > pDamage) {
+      this->shieldCur = this->shieldCur - pDamage;
+    }
+    else { // shield <= pDamage
+      this->shieldCur -=pDamage;
+      this->shieldActive = false; //shield collapses
+      pDamage += this->shieldCur;
+      if( !this->shieldActive) {
+        this->armorCur -= pDamage / 2; // remaining damages hits armor at half rate
+        this->electronicCur -= eDamage;
+      }
+    }
+  }
+  else {
+    this->armorCur = this->armorCur - pDamage;
+    this->electronicCur = this->electronicCur - eDamage;
+  }
+  if( this->armorCur <= 0) { /* FIXME implement shipcrash*/ }
+    this->destroy(this);
+
+  updateElectronicWidget();
+  updateShieldWidget();
+
+  this->setHealth( this->armorCur);
+}
+
+
+void SpaceShip::regen(float time){
+  float tmp;
+  if (this->armorCur != this->armorMax || this->armorRegen != 0){
+    tmp = this->armorCur + this->armorRegen * time;
+    if ( tmp > electronicMax)
+      this->armorCur = this->armorMax;
+    else
+      this->armorCur = tmp;
+  }
+  if (this->shieldCur != this->shieldMax || this->shieldRegen != 0){
+    tmp =  this->shieldCur + (this->shieldRegen + this->reactorOutput * this->shieldEnergyShare) * time;
+    if( tmp > shieldMax)
+      this->shieldCur = this->shieldMax;
+    else
+      this->shieldCur = tmp;
+    this->shieldActive = ( this->shieldActive || this->shieldCur > shieldTH);
+
+    updateShieldWidget();
+  }
+
+  this->setHealth( this->shieldCur);      // FIXME currently just to test share system
+
+  if (this->electronicCur != this->electronicMax || this->electronicRegen != 0){
+    tmp = this->electronicCur + this->electronicRegen * time;
+    if ( tmp > electronicMax)
+      this->electronicCur = this->electronicMax;
+    else
+      this->electronicCur = tmp;
+
+    updateElectronicWidget();
+  }
+
+}
+
+
+/**
+ * Weapon regeneration
+ * does not use any reactor capacity, as it wouldn't work in a consistent way.
+ */
+void SpaceShip::weaponRegen(float time)
+{
+  float energy  = ( this->reactorOutput * this->weaponEnergyShare + this->weaponEnergyRegen) * time;
+  Weapon* weapon;
+  for( unsigned int i=0; i < this->weaponMan.getSlotCount(); i++)
+  {
+    weapon = this->weaponMan.getWeapon(i);
+    if( weapon != NULL && weapon->isActive())
+    {
+      weapon->increaseEnergy( energy);
+    }
+
+  }
+  // weaponMan.increaseAmmunition( weapon, energy);
+}
+
+
+void SpaceShip::enterPlaymode(Playable::Playmode playmode)
+{
+  switch(playmode)
+  {
+    case Playable::Full3D:
+      /*
+      if (State::getCameraNode != NULL)
+      {
+        Vector absCoor = this->getAbsCoor();
+        this->setParent(PNode::getNullParent());
+        this->setAbsCoor(absCoor);
+        State::getCameraNode()->setParentSoft(&this->cameraNode);
+        State::getCameraNode()->setRelCoorSoft(-10, 0,0);
+        State::getCameraTargetNode()->setParentSoft(&this->cameraNode);
+        State::getCameraTargetNode()->setRelCoorSoft(100, 0,0);
+
+      }
+      */
+      //break;
+
+      break;
+    case Playable::Horizontal:
+      if (State::getCameraNode != NULL)
+      {
+        this->debugNode(1);
+        this->travelNode->debugNode(1);
+
+        this->travelNode->setAbsCoor(this->getAbsCoor());
+        this->travelNode->updateNode(0.01f);
+
+        this->isTravelDistanceInit = false;
+
+        if(this->entityTrack)
+           this->travelNode->setParent(this->entityTrack->getTrackNode());
+
+        this->setParent(this->travelNode);
+        this->setRelCoor(0,0,0);
+
+        State::getCameraNode()->setParentSoft(this->travelNode);
+        //State::getCameraNode()->setParentSoft(this);
+        //State::getCameraNode()->setRelCoorSoft(-0.01, 40, 0);
+        State::getCameraTargetNode()->setParentSoft(this->travelNode);
+        //State::getCameraTargetNode()->setParentSoft(this);
+        //State::getCameraTargetNode()->setRelCoorSoft(0,0,0);
+        this->setCameraMode(Camera::ViewTop);
+        State::getCamera()->setEventHandling(false);
+        registerEvent(KeyMapper::PEV_VIEW0);
+        registerEvent(KeyMapper::PEV_VIEW1);
+        registerEvent(KeyMapper::PEV_VIEW2);
+        registerEvent(KeyMapper::PEV_VIEW3);
+        registerEvent(KeyMapper::PEV_VIEW4);
+        registerEvent(KeyMapper::PEV_VIEW5);
+
+        State::getCamera()->setParentMode(PNODE_ALL);
+
+        //this->updateTravelDistance();
+
+        this->debugNode(1);
+        this->travelNode->debugNode(1);
+      }
+      break;
+
+    default:
+      PRINTF(2)("Playmode %s Not Implemented in %s\n", Playable::playmodeToString(this->getPlaymode()).c_str(), this->getClassCName());
+  }
+}
+
+/**
+ * @brief calculate the velocity
+ * @param time the timeslice since the last frame
+*/
+
+void SpaceShip::movement (float dt)
+{
+  //by releasing the buttons, the velocity decreases with airCoeff*Acceleration. Should be strong enough so 
+  //the ship doesn't slide too much. 
+  float airCoeff = 2.5;
+  float pi = 3.14;
+
+  switch(this->getPlaymode())
+  {
+    case Playable::Horizontal:
+    {
+      // these routines will change the travel movement into zero in a short amout of time, if the player
+      // doesn't press any buttons.
+      if (this->travelVelocity.x >= 0)
+      {
+        if (this->travelVelocity.x > airCoeff*this->acceleration * dt)
+          this->travelVelocity.x -= airCoeff* this->acceleration * dt;
+        else
+          this->travelVelocity.x = 0;
+      }
+      else
+      {
+        if (this->travelVelocity.x < -airCoeff*this->acceleration * dt)
+          this->travelVelocity.x += airCoeff* this->acceleration * dt;
+        else
+          this->travelVelocity.x = 0;
+      }
+      if (this->travelVelocity.z >= 0)
+      {
+        if (this->travelVelocity.z > airCoeff*this->acceleration * dt)
+          this->travelVelocity.z -= airCoeff* this->acceleration * dt;
+        else
+          this->travelVelocity.z = 0;
+      }
+      else
+      {
+        if (this->travelVelocity.z < -airCoeff*this->acceleration * dt)
+          this->travelVelocity.z += airCoeff* this->acceleration * dt;
+        else
+          this->travelVelocity.z = 0;
+      }
+    
+      // this will evite, that the ship moves outside the travelDistance- borders,when the player releases all buttons
+      // and its continuing to slide a bit.
+      Vector oldCoor = this->getRelCoor();
+      if (this->getRelCoor().x > this->travelDistancePlus.x) this->setRelCoor(this->travelDistancePlus.x, oldCoor.y, oldCoor.z);
+      if (this->getRelCoor().x < this->travelDistanceMinus.x) this->setRelCoor(this->travelDistanceMinus.x, oldCoor.y, oldCoor.z);
+      if (this->getRelCoor().z > this->travelDistancePlus.y) this->setRelCoor(oldCoor.x, oldCoor.y, this->travelDistancePlus.y);
+      if (this->getRelCoor().z < this->travelDistanceMinus.y) this->setRelCoor(oldCoor.x, oldCoor.y, this->travelDistanceMinus.y);
+    
+      if( this->systemFailure() )
+        bForward = bBackward = bLeft = bRight = false;
+    
+      if( this->bForward )
+      {
+        //printf("ShipCoorX: %f \n", this->getRelCoor().x);
+        if(this->getRelCoor().x < this->travelDistancePlus.x)
+        {
+          if (this->travelVelocity.x < this->travelSpeed)
+          {
+            this->travelVelocity.x += (airCoeff + 1.0)*this->acceleration*dt;
+          }
+          else
+          {
+            this->travelVelocity.x = this->travelSpeed;
+          }
+        }
+        else
+        {
+          this->travelVelocity.x = 0.0f;
+        }
+      }
+    
+      if( this->bBackward )
+      {
+        if(this->getRelCoor().x > this->travelDistanceMinus.x)
+        {
+          if (this->travelVelocity.x > -this->travelSpeed)
+          {
+            this->travelVelocity.x -= (airCoeff + 1.0)*this->acceleration*dt;
+          }
+          else
+          {
+            this->travelVelocity.x = -this->travelSpeed;
+          }
+        }
+        else
+        {
+          this->travelVelocity.x = 0.0f;
+        }
+      }
+    
+      if( this->bLeft)
+      {
+        if(this->getRelCoor().z > this->travelDistanceMinus.y)
+        {
+          if (this->travelVelocity.z > -this->travelSpeed)
+          {
+            this->travelVelocity.z -= (airCoeff + 1.0)*this->acceleration*dt;
+          }
+          else
+          {
+            this->travelVelocity.z = -this->travelSpeed;
+          }
+        }
+        else
+        {
+          this->travelVelocity.z = 0.0f;
+        }
+        this->setRelDirSoft(Quaternion(-pi/6, Vector(1,0,0)), 6);
+      }
+    
+      if( this->bRight)
+      {
+        //printf("ShipCoorZ: %f \n", this->getRelCoor().z);
+        if(this->getRelCoor().z < this->travelDistancePlus.y)
+        {
+          if (this->travelVelocity.z < this->travelSpeed)
+          {
+            this->travelVelocity.z += (airCoeff + 1.0)*this->acceleration*dt;
+          }
+          else
+          {
+            this->travelVelocity.z = this->travelSpeed;
+          }
+        }
+        else
+        {
+          this->travelVelocity.z = 0.0f;
+        }
+        this->setRelDirSoft(Quaternion(pi/6, Vector(1,0,0)), 6);
+      }
+      if (!this->bRight && !this->bLeft)
+      {
+        this->setRelDirSoft(Quaternion(0, Vector(1,0,0)), 6);
+      }
+
+    //normalisation of the vectors (vector sum must be <= travelspeed)
+    float xzNorm = sqrt(pow(this->travelVelocity.x, 2) + pow(this->travelVelocity.z, 2));
+    if (xzNorm > this->travelSpeed)
+    {
+      this->travelVelocity.x = this->travelVelocity.x/xzNorm * this->travelSpeed;
+      this->travelVelocity.z = this->travelVelocity.z/xzNorm * this->travelSpeed;
+    }
+
+    //this moves camera and ship along the travel path.
+    if(!this->entityTrack) 
+       this->travelNode->shiftCoor(Vector(this->cameraSpeed * dt, 0, 0));
+
+    break;
+    }
+    case Playable::Vertical:
+      break;
+    default:
+      PRINTF(4)("Playmode %s Not Implemented in %s\n", Playable::playmodeToString(this->getPlaymode()).c_str(), this->getClassCName());
+  }
+   //set new coordinates calculated through key- events.
+  this->shiftCoor (this->travelVelocity * dt);
+}
+
+void SpaceShip::setPlaymodeXML(const std::string& playmode)
+{
+  this->setPlaymode(Playable::stringToPlaymode(playmode));
+}
+
+/**
+ * @brief jumps to the next WeaponConfiguration
+ */
+void SpaceShip::nextWeaponConfig()
+{
+  PRINTF(0)("Requested next weapon config!\n");
+  this->weaponMan.nextWeaponConfig();
+  Playable::weaponConfigChanged();
+}
+
+/**
+ * @brief moves to the last WeaponConfiguration
+ */
+void SpaceShip::previousWeaponConfig()
+{
+  this->curWeaponPrimary    = (this->curWeaponPrimary + 1) % 3;
+  this->weaponMan.changeWeaponConfig(this->curWeaponPrimary);
+  Playable::weaponConfigChanged();
+}
+
+void SpaceShip::hit( float damage, WorldEntity* killer)
+{
+  this->damage(killer->getDamage(),0);
+}
+
+void SpaceShip::updateElectronicWidget()
+{
+  if (this->electronicWidget != NULL)
+  { //if it exists already: update it
+     this->electronicWidget->setMaximum(this->electronicMax);
+     this->electronicWidget->setValue(this->electronicCur);
+  }
+  else
+  { //create the widget
+    this->electronicWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    this->electronicWidget->getBarWidget()->setChangedValueColor(Color(1,0,0,1));
+    //this->electronicWidget->setDisplayedName("Electronics:");
+    //this->electronicWidget->setSize2D(100,20);
+    //this->electronicWidget->setAbsCoor2D(150,200);
+    this->updateElectronicWidget();
+    if (this->hasPlayer())
+      State::getPlayer()->hud().setEnergyWidget(this->electronicWidget);
+  }
+}
+
+void SpaceShip::updateShieldWidget()
+{
+  if (this->shieldWidget != NULL)
+  { 
+    this->shieldWidget->setMaximum(this->shieldMax);
+    this->shieldWidget->setValue(this->shieldCur);;
+  }
+  else
+  {
+    this->shieldWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    this->shieldWidget->getBarWidget()->setChangedValueColor(Color(1,0,0,1));
+    //this->shieldWidget->setDisplayedName("Shield:");
+    //his->shieldWidget->setSize2D(100,20);
+    //this->shieldWidget->setAbsCoor2D(200,200);
+    this->updateShieldWidget();
+    if (this->hasPlayer())
+      State::getPlayer()->hud().setShiledWidget(this->shieldWidget);
+  }
+}
+
+void SpaceShip::setCameraDistance(float dist)
+{
+  State::getCamera()->setViewTopDistance(dist);
+}
+
+void SpaceShip::setCameraFovy(float fovy)
+{
+  State::getCamera()->setViewTopFovy(fovy);
+}
+
+void SpaceShip::updateTravelDistance()
+{
+  float x = 1.25 * this->actionWidthPercentage * fabsf(State::getCamera()->getAbsCoor().y) * tan(State::getCamera()->getFovy()*M_PI /360.0);
+  float y = x / State::getCamera()->getAspectRatio() / this->actionWidthPercentage;
+  //State::getCamera()->setAbsCoor(-5, 1000, 0);
+
+
+  //State::getCamera()->getAbsCoor().print();
+  //printf("CameraRelCoorY: %f \n", State::getCamera()->getRelCoor().y);
+
+  //printf("x: %f, y: %f \n", x, y);
+  this->travelDistancePlus = Vector2D(y, x);
+  this->travelDistanceMinus = Vector2D(-y, -x);
+
+  State::getPlayer()->hud().setOverlayPercentage(100-int(100*this->actionWidthPercentage));
+  PRINTF(0)("TravelDistance has been updated\n");
+  this->isTravelDistanceInit = true;
+}
+
+void SpaceShip::setActionWidthPercentage(int i) 
+{
+  if (i>100) i=100;
+  if (i<0) i=0;
+  this->actionWidthPercentage = i/100.0;
+
+  if (this->hasPlayer())
+    this->isTravelDistanceInit = false;
+};

branches/playability.new/src/world_entities/space_ships/space_ship.h

@@ -2 +2 @@
  * @file space_ship.h
  * Implements the Control of a Spaceship
+ * Space Ships are the core class for all types of ships in Orxonox
+ * By default is on OM_GROUP_00
+ * If player boards the ship, it is moved to OM_GROUP_01
  */
 
@@ -16 +19 @@
 class ParticleEmitter;
 class ParticleSystem;
+class Trail;
+class Wobblegrid;
 
 class SpaceShip : public Playable
@@ -29 +34 @@
 
     virtual void setPlayDirection(const Quaternion& rot, float speed = 0.0f);
+    /*
+    void setTravelHeight(float travelHeight);
+    void setTravelDistance(const Vector2D& distance);
+    void setTravelDistance(float x, float y);
+    */
+
+    //void setAirFriction(float friction) { this->airFriction = friction; };
 
     virtual void enter();
@@ -41 +53 @@
     virtual void respawn();
 
-    virtual void collidesWith(WorldEntity* entity, const Vector& location);
+    inline Vector getVelocity() { return this->velocity; };
+
     virtual void tick(float time);
     virtual void draw() const;
 
     virtual void process(const Event &event);
+//    virtual void hit (WorldEntity* entity, float damage);
+
+    inline WeaponManager& getWeaponManagerSecondary() { return this->secWeaponMan; };
+
+    //Functions for GUI
+    inline float getShieldCur() { return this->shieldCur; };        //!< returns current shield value
+    inline float getShieldMax() { return this->shieldMax; };        //!< returns maximum shield value
+
+    inline float getArmorCur() { return this->armorCur; };          //!< returns current armor value
+    inline float getArmorMax() { return this->armorMax; };          //!< returns current armor value
+
+    inline float getElectronicCur() { return this->electronicCur; }; //!< returns current electronic value
+    inline float getElectronicMax() { return this->electronicMax; }; //!< returns current electronic value
+
+    inline PNode* getTravelNode() { return this->travelNode; };
+
+    //damage handler
+    virtual void damage(float pDamage, float eDamage);  //!< pDamage physical damage, eDamage electronic damage
+
+    //included by Michel: 
+    virtual void enterPlaymode(Playable::Playmode playmode);
+    void setPlaymodeXML(const std::string& playmode); //recieves the playmode from a string (useful for script implementation)
+    void setActionWidthPercentage(int i);
+    void updateTravelDistance();
+    virtual void movement (float dt);
+
+    //
+
+    void nextWeaponConfig();
+    void previousWeaponConfig();
+
+    virtual void hit(float damage, WorldEntity* killer);
 
   private:
     void init();
 
-    void calculateVelocity(float time);
-
-    bool                  bUp;                //!< up button pressed.
-    bool                  bDown;              //!< down button pressed.
+    //void calculateVelocity(float time);
+
+    void regen(float time);  //!< handler for shield and electronic regeneration
+
+    void weaponRegen(float time);   //!< weapon energy regeneration
+
+    inline bool systemFailure() {  return (this->electronicCur < float(rand())/float(RAND_MAX) * this->electronicTH); };
+
+    void updateElectronicWidget();
+    void updateShieldWidget();
+
+    //WeaponManager         weaponMan;      //!< the primary weapon manager: managing a list of energy weapons to wepaon-slot mapping
+    WeaponManager         secWeaponMan;       //!< the secondary weapon manager: managing a list of special weapons to weapon-slot mapping
+    short                 supportedPlaymodes; //!< What Playmodes are Supported in this Playable.
+    Playable::Playmode    playmode;           //!< The current playmode.
+
+    //ship atributes
+    float       shieldCur;          //!< current shield
+    float       shieldMax;          //!< maximum shield
+    float       shieldEnergyShare;  //!< percentage of reactor output
+    float       shieldRegen;        //!< shield regeneration rate per second
+    float       shieldTH;           //!< shield threshhold for reactivation
+    bool        shieldActive;       //!< wheather the shield is working
+    OrxGui::GLGuiEnergyWidgetVertical* shieldWidget; //!< holds the widget that shows the shield bar
+
+    float       armorCur;           //!< current armor
+    float       armorMax;           //!< maximum armor
+    float       armorRegen;         //!< armor regeneration per tick (usable on bioships?)
+    //note that the armor widget is set on the health- widget in world- entity (see in player.cc)
+
+    float       electronicCur;      //!< current electronic
+    float       electronicMax;      //!< maximum electronic
+    float       electronicRegen;    //!< electronic regenration rate per tick
+    float       electronicTH;       //!< Threshhold for electronic failure
+    OrxGui::GLGuiEnergyWidgetVertical* electronicWidget; //!< holds the widget that shows the electronic bar
+
+    float       engineSpeedCur;     //!< speed output for movement = speed base + energy share part
+    float       engineSpeedBase;    //!< speed base
+    int         enginePowerConsume; //!< energy needed
+    float       engineEnergyShare;  //!< percentage of reactor output
+
+    int         weaponEnergySlot;   //!< number of energy weapon slots
+    int         weaponEnergyUsed;
+    float       weaponEnergyShare;
+    float       weaponEnergyRegen;
+    int         weaponSpecialSlot;  //!< number of special weapon slots
+    int         weaponSpecialUsed;
+
+    float       reactorOutput;      //!< reactor output 
+    float       reactorCapacity;    //!< reactor capacity
+
+    int         curWeaponPrimary;   //!< current primary weapon config 
+    int         curWeaponSecondary; //!< current secondary weapon config
+
+    bool                  bForward;                //!< up button pressed.
+    bool                  bBackward;              //!< down button pressed.
     bool                  bLeft;              //!< left button pressed.
     bool                  bRight;             //!< right button pressed.
     bool                  bAscend;            //!< ascend button pressed.
     bool                  bDescend;           //!< descend button presses.
-//    bool                  bFire;              //!< fire button pressed.(moved to playable)
     bool                  bRollL;             //!< rolling button pressed (left)
     bool                  bRollR;             //!< rolling button pressed (right)
-
+    bool                  bSecFire;           //!< second fire button pressed
+
+    /*
     float                 xMouse;             //!< mouse moved in x-Direction
     float                 yMouse;             //!< mouse moved in y-Direction
@@ -68 +166 @@
     int                   controlVelocityX;
     int                   controlVelocityY;
-//    float                 cycle;              //!< hovercycle
+    */
 
     Vector                velocity;           //!< the velocity of the player.
-    Vector                oldVelocity;        //!< the velocity the player had last synced
+    Vector                oldPos;
+
+// 2D-traveling
+    PNode*                travelNode;
+    float                 travelSpeed;        //!< the current speed of the Ship (to make soft movement)
+    Vector                travelVelocity;     //!< object internal velocity vector for relative movement to the track node
+    Vector2D              travelDistancePlus;     //!< Travel-Distance away from the TravelNode
+    Vector2D              travelDistanceMinus;
+    bool                  isTravelDistanceInit;
+
+    float                 actionWidthPercentage;
+
+// Camera
+    PNode                 cameraNode;
+    float                 cameraLook;
+    float                 rotation;
+    float                 cameraSpeed;
+
+    void                  setCameraDistance(float dist);
+    void                  setCameraFovy(float fovy);
+
+    /*
     Quaternion            mouseDir;           //!< the direction where the player wants to fly
     Quaternion            oldMouseDir;        //!< the direction where the player wanted to fly
@@ -77 +196 @@
     Quaternion            rotQuat;
     Quaternion            pitchDir;
-    float                 travelSpeed;        //!< the current speed of the player (to make soft movement)
-    float                 acceleration;       //!< the acceleration of the player.
-
-    float                 airViscosity;
+    float                 dogdeSpeed;        //!< the dogde Speed of the ship.
+    */
+
+    //Quaternion            direction;          //!< the direction of the ship.
+    float                 acceleration;       //!< the acceleration of the ship.
+    //float                 airFriction;        //!< AirFriction.
+    //float                 airViscosity;
 
     byte                  oldMask;            //!< used for synchronisation
 
-    ParticleEmitter*      burstEmitter;
-    ParticleSystem*       burstSystem;
+    Trail*                trail;              //!< Burst trail
+    Trail*                trailL;              //!< Burst trail
+    Trail*                trailR;              //!< Burst trail
+
+
 };
 

branches/playability.new/src/world_entities/space_ships/spacecraft_2d.cc

@@ -273 +273 @@
 {
   dynamic_cast<Element2D*>(this->getWeaponManager().getFixedTarget())->setVisibility( true);
-  this->setPlaymode(this->getPlaymode());
+//   this->setPlaymode(this->getPlaymode());
+  this->setPlaymode(Playable::Horizontal);
+  this->setTravelSpeed(10.0f);
 }
 

branches/playability.new/src/world_entities/space_ships/spacecraft_2d.h

@@ -66 +66 @@
     float                 acceleration;       //!< the acceleration of the Spacecraft2D.
     float                 airFriction;        //!< AirFriction.
-
     float                 airViscosity;
 

branches/playability.new/src/world_entities/test_entity.cc

@@ -86 +86 @@
 }
 
+void TestEntity::draw() const
+{
+//   if(!mediaLoaded)
+//     false;
 
+  glPushAttrib(GL_ENABLE_BIT);
+  glDisable(GL_LIGHTING);
+//   glDisable(GL_BLEND);
+// 
+//   glEnable(GL_TEXTURE_2D);
+//   glBindTexture(GL_TEXTURE_2D, media_container->getFrameTexture(counter));
+
+  glPushMatrix();
+ /* glTranslatef (this->getAbsCoor ().x,
+                this->getAbsCoor ().y,
+                this->getAbsCoor ().z);
+  glRotatef(axis, 0.0f, 1.0f, 0.0f);*/
+//PRINTF(0)("axis: %f\n", axis);
+
+  glColor3f(1.0, 0, 0);
+
+  glBegin(GL_QUADS);
+    glVertex3f( 0.0f, -100.0f, 0.0f);
+//     glTexCoord2f(1.0f, 1.0f);
+    glVertex3f( 0.0f,  -100.0f , 2000.0f);
+//     glTexCoord2f(0.0f, 1.0f);
+    glVertex3f( 10000.0f,  -100.0f , 2000.0f );
+//     glTexCoord2f(0.0f, 0.0f);
+    glVertex3f( 10000.0f, -100.0f, 0.0f );
+//     glTexCoord2f(1.0f, 0.0f);
+    
+  glEnd();
+
+  glPopMatrix();
+  glPopAttrib();
+}
 
 /**
@@ -98 +133 @@
 
 
-/**
- *
- */
-void TestEntity::draw() const
-{
-
-}
 
 

branches/playability.new/src/world_entities/weapons/weapon.cc

@@ -33 +33 @@
 #include "resource_sound_buffer.h"
 
-#include "elements/glgui_energywidget.h"
+#include "elements/glgui_energywidgetvertical.h"
 
 ObjectListDefinition(Weapon);
@@ -119 +119 @@
   }
 
-  this->soundSource = new OrxSound::SoundSource(this);       //< Every Weapon has exacty one SoundSource.
-  this->emissionPoint.setParent(this);             //< One EmissionPoint, that is a PNode connected to the weapon. You can set this to the exitting point of the Projectiles
-  this->emissionPoint.setName("EmissionPoint");
-  this->emissionPoint.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  this->soundSource = new OrxSound::SoundSource(this);       //< Every Weapon has exacty one SoundSource
+
+  this->barrels = 1;
+  this->segs = 1;
+
+  this->shootAnim = new Animation3D**[this->getBarrels()];
+  for (int i = 0; i < this->getBarrels(); i++)
+    this->shootAnim[i] = new Animation3D* [this->getSegs()];
+
+  this->emissionPoint = new PNode*[this->barrels];
+  for(int i = 0; i < this->barrels; i++){
+    this->emissionPoint[i] = new PNode;
+    this->emissionPoint[i]->setParent(this);             //< One EmissionPoint, that is a PNode connected to the weapon. You can set this to the exitting point of the Projectiles
+    this->emissionPoint[i]->setName("EmissionPoint");
+    this->emissionPoint[i]->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+  }
 
   this->defaultTarget = NULL;                      //< Nothing is Targeted by default.
@@ -145 +157 @@
 
 /**
+ * needed, if there are more than one barrel or segments
+ */
+void Weapon::init2() 
+{
+  if (this->barrels == 1 && this->segs == 1)
+    return;
+
+  delete this->emissionPoint[0];
+  delete this->emissionPoint;
+  delete this->shootAnim[0];
+  delete this->shootAnim;
+
+  this->shootAnim = new Animation3D**[this->barrels];
+  this->emissionPoint = new PNode*[this->barrels];
+  for(int i = 0; i < this->barrels; i++){
+    this->emissionPoint[i] = new PNode;
+    this->emissionPoint[i]->setParent(this);             //< One EmissionPoint, that is a PNode connected to the weapon. You can set this to the exitting point of the Projectiles
+    this->emissionPoint[i]->setName("EmissionPoint");
+    this->emissionPoint[i]->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
+    this->shootAnim[i] = new Animation3D* [this->segs];
+  }
+}
+
+/**
+ * deconstructor for init2
+ */
+void Weapon::deconstr()
+{
+  for(int i = 0; i < this->barrels; i++) {
+    delete this->emissionPoint[i];
+    for (int j = 0; j < this->segs; j++)
+      delete this->shootAnim[i][j];
+    delete this->shootAnim[i];
+  }
+
+  delete this->emissionPoint;
+  delete this->shootAnim;
+}
+
+/**
  * loads the Parameters of a Weapon
  * @param root the XML-Element to load the Weapons settings from
@@ -154 +206 @@
   LoadParam(root, "projectile", this, Weapon, setProjectileTypeC)
   .describe("Sets the name of the Projectile to load onto the Entity");
-
+/*
   LoadParam(root, "emission-point", this, Weapon, setEmissionPoint)
-  .describe("Sets the Point of emission of this weapon");
+  .describe("Sets the Point of emission of this weapon (1: EmmsionVector; 2: EmissionPoint)");*/
 
   LoadParam(root, "state-duration", this, Weapon, setStateDuration)
@@ -253 +305 @@
  * @param point the Point relative to the mass-point of the Weapon
  */
+void Weapon::setEmissionPoint(const Vector& point, int barrel)
+{
+  this->emissionPoint[barrel]->setRelCoor(point);
+}
+
 void Weapon::setEmissionPoint(const Vector& point)
 {
-  this->emissionPoint.setRelCoor(point);
-}
-
+  this->emissionPoint[0]->setRelCoor(point);
+}
 
 /**
@@ -315 +371 @@
 }
 
+Animation3D* Weapon::getAnimation(int barrel, int seg, PNode* node)
+{
+  if (barrel >= this->getBarrels() || seg >= this->getSegs()) // if the state is not known
+    return NULL;
+
+  if (unlikely(this->shootAnim[barrel][seg] == NULL)) // if the animation does not exist yet create it.
+  {
+    if (likely(node != NULL))
+      return this->shootAnim[barrel][seg] = new Animation3D(node);
+    else
+    {
+//       PRINTF(2)("Node not defined for the Creation of the 3D-animation of state %s\n", stateToChar(state));
+      return NULL;
+    }
+  }
+  else
+    return this->shootAnim[barrel][seg];
+}
+
 OrxGui::GLGuiWidget* Weapon::getEnergyWidget()
 {
-  if (this->energyWidget == NULL)
-  {
-    this->energyWidget = new OrxGui::GLGuiEnergyWidget();
-    this->energyWidget->setDisplayedName(this->getClassCName());
+  if ( this->energyWidget == NULL)
+  {
+    this->energyWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    //this->energyWidget->setDisplayedName(this->getClassCName());
     this->energyWidget->setSize2D( 20, 100);
     this->energyWidget->setMaximum(this->getEnergyMax());
@@ -352 +427 @@
   if (likely(this->isActive()))
   {
+    /** Disabled for releaseFire() from WM*/
     if (this->requestedAction != WA_NONE)
       return;
@@ -378 +454 @@
   {
     this->energy += energyToAdd;
+    this->updateWidgets();
     return 0.0;
   }
@@ -383 +460 @@
   {
     this->energy += maxAddEnergy;
+    this->updateWidgets();
     return energyToAdd - maxAddEnergy;
   }
+  
 }
 
@@ -431 +510 @@
     break;
     default:
-    PRINTF(2)("Action %s Not Implemented yet \n", Weapon::actionToChar(action));
+    PRINTF(5)("Action %s Not Implemented yet \n", Weapon::actionToChar(action));
     return false;
   }
@@ -507 +586 @@
 bool Weapon::fireW()
 {
+//   printf("fireW Weapon\n");
   //if (likely(this->currentState != WS_INACTIVE))
   if (this->minCharge <= this->energy)
@@ -513 +593 @@
     if (this->soundBuffers[WA_SHOOT].loaded())
       this->soundSource->play(this->soundBuffers[WA_SHOOT]);
-    this->updateWidgets();
     // fire
     this->energy -= this->minCharge;
@@ -519 +598 @@
     // setting up for the next state
     this->enterState(WS_SHOOTING);
+    this->updateWidgets();
   }
   else  // reload if we still have the charge
@@ -538 +618 @@
       unlikely(this->energy + this->ammoContainer->getStoredEnergy() < this->minCharge))
   {
-    this->requestAction(WA_DEACTIVATE);
+    //this->requestAction(WA_DEACTIVATE);
     this->execute();
     return false;

branches/playability.new/src/world_entities/weapons/weapon.h

@@ -126 +126 @@
 
     // EMISSION
+    /** keeping old functions*/
+    void setEmissionPoint(const Vector& point, int barrel);
     void setEmissionPoint(const Vector& point);
     /** @see void setEmissionPoint(const Vector& point); */
+    inline void setEmissionPoint(float x, float y, float z, int barrel) { this->setEmissionPoint(Vector(x, y, z), barrel); };
     inline void setEmissionPoint(float x, float y, float z) { this->setEmissionPoint(Vector(x, y, z)); };
     /** @returns the absolute Position of the EmissionPoint */
-    inline const Vector& getEmissionPoint() const { return this->emissionPoint.getAbsCoor(); };
+    inline const Vector& getEmissionPoint(int barrel) const { return this->emissionPoint[barrel]->getAbsCoor(); };
+    inline const Vector& getEmissionPoint() const { return this->emissionPoint[0]->getAbsCoor(); };
+
 
     inline void setDefaultTarget(PNode* defaultTarget) { this->defaultTarget = defaultTarget; };
@@ -158 +163 @@
 
     Animation3D* getAnimation(WeaponState state, PNode* node = NULL);
+    Animation3D* getAnimation(int barrel, int seg, PNode* node);
     Animation3D* copyAnimation(WeaponState from, WeaponState to);
 
@@ -169 +175 @@
     bool check() const;
     void debug() const;
+
+    inline int getBarrels() {return this->barrels; };
+    inline int getSegs() { return this->segs; };
+    inline void setBarrels(int barrels) { this->barrels = barrels; };
+    inline void setSegs(int segs) { this->segs = segs; };
+
+    inline Animation3D* getShootAnim(int barrel, int seg) { return this->shootAnim[barrel][seg]; };
+    inline void setShootAnim(int barrel, int seg, PNode* component) { this->shootAnim[barrel][seg] = this->getAnimation(barrel, seg, component); };
+
+    void init2();
+    void deconstr();
 
   protected:
@@ -184 +201 @@
     static WeaponState   charToState(const std::string& state);
     static const char*   stateToChar(WeaponState state);
+
+
 
   private:
@@ -214 +233 @@
     float                maxCharge;                        //!< The maximal energy to be loaded onto one projectile (this is only availible if chargeable is enabled)
 
-    OrxGui::GLGuiEnergyWidget* energyWidget;
+    OrxGui::GLGuiEnergyWidgetVertical* energyWidget;
 
     PNode*               defaultTarget;                    //!< A target for targeting Weapons.
@@ -230 +249 @@
     OrxSound::SoundBuffer  soundBuffers[WA_ACTION_COUNT];   //!< SoundBuffers for all actions @see WeaponAction.
 
-    PNode                  emissionPoint;                   //!< The point, where the projectiles are emitted. (this is coppled with the Weapon by default)
+    PNode**                emissionPoint;                   //!< The point, where the projectiles are emitted. (this is coppled with the Weapon by default)
 
     bool                   hideInactive;                    //!< Hides the Weapon if it is inactive
@@ -237 +256 @@
     ClassID                projectile;                      //!< the projectile used for this weapon (since they should be generated via macro and the FastFactory, only the ClassID must be known.)
     FastFactory*           projectileFactory;               //!< A factory, that produces and handles the projectiles.
+
+    int                    barrels;                         //!< # of barrels
+    int                    segs;                             //!< # of segments, one barrel has
+    Animation3D***         shootAnim;
+
   };
 

branches/playability.new/src/world_entities/weapons/weapon_manager.cc

@@ -103 +103 @@
 
   this->currentConfigID = 0;
-  this->slotCount = 2;
+  this->slotCount = WM_MAX_SLOTS;
   //this->weaponChange;
 
@@ -114 +114 @@
   this->crossHairSizeAnim->addKeyFrame(100, .05, ANIM_LINEAR);
   this->crossHairSizeAnim->addKeyFrame(50, .01, ANIM_LINEAR);
+
+  this->hideCrosshair();
+
+  this->bFire = false;
+}
+
+void WeaponManager::showCrosshair()
+{
+  this->crosshair->setVisibility( true);
+}
+
+void WeaponManager::hideCrosshair()
+{
+  this->crosshair->setVisibility( false);
+}
+
+void WeaponManager::setRotationSpeed(float speed)
+{
+  this->crosshair->setRotationSpeed(speed);
 }
 
@@ -300 +319 @@
     if (this->parentEntity->isA(Playable::staticClassID()))
       dynamic_cast<Playable*>(this->parentEntity)->weaponConfigChanged();
+    
     weapon->setDefaultTarget(this->crosshair);
   }
@@ -317 +337 @@
 
 /**
- * @brief does the same as the funtion inclreaseAmmunition, added four your convenience
+ * @brief does the same as the funtion increaseAmmunition, added four your convenience
  * @param weapon, the Weapon to read the ammo-info about.
  * @param ammo how much ammo to add.
  */
-float WeaponManager::inclreaseAmmunition(const Weapon* weapon, float ammo)
+float WeaponManager::increaseAmmunition(const Weapon* weapon, float ammo)
 {
   assert (weapon != NULL);
@@ -400 +420 @@
   this->currentConfigID = weaponConfig;
   PRINTF(4)("Changing weapon configuration: to %i\n", this->currentConfigID);
+
   for (int i = 0; i < WM_MAX_SLOTS; i++)
     this->currentSlotConfig[i].nextWeapon = this->configs[currentConfigID][i];
@@ -410 +431 @@
 void WeaponManager::fire()
 {
+//   printf("firing WM: ");
   Weapon* firingWeapon;
   for(int i = 0; i < this->slotCount; i++)
   {
+//     printf("%i ", i);
+          firingWeapon = this->currentSlotConfig[i].currentWeapon;
+      if( firingWeapon != NULL && firingWeapon->getCurrentState() == WS_SHOOTING) continue;
+          if( firingWeapon != NULL) firingWeapon->requestAction(WA_SHOOT);
+  }
+//   printf("\n");
+  /*
+        this->crosshair->setRotationSpeed(500);
+        this->crossHairSizeAnim->replay();
+  */
+}
+
+/**
+ * triggers fire of all weapons in the current weaponconfig
+ */
+void WeaponManager::releaseFire()
+{
+  Weapon* firingWeapon;
+  for(int i = 0; i < this->slotCount; i++)
+  {
     firingWeapon = this->currentSlotConfig[i].currentWeapon;
-    if( firingWeapon != NULL) firingWeapon->requestAction(WA_SHOOT);
-  }
+    if( firingWeapon != NULL) firingWeapon->requestAction(WA_NONE);
+  }
+
+  /*
   this->crosshair->setRotationSpeed(500);
   this->crossHairSizeAnim->replay();
-}
-
+  */
+}
 
 /**
@@ -429 +473 @@
   Weapon* tickWeapon;
 
+
   for(int i = 0; i < this->slotCount; i++)
   {
-/*
-    NICE LITTLE DEBUG FUNCTION
-       if (this->currentSlotConfig[i].currentWeapon != NULL || this->currentSlotConfig[i].nextWeapon != NULL)
+
+    //NICE LITTLE DEBUG FUNCTION
+    /*   if (this->currentSlotConfig[i].currentWeapon != NULL || this->currentSlotConfig[i].nextWeapon != NULL)
       printf("%p %p\n", this->currentSlotConfig[i].currentWeapon, this->currentSlotConfig[i].nextWeapon);*/
 
@@ -455 +500 @@
         }
       }
-
       // switching to next Weapon
       tickWeapon = this->currentSlotConfig[i].currentWeapon = this->currentSlotConfig[i].nextWeapon;
+      
       if (tickWeapon != NULL)
       {
-           //        if (this->parent != NULL)
-          tickWeapon->toList(this->parentEntity->getOMListNumber());
+        //if (this->parent != NULL)
+        tickWeapon->toList(this->parentEntity->getOMListNumber());
         tickWeapon->requestAction(WA_ACTIVATE);
         this->currentSlotConfig[i].position.activateNode();

branches/playability.new/src/world_entities/weapons/weapon_manager.h

@@ -60 +60 @@
     void loadWeapons(const TiXmlElement* root);
 
+    void showCrosshair();
+    void hideCrosshair();
+    void setRotationSpeed(float speed);
+
     void setSlotCount(unsigned int slotCount);
     unsigned int getSlotCount() const { return this->slotCount; };
@@ -91 +95 @@
 
     float increaseAmmunition(const ClassID& projectileType, float ammo);
-    float inclreaseAmmunition(const Weapon* weapon, float ammo);
+    float increaseAmmunition(const Weapon* weapon, float ammo);
 
     /** @returns a fixed target namely the Crosshair's 3D position */
@@ -99 +103 @@
     //! @TODO: implement this function (maybe also in Weapon itself)
     void releaseFire();
+    //inline void setFire() { this->bFire = true; };
 
     void tick(float dt);
@@ -127 +132 @@
 
     std::vector<CountPointer<AmmoContainer> > ammo;                   //!< Containers
+
+    bool                    bFire;
 };
 

branches/playability.new/src/world_entities/world_entity.cc

@@ -32 +32 @@
 
 #include "util/loading/load_param.h"
+#include "loading/load_param_xml.h"
+#include "util/loading/factory.h"
+
 #include "obb_tree.h"
 
 #include "elements/glgui_energywidget.h"
+#include "elements/glgui_energywidgetvertical.h"
 
 #include "state.h"
@@ -44 +48 @@
 #include "kill.h"
 #include "debug.h"
+
+#include "track/track.h"
 
 #include "projectiles/projectile.h"
@@ -86 +92 @@
   this->_bOnGround = false;
 
+  // Track of this entity
+  this->entityTrack = NULL;
+
   // registering default reactions:
   this->subscribeReaction(CoRe::CREngine::CR_OBJECT_DAMAGE, Projectile::staticClassID());
@@ -148 +157 @@
   .describe("the fileName of the object information file (optional)");
 
+  // Entity Attributes
   LoadParam(root, "maxHealth", this, WorldEntity, setHealthMax)
   .describe("The Maximum health that can be loaded onto this entity")
@@ -157 +167 @@
 
   LoadParam(root, "list", this, WorldEntity, toListS);
+
+
+  // Track
+  LoadParamXML(root, "Track", this, WorldEntity, addTrack)
+   .describe("creates and adds a track to this WorldEntity");
+}
+
+
+/**
+ * this functions adds a track to this workd entity. This can be usefull, if you like this WE to follow a some waypoints.
+ * here the track is created and further initializing left for the Track itself
+ */
+void WorldEntity::addTrack(const TiXmlElement* root)
+{
+  // The problem we have is most likely here. The track should be constructed WITH the XML-Code
+  this->entityTrack = new Track(root);
+  this->setParent(this->entityTrack->getTrackNode());
+  this->entityTrack->getTrackNode()->setParentMode(PNODE_ALL);
+  /*LOAD_PARAM_START_CYCLE(root, element);
+  {
+    PRINTF(4)("element is: %s\n", element->Value());
+    Factory::fabricate(element);
+  }
+  LOAD_PARAM_END_CYCLE(element);*/
+  
+
 }
 
@@ -613 +649 @@
 */
 void WorldEntity::tick(float time)
-{}
+{
+}
 
 
@@ -652 +689 @@
       this->models[0]->draw();
     }
+    
+    //if (this->entityTrack)
+       //this->entityTrack->drawGraph(0.02);
 
     //     if( this->aabbNode != NULL)
@@ -721 +761 @@
   if (this->healthWidget == NULL)
   {
-    this->healthWidget = new OrxGui::GLGuiEnergyWidget();
-    this->healthWidget->setDisplayedName(std::string(this->getClassName()) + " Energy:");
-    this->healthWidget->setSize2D(30,400);
-    this->healthWidget->setAbsCoor2D(10,100);
+    this->healthWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    //this->healthWidget->setDisplayedName("Health");
+    //this->healthWidget->setSize2D(100,20);
+    //this->healthWidget->setAbsCoor2D(100,200);
 
     this->updateHealthWidget();
@@ -773 +813 @@
 void WorldEntity::hit(float damage, WorldEntity* killer)
 {
+
   this->decreaseHealth(damage);
 

branches/playability.new/src/world_entities/world_entity.h

@@ -25 +25 @@
 // FORWARD DECLARATION
 namespace OrxSound { class SoundBuffer; class SoundSource; }
-namespace OrxGui { class GLGuiWidget; class GLGuiBar; class GLGuiEnergyWidget; };
+namespace OrxGui { class GLGuiWidget; class GLGuiBar; class GLGuiEnergyWidget; class GLGuiEnergyWidgetVertical; };
 namespace CoRe { class Collision; }
 
@@ -32 +32 @@
 class AABBTreeNode;
 class Model;
+class Track;
+class TiXmlElement;
 
 class ObjectInformationFile;
@@ -156 +158 @@
   void increaseHealthMax(float increaseHealth);
   OrxGui::GLGuiWidget* getHealthWidget();
-  bool hasHealthWidget() const { return this->healthWidget; };
+  bool hasHealthWidget() const { return this->healthWidget != NULL; };
 
   virtual void varChangeHandler( std::list<int> & id );
@@ -185 +187 @@
 private:
   void updateHealthWidget();
+  void addTrack(const TiXmlElement* root);
 
 
@@ -192 +195 @@
   float                   health;             //!< The Energy of this Entity, if the Entity has any energy at all.
   float                   healthMax;          //!< The Maximal energy this entity can take.
-  OrxGui::GLGuiEnergyWidget* healthWidget;    //!< The Slider (if wanted).
+  OrxGui::GLGuiEnergyWidgetVertical* healthWidget;    //!< The Slider (if wanted).
 
   std::vector<Model*>     models;             //!< The model that should be loaded for this entity.
@@ -235 +238 @@
 protected:
   Vector                  velocity;                        //!< speed of the entity
+  Track*                  entityTrack;                     //!< this is the track this entity follows (or NULL if none)
 
 };

@@ -10 +10 @@
 autom4te.cache
 aclocal.m4
+tags
+test.bmp
+config.sub
+config.guess
+OrxonoxPlayability.kdevses
+OrxonoxPlayability.kdevelop.pcs