Changeset 10698 – Orxonox

trunk/src/ai/swarm_gorel.cc

r10618	r10698
23	23
24	24	//calculate movement parameters..
25		float averageRadius;
	25	float averageRadius = 0;
26	26	for (it=members.begin(); it!= members.end(); it++ ){
27	27	averageRadius+=it->second->getNPCRadius();

trunk/src/defs/include_paths.am

r10376	r10698
31	31
32	32	AM_CXXFLAGS+=-I$(MAINSRCDIR)/../extern_libs
	33
	34	AM_LDFLAGS+=-L$(MAINSRCDIR)/../extern_libs

trunk/src/defs/orxonox_globals.h

-                      r10638
+                      r10698
 #define   CONFIG_NAME_DEBUG_LEVEL          "Debug-Level"
 // evenets
+// events
 #define   CONFIG_NAME_PLAYER_FORWARD       "Forward"
 #define   CONFIG_NAME_PLAYER_BACKWARD      "Backward"
 …
 #define   CONFIG_NAME_PLAYER_STRAFE_RIGHT  "StrafeRight"
 #define   CONFIG_NAME_PLAYER_JUMP          "Jump"
+#define   CONFIG_NAME_PLAYER_CROUCH        "Crouch"
 #define   CONFIG_NAME_PLAYER_ACTION        "Action"

trunk/src/lib/collision_detection/aabb_tree_node.cc

r10013	r10698
740	740
741	741	/* DRAW POLYGONS */
742		if( ~~drawMode & DRAW_BV_POLYGON \|\| drawMode & DRAW_ALL \|\| drawMode & DRAW_BV_BLENDED~~)
	742	if( (drawMode & DRAW_BV_POLYGON) \|\| (drawMode & DRAW_ALL) \|\| (drawMode & DRAW_BV_BLENDED))
743	743	{
744	744	if (top)

trunk/src/lib/event/key_mapper.cc

-                      r10638
+                      r10698
 int KeyMapper::PEV_JUMP              = EV_UNKNOWN;
 int KeyMapper::PEV_ACTION            = EV_UNKNOWN;
+int KeyMapper::PEV_CROUCH            = EV_UNKNOWN;
 int KeyMapper::PEV_FIRE1             = EV_UNKNOWN;
 …
       {&KeyMapper::PEV_JUMP,                 CONFIG_NAME_PLAYER_JUMP,            SDLK_SPACE},
       {&KeyMapper::PEV_ACTION,               CONFIG_NAME_PLAYER_ACTION,          SDLK_u},
+      {&KeyMapper::PEV_CROUCH,               CONFIG_NAME_PLAYER_CROUCH,          SDLK_LCTRL},
       {&KeyMapper::PEV_FIRE1,                CONFIG_NAME_PLAYER_FIRE,            EV_MOUSE_BUTTON_LEFT},

trunk/src/lib/event/key_mapper.h

r10638	r10698
58	58	static int PEV_JUMP; //!< jump
59	59	static int PEV_ACTION; //!< the action (or use) key
	60	static int PEV_CROUCH; //!< crouch
60	61
61	62	static int PEV_FIRE1; //!< fire button 1

trunk/src/lib/graphics/importer/bsp/bsp_manager.cc

-                      r10643
+                      r10698
   // erase alreadyVisible
   for(int i = 0; i < this->bspFile->numFaces; i++) this->alreadyVisible[i] = false;
   float tmp = 0;
+//   float tmp = 0;
   //this->opal.clear();
   //this->trasparent.clear();
 …
   this->viewDir=    State::getCamera()->getAbsDirX();
   float d = (cam.x*viewDir.x + cam.y*viewDir.y + cam.z * viewDir.z);
+//   float d = (cam.x*viewDir.x + cam.y*viewDir.y + cam.z * viewDir.z);
   BspTreeNode*  ActLeaf = this->getLeaf(this->bspFile->root, &ship);
 …
     for(int i = 0; i <  this->bspFile->numLeafs   ; ++i ) {
       leaf& camLeaf =  (this->bspFile->leaves)[ActLeaf->leafIndex] ;
+//       leaf& camLeaf =  (this->bspFile->leaves)[ActLeaf->leafIndex] ;
       leaf& curLeaf =  (this->bspFile->leaves)[i] ;
       int& cluster =  curLeaf.cluster;
 …
+float BspManager::checkCollisionRay(Vector StartPoint, Vector Direction, float length )
+{
+  Direction.normalize(); // Oder besser vor dem Fkt-Aufruf schon normalisieren
+  this->outputStartsOut = true;
+  this->outputAllSolid = false;
+  this->outputFraction = 1.0f;
+  this->inputStart =  StartPoint;
+  Vector End =   StartPoint + (Direction)*length;
+  this->inputEnd =   End;
+  this->checkCollisionRayN(this->root, 0.0f, 1.0f, &StartPoint, &(End) );
+  return (this->outputFraction * length);
+}
 /**

trunk/src/lib/graphics/importer/bsp/bsp_manager.h

r10618	r10698
77	77	void checkCollision(WorldEntity* worldEntity); /*!< WorldEntities use this function to check wheter they collided with the BspEntity.
78	78	If a collision has been detected, the collides-function of worldEntity will be called.*/
	79	float checkCollisionRay(Vector StartPoint, Vector Direction, float length ) ;
79	80
80	81	int sortTransparency; //!< sort transparent textures

trunk/src/lib/math/quaternion.h

-                      r10695
+                      r10698
     /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
   inline bool operator== (const Quaternion& q) const { return (unlikely(this->v==q.v&&this->w==q.w))?true:false; };
+    inline bool operator== (const Quaternion& q) const { return (unlikely(this->v==q.v&&this->w==q.w))?true:false; };
     /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
   inline bool operator!= (const Quaternion& q) const { return (unlikely(this->v!=q.v||this->w!=q.w))?true:false; };
+    inline bool operator!= (const Quaternion& q) const { return (unlikely(this->v!=q.v||this->w!=q.w))?true:false; };
     /** @param f: a real value @return a Quaternion containing the quotient */
     inline Quaternion operator/ (const float& f) const { return (unlikely(f==0.0)) ? Quaternion() : Quaternion(this->v/f, this->w/f); };
 …
     inline void slerpTo(const Quaternion& toQuat, float t);
+    void slerpTo(const Quaternion& toQuat, float t);
     static Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);

trunk/src/lib/math/vector.h

-                      r10376
+                      r10698
   /** @param index The index of the "array" @returns the x/y/z coordinate */
   inline float operator[] (float index) const {if( index == 0) return this->x; if( index == 1) return this->y; if( index == 2) return this->z; }
+  inline float operator[] (float index) const {if( index == 0) return this->x; if( index == 1) return this->y; if( index == 2) return this->z; else return this->x; }
   /** @param v The vector to add @returns the addition between two vectors (this + v) */
   inline Vector operator+ (const Vector& v) const { return Vector(x + v.x, y + v.y, z + v.z); };
 …
   /** @param v The vector to substract  @returns the substraction between two vectors (this - v) */
   inline Vector operator- (const sVec3D& v) const { return Vector(x - v[0], y - v[1], z - v[2]); }
+  /** @returns the substraction between (0, 0, 0) and this (null-this) */
+  inline Vector operator- () const { return Vector(-x, -y, -z); }
   /** @param v The vector to substract  @returns the substraction between two vectors (this -= v) */
   inline const Vector& operator-= (const Vector& v) { this->x -= v.x; this->y -= v.y; this->z -= v.z; return *this; };

trunk/src/story_entities/game_world.cc

r10618	r10698
695	695	AtmosphericEngine::getInstance()->draw();
696	696
	697	/* draw bounding boxes */
697	698	if( unlikely( this->showBV))
698	699	{

trunk/src/util/Makefile.am

-                      r10618
+                      r10698
                         animation/animation_player.cc \
+                        \
+                        track/track.cc
+                        track/track.cc \
+                        track/action_box.cc
 noinst_HEADERS =        \
 …
                         animation/t_animation.h \
+                        \
+                        track/track.h
+                        track/track.h \
+                        track/action_box.h

trunk/src/util/hud.cc

-                      r10516
+                      r10698
    ### File Specific:
    main-programmer: Benjamin Grauer
    co-programmer: ...
+   co-programmer: Benjamin Knecht
 */
 …
   this->energyWidget = NULL;
   this->shieldWidget = NULL;
   this->armorWidget = NULL;
   //this->leftRect = NULL;
   //this->rightRect = NULL;
+  this->healthWidget = NULL;
+  this->leftRect = NULL;
+  this->rightRect = NULL;
   this->resX = 1;
   this->resY = 1;
 …
   this->rightRect = new OrxGui::GLGuiImage();
   this->leftRect = new OrxGui::GLGuiImage();
+  this->topRect = new OrxGui::GLGuiImage();
+  this->bottomRect = new OrxGui::GLGuiImage();
+  this->middleRect = new OrxGui::GLGuiImage();
   this->inputLine = new OrxGui::GLGuiInputLine();
   this->inputLine->setParent2D(this);
+  //this->inputLine->setParent2D(this);
   this->notifier = new OrxGui::GLGuiNotifier();
+  this->notifier->setParent2D(this);
+  notifier->setAbsCoor2D(100,100);
+  this->notifier->setParent2D(this->bottomRect);
+  notifier->setRelCoor2D(5,5);
+  this->barSocket = new OrxGui::GLGuiImage();
+  this->barSocket->setParent2D(this->bottomRect);
   this->_radar = new OrxGui::GLGuiRadar();
 …
   delete this->_radar;
+  delete this->barSocket;
   delete this->rightRect;
   delete this->leftRect;
+  delete this->topRect;
+  delete this->bottomRect;
+  delete this->middleRect;
   //if (this->shipValuesBox != NULL)
     //delete this->shipValuesBox;
 …
+  }
   this->updateResolution();
+}
 void Hud::setShiledWidget(OrxGui::GLGuiWidget* widget)
+  this->updateResolution();
+}
+void Hud::setShieldWidget(OrxGui::GLGuiWidget* widget)
+{
   /*
 …
+}
+void Hud::setArmorWidget(OrxGui::GLGuiWidget* widget)
+{
+  /*
+  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);
+    dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->armorWidget)->setDisplayedImage("textures/gui/gui_health_icon.png");
+    this->armorWidget->show();
+    /*    this->armorWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
+        this->armorWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
+void Hud::setHealthWidget(OrxGui::GLGuiWidget* widget)
+{
+        if( this->playmode == FirstPerson )
+        {
+                this->healthWidget = new OrxGui::GLGuiBar();
+                dynamic_cast<OrxGui::GLGuiBar*> (this->healthWidget)->setMaximum(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (widget)->getBarWidget()->maximum());
+                dynamic_cast<OrxGui::GLGuiBar*> (this->healthWidget)->setValue(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (widget)->getBarWidget()->value());
+                this->healthWidget->setParent2D(this->barSocket);
+        }
+        else
+        {
+          /*
+          if (this->shipValuesBox == NULL)
+            this->createShipValuesBox();
+          */
+        // decopple old widget
+          if (this->healthWidget != NULL)
+          {
+            this->healthWidget->hide();
+          }
+          this->healthWidget = widget;
+          if (this->healthWidget != NULL)
+          {
+            //this->healthWidget->shiftDir2D(270);
+            //this->shipValuesBox->pack(this->healthWidget);
+            //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->healthWidget)->setStandardSettings();
+            this->healthWidget->setParent2D(this->leftRect);
+            //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->healthWidget)->setDisplayedImage("textures/gui/gui_health_icon.png");
+            this->healthWidget->show();
+            /*    this->healthWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
+                this->healthWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
+          }
+        }
+  this->updateResolution();
+}
+void Hud::setImplantWidget(OrxGui::GLGuiWidget* widget)
+{
+  //if (this->shipValuesBox == NULL)
+    //this->createShipValuesBox();
+  // decopple old widget
+  if (this->implantWidget != NULL)
+  {
+    this->implantWidget->hide();
+  }
+  this->implantWidget = widget;
+  if (this->implantWidget != 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->implantWidget->setParent2D(this->leftRect);
+    dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->implantWidget)->setDisplayedImage("textures/gui/gui_electronics_icon.png");
+    this->implantWidget->show();
+    /*    this->energyWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
+        this->energyWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
+  }
 …
   this->setSize2D(.2 * this->resX, this->resY);
+  this->notifier->setAbsCoor2D(0.7 * this->resX, 0.3 * this->resY);
+  this->notifier->setWidgetSize(0.25 * this->resX, 0.6 * this->resY);
+  if( this->playmode != FirstPerson )
+  {
+          this->notifier->setAbsCoor2D(0.7 * this->resX, 0.3 * this->resY);
+          this->notifier->setWidgetSize(0.25 * this->resX, 0.6 * this->resY);
+  }
   int overlayWidth = 0;
 …
     overlayWidth = this->resX * (overlayPercentage)/(200);
   else
     overlayWidth = this->resX * 0.1;
+    overlayWidth = this->resX / 10; // fixed warning!
   //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->playmode != FirstPerson )
+  {
+          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));
+  }
+  else
+  {
+          this->bottomRect->setParent2D(this);
+          this->bottomRect->setWidgetSize(float(this->resX), float(overlayWidth));
+          this->bottomRect->setAbsCoor2D(0, this->resY - overlayWidth);
+          this->topRect->setParent2D(this);
+          this->topRect->setWidgetSize(float(this->resX), float(overlayWidth));
+          this->topRect->setAbsCoor2D(0, 0);
+          this->middleRect->setParent2D(this);
+          this->middleRect->setWidgetSize(float(this->resY)/2, float(this->resY)/2);
+          this->middleRect->setAbsCoor2D(float(this->resX - this->resY/2)/2, float(this->resY)/4);
+  }
   if (this->overlayActive == true)
 …
+  {
     PRINTF(4)("UPDATING RADAR\n");
+    this->_radar->setParent2D(this->leftRect);
+    if( this->playmode != FirstPerson )
+        this->_radar->setParent2D(this->leftRect);
+    else
+        this->_radar->setParent2D(this->topRect);
     if (radarCenterNode == NULL)
       this->_radar->setCenterNode(State::getPlayer()->getPlayable());
 …
     int statWidgetsNumber = 0;
     float expectedArmorSizeX = 0;
     float expectedArmorSizeY = 0;
+    float expectedHealthSizeX = 0;
+    float expectedHealthSizeY = 0;
     float newSizeY = 0; float newSizeX = 0;
     float moduloWidth = 0;
+    if (this->armorWidget != NULL)
+    {
+      expectedArmorSizeX = 150;
+      expectedArmorSizeY = 50;
+      statWidgetsNumber++;
+    }
+        if( this->playmode != FirstPerson )
+        {
+            if (this->healthWidget != NULL)
+            {
+              expectedHealthSizeX = 150;
+              expectedHealthSizeY = 50;
+              statWidgetsNumber++;
+            }
+            if (this->shieldWidget != NULL)
+              statWidgetsNumber++;
+            if (this->energyWidget != NULL)
+              statWidgetsNumber++;
+            if (expectedHealthSizeY * statWidgetsNumber > overlayWidth)
+            {
+              newSizeY = overlayWidth / float(statWidgetsNumber);
+              newSizeX = expectedHealthSizeX;
+              PRINTF(0)("Statwidgets resized\n");
+            }
+            else
+            {
+              newSizeY = expectedHealthSizeY;
+              newSizeX = expectedHealthSizeX;
+              moduloWidth = int(overlayWidth) % int(expectedHealthSizeY * statWidgetsNumber);
+            }
+            float posY = overlayWidth + newSizeX;
+            if (this->healthWidget != NULL)
+            {
+              this->healthWidget->setSize2D(newSizeX, newSizeY);
+              this->healthWidget->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);
+            }
+        }
+        else
+        {
+                this->barSocket->setParent2D(this->bottomRect);
+                this->barSocket->setWidgetSize( float(overlayWidth), float(overlayWidth));
+                this->barSocket->setRelCoor2D(0,this->resX - float(overlayWidth));
+                this->healthWidget->setRelCoor2D(10,-20);
+        }
+    /*
+    if (this->healthWidget != NULL)
+      this->healthWidget->setRelCoor2D(100,0.2*this->resY + this->healthWidget->getSizeX2D());
     if (this->shieldWidget != NULL)
+      statWidgetsNumber++;
+      this->shieldWidget->setRelCoor2D(60,0.2*this->resY + this->healthWidget->getSizeX2D());
     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->energyWidget->setRelCoor2D(20,0.2*this->resY + this->healthWidget->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);
+    //this->shieldWidget->setRelCoor2D(0.1*this->resX + this->healthWidget->getSizeX2D(),0);
+    //this->energyWidget->setRelCoor2D(0.1*this->resX + this->healthWidget->getSizeX2D() + this->shieldWidget->getSizeX2D(),0);
+  }

trunk/src/util/hud.h

-                      r10368
+                      r10698
 public:
+  typedef enum {
+    Vertical         =  1,       //!< Vertical (seen from left or right/move in x-z)
+    Horizontal       =  2,       //!< Horizontal (seet from the top/move in x-y)
+    FromBehind       =  4,       //!< Seen from behind (move in z-y)
+    Full3D           =  8,       //!< Full featured 3D-mode. (move in all directions x-y-z)
+    FirstPerson      = 16,
+    PlaymodeCount    =  5,
+  } Playmode;
   Hud();
   virtual ~Hud();
 …
   void notifyUser(const std::string& message);
+  inline void setMode(Hud::Playmode playmode) {this->playmode = playmode;};
+  inline Hud::Playmode getMode() {return this->playmode;};
   void setBackGround();
   void setEnergyWidget(OrxGui::GLGuiWidget* widget);
+  void setShiledWidget(OrxGui::GLGuiWidget* widget);
+  void setArmorWidget(OrxGui::GLGuiWidget* widget);
+  void setShieldWidget(OrxGui::GLGuiWidget* widget);
+  void setHealthWidget(OrxGui::GLGuiWidget* widget);
+  void setImplantWidget(OrxGui::GLGuiWidget* widget);
   inline OrxGui::GLGuiWidget* getEnergyWidget() {return this->energyWidget;};
   inline OrxGui::GLGuiWidget* getShieldWidget() {return this->shieldWidget;};
+  inline OrxGui::GLGuiWidget* getArmorWidget() {return this->armorWidget;};
+  inline OrxGui::GLGuiWidget* getHealthWidget() {return this->healthWidget;};
+  inline OrxGui::GLGuiWidget* getImplantWidget() {return this->implantWidget;};
   void setWeaponManager(WeaponManager* weaponMan, WeaponManager* weaponManSec = NULL);
 …
   unsigned int             resX;
   unsigned int             resY;
+  Hud::Playmode                         playmode;
   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;
   OrxGui::GLGuiWidget*     shieldWidget;
+  OrxGui::GLGuiWidget*     armorWidget;
+  OrxGui::GLGuiWidget*     healthWidget;
+  OrxGui::GLGuiWidget*     implantWidget;
   OrxGui::GLGuiNotifier*   notifier;
 …
   OrxGui::GLGuiWidget*     rightRect;
   OrxGui::GLGuiWidget*     leftRect;
+  OrxGui::GLGuiWidget*          topRect;
+  OrxGui::GLGuiWidget*          bottomRect;
+  OrxGui::GLGuiWidget*          middleRect;
+  OrxGui::GLGuiWidget*          barSocket;
   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;

trunk/src/util/state.cc

r10643	r10698
56	56	int State::menuID = -1;
57	57
	58	ActionBox* State::actionBox = NULL;
58	59
59	60	/**

trunk/src/util/state.h

-                      r10643
+                      r10698
 class CameraMan;
 class ScriptManager;
+class ActionBox;
 …
   /** @returns the scroller-travelnode (center of the screen) */
   static PNode* getTravelNode() { return State::travelNode; }
+  /** sets the action box (this is where the fighting takes place) */
+  static void setActionBox( ActionBox* ab ){ State::actionBox = ab; }
+  /** @returns the action box (this is where the fighting takes place) */
+  static ActionBox* getActionBox(){ return State::actionBox; }
 …
   static Player*                player;             //!< A reference to the Player
   static PNode*                 travelNode;         //!< A reference to the scroller-travelnode
+  static ActionBox*             actionBox;          //!< A reference to the action box
   static SkyBox*                skyBox;            //!< The SkyBox used in the current world.

trunk/src/util/track/track.cc

-                      r10618
+                      r10698
 #include "debug.h"
+#include "action_box.h"
 ObjectListDefinition(Track);
 …
   this->duration = 20;
   this->endTime = 20;
+  this->width = 10;
+  this->width = 24;
+  this->height = 18;
+  this->depth = 200;
+  this->stretch = 4;
   this->curve = new BezierCurve();
   this->trackNode = new PNode(PNode::getNullParent(), PNODE_ALL);
 …
   this->localTime = 0;
   this->pause = false;
+  this->actionBox = NULL;
+}
 …
+     }
      LOAD_PARAM_END_CYCLE(element);
+     LoadParam(root, "ActionBox", this, Track, addActionBox );
+}
 …
+       {
            Vector tmp = this->calcPos();
            Vector dV = tmp - this->trackNode->getAbsCoor();
            float dx = speed * dt;
            float ratio = dx / dV.len();
            if( dt > 0.0f)
+           {
 …
+           }
            tmp = this->calcPos();
            Vector v(0.0, 1.0, 0.0);
            Quaternion quat = Quaternion(this->calcDir(), v);
            Quaternion q(-PI/2, v);
            quat = quat * q;
            // move trackNode of the track
            this->trackNode->shiftCoor(tmp - this->trackNode->getAbsCoor());
 …
     glPopMatrix();
+}
+/**
+ * creates new action box and assignes it to this track
+ * @param width_2 width/2 of near end
+ * @param height_2 height/2 of near end
+ * @param depth depth
+ * @param stretch far end will be stretched with this factor
+ */
+void Track::addActionBox( float width_2, float height_2, float depth, float stretch )
+{
+  actionBox = new ActionBox( this, width_2, height_2, depth, stretch );
+}

trunk/src/util/track/track.h

-                      r10498
+                      r10698
 class PNode;
 class TiXmlElement;
+class ActionBox;
 class Track : public BaseObject
 …
    float                 duration;             //!< The time used to cross this Track (curve).
    float                 endTime;              //!< The time at which this Track ends.
+   float                 width;                //!< Th width of the Path. This tells the Player(s), how far he(they) can go to the left/right.
+   float                 width;                //!< The width of the action box, next to the player.
+   float                 height;               //!< The Height of the action box, next to the player
+   float                 depth;                //!< Depth of the action box
+   float                 stretch;              //!< multiplyer between w/h at player and w/h at far end of the action box
    int                   nodeCount;            //!< The count of points this Track has.
    Curve*                curve;                //!< The Curve of this Track
+   ActionBox*            getActionBox(){ return this->actionBox; }
  private:
    void init();
  private:
    CurveType            curveType;              //!< The CurveType the entire TrackSystem will have.
 …
    int                  mode;                   //!< Defines the behaviour of the Track.
    bool                 pause;                  //!< Defines if the track runs (false) or not (true)
+   ActionBox*           actionBox;
+   void addActionBox( float width_2, float height_2, float depth, float stretch );
 };

trunk/src/world_entities/WorldEntities.am

-                      r10695
+                      r10698
 ## THE SUBCLASSES. THESE MUST BE DYNAMICALLY LINKED OR COMPILED IN DIRECTLY
 WorldEntities_SOURCES_ = \
 …
                 world_entities/npcs/repair_station.cc \
                 world_entities/npcs/attractor_mine.cc \
+                world_entities/npcs/actionbox_enemy.cc \
+                world_entities/npcs/adm_turret.cc \
+                \
+                \
 …
                 world_entities/weapons/spike_thrower.cc \
                 world_entities/weapons/acid_launcher.cc \
+                world_entities/weapons/rf_cannon.cc \
+                world_entities/weapons/disruptor.cc \
+                world_entities/weapons/nadion_laser.cc \
+                world_entities/weapons/bsp_weapon.cc \
+                \
                 world_entities/projectiles/lbolt.cc \
 …
                 world_entities/projectiles/spike.cc \
                 world_entities/projectiles/acid_splash.cc \
+                world_entities/projectiles/plasma_pulse.cc \
+                world_entities/projectiles/nadion_blast.cc \
+                \
                 world_entities/projectiles/projectile_weapon.cc \
 …
                 npcs/repair_station.h \
                 npcs/attractor_mine.h \
+                npcs/actionbox_enemy.h \
+                npcs/adm_turret.h \
+                \
                 environments/environment.h \
 …
                 weapons/spike_thrower.h \
                 weapons/acid_launcher.h \
+                weapons/rf_cannon.h \
+                weapons/disruptor.h \
+                weapons/nadion_laser.h \
+                weapons/bsp_weapon.h \
+                \
                 projectiles/lbolt.h \
 …
                 projectiles/spike_ball.h \
                 projectiles/acid_splash.h \
+                projectiles/plasma_pulse.h \
+                projectiles/nadion_blast.h \
+                \
                 projectiles/projectile_weapon.h \

trunk/src/world_entities/creatures/fps_player.cc

-                      r10618
+                      r10698
 #include "interactive_model.h"
 #include "state.h"
+#include "tools/camera.h"
+#include "player.h"
 #include "src/lib/util/loading/factory.h"
 …
                             ->addMethod("getAbsCoorY", Executor0ret<PNode, lua_State*, float>(&PNode::getAbsCoorY))
                             ->addMethod("getAbsCoorZ", Executor0ret<PNode, lua_State*, float>(&PNode::getAbsCoorZ))
+                            ->addMethod("displayHUDText", Executor1<FPSPlayer, lua_State*, const std::string&>(&FPSPlayer::displayHUDText))
                        );
 …
   this->bPosBut = false;
   this->bFire = false;
+  this->bFire2 = false;
+  this->changeZoom = true;
+  this->inZoomMode = false;
+  this->changingZoom = false;
   this->xMouse = 0.0f;
 …
   registerEvent(KeyMapper::PEV_RIGHT);
   registerEvent(KeyMapper::PEV_FIRE1);
+  registerEvent(KeyMapper::PEV_FIRE2);
   registerEvent(KeyMapper::PEV_JUMP);
+  registerEvent(KeyMapper::PEV_CROUCH);
   registerEvent(EV_MOUSE_MOTION);
 …
   this->getWeaponManager().getFixedTarget()->setParent(&this->cameraNode);
+  this->getWeaponManager().getFixedTarget()->setRelCoor(1000,0,0);
+  this->getWeaponManager().getFixedTarget()->setParentMode(PNODE_ALL);
+  this->getWeaponManager().getFixedTarget()->setRelCoor(10,0,0);
 …
+}
+/**
+ * was probabably designed for setting direction of FPSPlayer
+ * but hey, this connot work like this, can it?
+ */
 void FPSPlayer::setPlayDirection(const Quaternion& quat, float speed)
+{
 …
+}
+/**
+ * Resets FPSPlayer stats and freezes its moving directions
+ *
+ */
 void FPSPlayer::reset()
+{
 …
   this->xMouse = 0.0f;
   this->yMouse = 0.0f;
+  this->inZoomMode = false;
   this->setHealth(80);
+}
+/**
+ * Defines what happens to camera and other important elements when changing
+ * into FPS-view
+ */
 void FPSPlayer::enter()
+{
 …
   State::getCameraNode()->setParentSoft(&this->cameraNode);
   State::getCameraTargetNode()->setParentSoft(&this->cameraNode);
+  this->getWeaponManager().getFixedTarget()->setParent(State::getCameraTargetNode());
+  this->getWeaponManager().getFixedTarget()->setRelCoor(0,0,0);
+  State::getCamera()->setViewMode(Camera::ViewFPS);
+  this->getWeaponManager().getFixedTarget()->setParent(&this->cameraNode);
+  //this->getWeaponManager().getFixedTarget()->setParentMode(PNODE_ALL);
+  //this->getWeaponManager().getFixedTarget()->setRelCoor(100,0,0);
   if ( !State::isOnline() )
 …
+}
+/**
+ * Defines what happens if active player leaves FPSPlayer
+ * (basicly hides crosshair and frees camera)
+ */
 void FPSPlayer::leave()
+{
 …
 void FPSPlayer::tick (float time)
+{
+     // Second init-step
   if ( !this->initWeapon )
+  {
 …
     this->getWeaponManager().getParentNode()->setParentMode(PNODE_ROTATE_AND_MOVE);
     this->getWeaponManager().getFixedTarget()->setParent(&this->cameraNode);
+    this->getWeaponManager().getFixedTarget()->setParentMode(PNODE_ROTATE_AND_MOVE);
+    //this->getWeaponManager().getFixedTarget()->setParentMode(PNODE_ROTATE_AND_MOVE);
+    State::getCamera()->setViewMode(Camera::ViewFPS);
 …
+    }
+    AABB* box = this->getModelAABB();
+    if( box != NULL)
+    {
+  }
+  // end of second init-step
+  // This box represents the dimension of the used model
+  AABB* box = this->getModelAABB();
+  if( box != NULL)
+  {
       float f = 1.0;
+      if( this->bCrouch )
+          f = 0.3*f;
       this->cameraNode.setRelCoor(0, box->halfLength[1] * f, 0);
+//       this->cameraNode.setRelCoor(10, box->halfLength[1] * f, 0);
+      float v = 0.1f;
+      this->getWeaponManager().setSlotPosition(0, Vector(-8.0, box->halfLength[1] * v, 1.1));
+      this->getWeaponManager().setSlotPosition(1, Vector(5.0, box->halfLength[1] * v, 0.0));
+    }
+  }
+//      this->cameraNode.setRelCoor(10, box->halfLength[1] * f, 0);
+     float v = 0.1f;
+     this->getWeaponManager().setSlotPosition(0, Vector(-8.0, box->halfLength[1] * v, 1.1));
+     this->getWeaponManager().setSlotPosition(1, Vector(5.0, box->halfLength[1] * v, 0.0));
+  }
+  /*
+  if( this->bFire2 )
+  {
+      // to change Zoom on click
+      if( this->changeZoom )
+      {
+          this->changeZoom = false;
+          if( this->inZoomMode )
+          {
+              State::getCamera()->setViewMode(Camera::ViewFPS);
+              this->inZoomMode = false;
+          }
+          else
+          {
+              State::getCamera()->setViewMode(Camera::ViewFPSZoom);
+              this->inZoomMode = true;
+          }
+      }
+  }
+  else
+  {
+      this->changeZoom = true;
+  }*/
+  if( this->bFire2 )
+  {
+      if( this->changeZoom )
+      {
+          if( !this->inZoomMode || this->changingZoom )
+          {
+              this->inZoomMode = true;
+              this->changingZoom = true;
+              float fovy = State::getCamera()->getFovy();
+              if( fovy > 30 )
+                  State::getCamera()->setFovy( fovy - 10*time );
+          }
+          else
+          {
+                State::getCamera()->setViewMode(Camera::ViewFPS);
+                this->inZoomMode = false;
+                this->changeZoom = false;
+          }
+      }
+  }
+  else
+  {
+      this->changeZoom = true;
+      this->changingZoom = false;
+  }
   this->getWeaponManager().tick(time);
 …
     xMouse *= time ;
     yMouse *= time ;
+    heading -= xMouse/5.;
+    attitude-= yMouse/5.;
+    float amount;
+    if( this->inZoomMode )
+        amount = 2.;
+    else
+        amount = 5.;
+    heading -= xMouse/amount;
+    attitude-= yMouse/amount;
 …
     }*/
+  velocity *= 100;
+  int speed;
+  if( this->bCrouch )
+      speed = 50;
+  else
+      speed = 100;
+  velocity *= speed;
   if( this->getModel( 0) != NULL && this->getModel(0)->isA(InteractiveModel::staticClassID()))
+  {
+    if( this->bJump)
+    {
+      if( this->jumpAcceleration < 1.0f)
+      if( this->bJump)
+      {
+        this->jumpAcceleration = 300.0f;
+        if( ((InteractiveModel*)this->getModel(0))->getAnimation() != JUMP)
+          ((InteractiveModel*)this->getModel(0))->setAnimation(JUMP);
+      }
+    }
+    else if(velocity.len() != 0.0f)
+    {
+      if( ((InteractiveModel*)this->getModel(0))->getAnimation() != RUN)
+        ((InteractiveModel*)this->getModel(0))->setAnimation(RUN);
+    }
+    else
+    {
+      if( ((InteractiveModel*)this->getModel(0))->getAnimation() != STAND)
+        ((InteractiveModel*)this->getModel(0))->setAnimation(STAND);
+    }
+          if( this->jumpAcceleration < 1.0f)
+          {
+              this->jumpAcceleration = 300.0f;
+              if( ((InteractiveModel*)this->getModel(0))->getAnimation() != JUMP)
+                  ((InteractiveModel*)this->getModel(0))->setAnimation(JUMP);
+          }
+       }
+       else if(velocity.len() != 0.0f)
+       {
+            if( this->bCrouch )
+            {
+                if( ((InteractiveModel*)this->getModel(0))->getAnimation() != CROUCH_WALK)
+                    ((InteractiveModel*)this->getModel(0))->setAnimation(CROUCH_WALK);
+            }
+            else
+            {
+                if( ((InteractiveModel*)this->getModel(0))->getAnimation() != RUN)
+                    ((InteractiveModel*)this->getModel(0))->setAnimation(RUN);
+            }
+       }
+       else
+       {
+           if( this->bCrouch )
+           {
+               if( ((InteractiveModel*)this->getModel(0))->getAnimation() != CROUCH_STAND)
+                   ((InteractiveModel*)this->getModel(0))->setAnimation(CROUCH_STAND);
+           }
+           else
+           {
+               if( ((InteractiveModel*)this->getModel(0))->getAnimation() != STAND)
+                   ((InteractiveModel*)this->getModel(0))->setAnimation(STAND);
+           }
+       }
+       if( this->bFire )
+       {
+           if( this->bCrouch )
+           {
+               if( ((InteractiveModel*)this->getModel(0))->getAnimation() != CROUCH_ATTACK)
+                   ((InteractiveModel*)this->getModel(0))->setAnimation(CROUCH_ATTACK);
+           }
+           else
+           {
+               if( ((InteractiveModel*)this->getModel(0))->getAnimation() != ATTACK)
+                   ((InteractiveModel*)this->getModel(0))->setAnimation(ATTACK);
+           }
+       }
+  }
 …
     this->fallVelocity = 0.0f;
+  }
+  if((velocity *time).len() < 10.0f) this->shiftCoor( velocity*time );
+  else{
+  if((velocity * time).len() < 10.0f) this->shiftCoor( velocity*time );
+  else
+  {
          velocity.normalize();
          velocity *= 10.0f;
          this->shiftCoor( velocity );
+       }
+  }
 …
   if( this->aimingSystem != NULL)
     this->aimingSystem->flushList();
+}
 …
 /**
  * process
+ * checks events
  */
 void FPSPlayer::process(const Event &event)
 …
   else if( event.type == KeyMapper::PEV_BACKWARD)
     this->bBackward = event.bPressed; //this->shiftCoor(0,-.1,0);
+  else if( event.type == KeyMapper::PEV_JUMP)
+    this->bJump = event.bPressed;
+  else if( event.type == KeyMapper::PEV_FIRE1)
+    this->bFire = event.bPressed;
+  else if( event.type == KeyMapper::PEV_FIRE2)
+    this->bFire2 = event.bPressed;
+  else if( event.type == KeyMapper::PEV_CROUCH)
+    this->bCrouch = event.bPressed;
   else if( event.type == EV_MOUSE_MOTION)
+  {
 …
     this->yMouse += event.yRel;
+  }
+  else if( event.type == KeyMapper::PEV_JUMP)
+  {
+    this->bJump = event.bPressed;
+  }
+  else if( event.type == KeyMapper::PEV_FIRE1)
+  {
+    this->bFire = event.bPressed;
+  }
+}
+}
+/**
+ * respawns FPSplayer
+ */
 void FPSPlayer::respawn( )
+{
 …
+}
+/**
+ * Kills the FPSplayer defining its killer
+ */
 void FPSPlayer::destroy( WorldEntity* killer )
+{
 …
+}
+void FPSPlayer::displayHUDText( const std::string& message )
+{
+        State::getPlayer()->hud().notifyUser(message);
+}

trunk/src/world_entities/creatures/fps_player.h

-                      r10566
+                      r10698
     virtual void tick(float time);
     virtual void draw() const;
+    void displayHUDText( const std::string& message );
 …
     void init();
+    bool                  bLeft;
+    bool                  bRight;
+    bool                  bForward;
+    bool                  bBackward;
+    bool                  bJump;              //!< jumping
+    bool                  bPosBut;             //!< position button
+    bool                  bFire;              //!< fire button
+    bool                  bLeft;             //!< strafe left
+    bool                  bRight;            //!< strafe right
+    bool                  bForward;          //!< walk forward
+    bool                  bBackward;         //!< walk backward
+    bool                  bJump;             //!< jumping
+    bool                  bPosBut;           //!< position button
+    bool                  bFire;             //!< fire button
+    bool                  bFire2;            //!< alternate fire button
+    bool                  bCrouch;           //!< crouch button
     float                 xMouse;             //!< mouse moved in x-Direction
     float                 yMouse;             //!< mouse moved in y-Direction
+    float                 xMouse;            //!< mouse moved in x-Direction
+    float                 yMouse;            //!< mouse moved in y-Direction
     float                 heading;
     float                 attitude;
+    float                 heading;           //!< the direction where the player heads to
+    float                 attitude;          //!< defines the camera angle to the x-z-plane
     PNode                 cameraNode;
+    PNode                 cameraNode;        //!< the "eyes" of the player (or call it head if you want)
     float                 fallVelocity;        //!< velocity for falling down
     float                 jumpAcceleration;    //!< the jump acceleration
+    float                 fallVelocity;      //!< velocity for falling down
+    float                 jumpAcceleration;  //!< the jump acceleration
     bool                  initWeapon;
+    bool                  changeZoom;        //!< zoom sight of player
+    bool                  inZoomMode;        //!< zoomsight
+    bool                  changingZoom;
     AimingSystem*         aimingSystem;        //!< aiming system of the player
+    AimingSystem*         aimingSystem;      //!< aiming system of the player
+    float                 damageTicker;        //!< ticker for dealing damage
+    float                 damageTicker;      //!< ticker for dealing damage
 };

trunk/src/world_entities/effects/billboard.cc

-                      r10618
+                      r10698
 ### File Specific:
    main-programmer: David Hasenfratz
+   co-programmer: Nicolas Schlumberger
 */
 …
   this->texColor = NULL;
+  this->pulseMagnitude = .5;
+  this->bPulse = false;
+  this->angularSpeed = M_2_PI; //360;
+  this->angle = 0;
+  this->setUpdateFunction((*sinf));
+}
 …
 void Billboard::tick(float dt)
+{
+  this->angle += dt * this->angularSpeed;
+  if (this->angle > M_2_PI)
+    this->angle -= M_2_PI;
+//   curMagnitude = updatePulse(this->angle);
+}
 …
   v.normalize();
+  v *= sizeX;
+  h *= sizeY;
+  float tmp = 1;
+  if (this->bPulse)
+    tmp += this->pulseMagnitude * sinf(this->angle); //updatePulse(this->angle);
+  v *= sizeX * tmp;
+  h *= sizeY * tmp;
 //v += this->getAbsCoor();

trunk/src/world_entities/effects/billboard.h

-                      r10433
+                      r10698
     void colorTexture(const Color col);
+    //!< Pulsing Capability, changes size of the grid
+    inline void togglePluse () {this->bPulse = !bPulse; };
+    inline void setPulse () { this->bPulse = true; };
+    inline void setPulse ( bool state ) {this->bPulse = state; };
+    inline float getPulse () { return this->bPulse; };
+    inline void setPulseMagnitude(float mag) {this->pulseMagnitude = mag; };
     virtual void tick(float dt);
     virtual void draw() const;
+    inline void setUpdateFunction(float (*updateFct)(float value)) { if( updateFct)  this->updatePulse = updateFct;};
   private:
+    float (*updatePulse)(float value);
     Material*        material;
     Color*           texColor;
     float sizeX;
     float sizeY;
+    bool bPulse;
+    float pulseMagnitude;
+    float curMagnitude;
+    float angle;
+    float angularSpeed;
 };

trunk/src/world_entities/effects/blink.cc

r10618	r10698
67	67	this->bBoard->setTexture("textures/light/blink.png");
68	68
69		/// Standard values
	69	//!< Standard values
70	70	this->bBoard->setAbsCoor(0, 0, 0);
71	71	// default position if not set in xml

trunk/src/world_entities/effects/explosion.h

-                      r10695
+                      r10698
     virtual void tick (float time);
+  private:
+    void setLifeTime( float lifeTime ){ this->lifeTime = lifeTime; }
+  protected:
     static FastFactory*        fastFactory;

trunk/src/world_entities/effects/wobblegrid.cc

r10618	r10698
10	10
11	11	### File Specific:
12		main-programmer: ~~David Hasenfratz~~
	12	main-programmer: Marc Schärer
13	13	*/
14	14

trunk/src/world_entities/npcs/adm_turret.cc

-                      r10694
+                      r10698
         this->isCeil = false;
         this->playerVisible = false;
+        this->weapon = NULL;
 …
+{
   WorldEntity::tick(dt);
   this->weapon->fire(false);
+  if (this->weapon) this->weapon->fire(false);
   this->updatePlayerVisible();
 …
     float angle = dv1.dot(dv2);
     if (angle > 0.999)
+          {
      this->weapon->fire(true);
+          }
+    {
+        if (this->weapon) this->weapon->fire(true);
+    }
+  }
   else

trunk/src/world_entities/npcs/npc.cc

r10618	r10698
407	407	{
408	408	int slot = ws->getWeaponSlot();
409		int side = ws->getWeaponSide();
	409	// int side = ws->getWeaponSide(); //FIXME / REMOVE: is not used
410	410	this->getWeaponManager().setSlotPosition(slot, (*it).second->getCenter());
411	411	this->getWeaponManager().setSlotDirection(slot, ws->getRelDir());

trunk/src/world_entities/playable.h

r10368	r10698
32	32	typedef enum {
33	33	Vertical = 1, //!< Vertical (seen from left or right/move in x-z)
34		Horizontal = 2, //!< Horizontal (seet from the top/move in x-y)
	34	Horizontal = 2, //!< Horizontal (seen from the top/move in x-y)
35	35	FromBehind = 4, //!< Seen from behind (move in z-y)
36	36	Full3D = 8, //!< Full featured 3D-mode. (move in all directions x-y-z)

trunk/src/world_entities/player.cc

-                      r10516
+                      r10698
 #include "event_handler.h"
+#include "creatures/fps_player.h"
 #include "state.h"
 …
     PRINTF(4)("Enter new Playable\n");
     this->playable = playable;
+    this->_hud.setArmorWidget(this->playable->getHealthWidget());
+    if (dynamic_cast<SpaceShip*>(this->playable) != 0)
+    if( playable->isA(FPSPlayer::staticClassID()) )
+    {
+        this->_hud.setMode(Hud::FirstPerson);
+        this->_hud.setHealthWidget(this->playable->getHealthWidget());
+    }
+    else
+    {
+        this->_hud.setMode(Hud::Full3D);
+        this->_hud.setHealthWidget(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->_hud.setWeaponManager(&this->playable->getWeaponManager());*/
     this->playable->setPlayer(this);

trunk/src/world_entities/projectiles/acid_splash.cc

-                      r10511
+                      r10698
   this->toList(OM_NULL);
   //this->toList(OM_DEAD);
   this->removeNode();
+//   this->removeNode();
   AcidSplash::fastFactory->kill(this);
+}

trunk/src/world_entities/projectiles/hbolt.cc

-                      r10618
+                      r10698
   this->setMinEnergy(10);
   this->setHealthMax(0);
   this->lifeSpan = 2.0;
+  this->lifeSpan = 3.0;
   this->angle = 0;
 …
   this->toList(OM_DEAD);
   this->removeNode();
+//   this->removeNode();
   HBolt::fastFactory->kill(this);
 …
   glPushAttrib(GL_ENABLE_BIT);
   glDisable(GL_LIGHTING);
 //   glDisable(GL_FOG);
+  glDisable(GL_FOG);
   glMatrixMode(GL_MODELVIEW);
 …
 //     float matrix[4][4];
     glTranslatef (this->getAbsCoor ().x, this->getAbsCoor ().y, this->getAbsCoor ().z);
+    this->halo->draw();
     Vector tmpRot = this->getAbsDir().getSpacialAxis();
     glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
 …
 //     glMultMatrixf((float*)matrix);
     this->getModel()->draw();
-    this->halo->draw();
   glPopMatrix();

trunk/src/world_entities/projectiles/laser.cc

r10114	r10698
100	100
101	101	this->toList(OM_NULL);
102		this->removeNode();
	102	// this->removeNode();
103	103	Laser::fastFactory->kill(this);
104	104	}

trunk/src/world_entities/projectiles/lbolt.cc

-                      r10618
+                      r10698
   this->halo = new Billboard();
   this->halo->setSize(.35, .35);
   this->halo->setTexture("hbolt_halo.png");
+  this->halo->setTexture("hbolt_halo.jpg");
   this->halo->setVisibility(false);
+  this->halo->setPulse();
+}
 …
   this->toList(OM_DEAD);
   this->removeNode();
+//   this->removeNode();
   LBolt::fastFactory->kill(this);
+}
 …
   angle += LBolt::rotationSpeed * dt;
+  if(angle > 360)
+    angle -= 360;
   for( ObjectList<NPC>::const_iterator eIterator = NPC::objectList().begin(); eIterator !=NPC::objectList().end(); eIterator++)
 …
     float matrix[4][4];
     glTranslatef (this->getAbsCoor ().x, this->getAbsCoor ().y, this->getAbsCoor ().z);
+    Vector tmpRot = this->getAbsDir().getSpacialAxis();
+    this->halo->draw();
+    Vector tmpRot;
+    tmpRot = this->flightDirection.getNormalized();
+    glRotatef(this->angle, tmpRot.x, tmpRot.y, tmpRot.z);
+    tmpRot = this->getAbsDir().getSpacialAxis();
     glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
+    glRotatef(this->angle, 1.0, 0.0, 0.0);
     this->getAbsDir().matrix (matrix);
     glMultMatrixf((float*)matrix);
     this->getModel()->draw();
-    this->halo->draw();
   glPopMatrix();
   glPopAttrib();

trunk/src/world_entities/projectiles/mbolt.cc

-                      r10618
+                      r10698
   this->toList(OM_NULL);
   //this->toList(OM_DEAD);
   this->removeNode();
+//   this->removeNode();
   MBolt::fastFactory->kill(this);
+}
 …
   float matrix[4][4];
   glTranslatef (this->getAbsCoor ().x, this->getAbsCoor ().y, this->getAbsCoor ().z);
+  glRotatef(this->angle, 1.0f, 0.0f, 0.0f); //spinning missile
+//   glRotatef(this->angle, 1.0f, 0.0f, 0.0f); //spinning missile
+  glRotatef(this->angle, this->flightDirection.x, this->flightDirection.y, this->flightDirection.z);
   this->getAbsDir().matrix (matrix);
   glMultMatrixf((float*)matrix);

trunk/src/world_entities/projectiles/rail_projectile.cc

r10114	r10698
99	99
100	100	this->toList(OM_NULL);
101		this->removeNode();
	101	// this->removeNode();
102	102	RailProjectile::fastFactory->kill(this);
103	103	}

trunk/src/world_entities/projectiles/spike.cc

r10368	r10698
111	111
112	112	this->toList(OM_NULL);
113		this->removeNode();
	113	// this->removeNode();
114	114	Spike::fastFactory->kill(this);
115	115	}

trunk/src/world_entities/projectiles/spike_ball.cc

r10511	r10698
149	149
150	150	this->toList(OM_NULL);
151		this->removeNode();
	151	// this->removeNode();
152	152	SpikeBall::fastFactory->kill(this);
153	153	}

trunk/src/world_entities/projectiles/swarm_projectile.cc

-                      r10618
+                      r10698
   this->toList(OM_DEAD);
   this->removeNode();
+//   this->removeNode();
   SwarmProjectile::fastFactory->kill(this);
+}
 …
     this->deactivate();
 /** old  guiding function*/
+  float projectileVelocity = this->getVelocity().len();
+  static float projectileVelocity = this->getVelocity().len();
   if (target != NULL){
     Vector estTargetDir = (this->target->getAbsCoor() - this->getAbsCoor()).getNormalized();
 …
   this->angle += this->rotationSpeed * time;
+  while (this->angle > 360)
+  {
+    this->angle -= 360;
+  }
+  while (this->angle > 360) { this->angle -= 360; }
   this->lastDir = this->curDir;
 …
     PRINTF(0)("Target was hit by Swarm Missile!\n");
+  }
   else if( this->target == NULL)
+  if( this->target == NULL)
     this->deactivate();
+}

trunk/src/world_entities/space_ships/space_ship.cc

-                      r10618
+                      r10698
 #include "util/loading/resource_manager.h"
+#include "world_entities/weapons/weapon_manager.h"
 #include "weapons/test_gun.h"
 #include "weapons/light_blaster.h"
 #include "weapons/medium_blaster.h"
 #include "weapons/heavy_blaster.h"
+#include "weapons/rf_cannon.h"
+#include "weapons/nadion_laser.h"
+#include "weapons/disruptor.h"
 #include "weapons/swarm_launcher.h"
 #include "weapons/spike_thrower.h"
 …
 #include "tools/cameraman.h"
+#include "tools/mount_point.h"
+#include "weapons/weapon_slot.h"
 #include "util/loading/load_param.h"
 …
 #include "track/track.h"
+// #include "lib/gui/gl_gui/glgui_bar.h"
+// #include "lib/gui/gl_gui/glgui_pushbutton.h"
+#include "track/action_box.h"
 …
   //weapons:
+  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->weaponMan.setParentEntity( this);
+  this->secWeaponMan.setParentEntity( this);
+  this->weaponMan.setSlotCount(8);
+  this->secWeaponMan.setSlotCount(6);
+  this->weaponMan.createWeaponSlot(0, 3.270, 1.028, .155, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(1, 3.270, 1.028, -.155, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(2, 4.385, .063, .876, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(3, 4.385, -.063, -.876, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(4, 1.635, -.612, 2.691, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(5, 1.536, -.612, -2.691, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(6, 1.536, -.612, 3.254, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.createWeaponSlot(7, 1.536, -.612, -3.254, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->weaponMan.addWeaponToSlot(0, 0, "RFCannon");
+  this->weaponMan.addWeaponToSlot(0, 1, "RFCannon");
+  this->weaponMan.addWeaponToSlot(0, 2, "RFCannon");
+  this->weaponMan.addWeaponToSlot(0, 3, "RFCannon");
+  this->weaponMan.addWeaponToSlot(1, 0, "RFCannon");
+  this->weaponMan.addWeaponToSlot(1, 1, "RFCannon");
+  this->weaponMan.addWeaponToSlot(1, 2, "RFCannon");
+  this->weaponMan.addWeaponToSlot(1, 3, "RFCannon");
+  this->weaponMan.addWeaponToSlot(0, 4, "NadionLaser");
+  this->weaponMan.addWeaponToSlot(0, 5, "NadionLaser");
+  this->weaponMan.addWeaponToSlot(2, 4, "NadionLaser");
+  this->weaponMan.addWeaponToSlot(2, 5, "NadionLaser");
+  this->weaponMan.addWeaponToSlot(0, 6, "Disruptor");
+  this->weaponMan.addWeaponToSlot(0, 7, "Disruptor");
+  this->weaponMan.addWeaponToSlot(3, 6, "Disruptor");
+  this->weaponMan.addWeaponToSlot(3, 7, "Disruptor");
+  this->secWeaponMan.createWeaponSlot(0, 1.5, 3, 0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->secWeaponMan.createWeaponSlot(1, 2.6, 0, 3.0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->secWeaponMan.createWeaponSlot(2, 1.5, 0, -.5, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->secWeaponMan.createWeaponSlot(3, 1.5, 0, .5, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->secWeaponMan.createWeaponSlot(4, 1.5, 0, .5, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->secWeaponMan.createWeaponSlot(5, 1.5, 0, -.5, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
+  this->secWeaponMan.addWeaponToSlot(0, 2, "SwarmLauncher");
+  this->weaponMan.changeWeaponConfig(0);
   this->secWeaponMan.changeWeaponConfig(0);
-//   curWeaponPrimary    = 3;
-//   curWeaponSecondary  = 0;
   Playable::weaponConfigChanged();
+  reactorOutput     = 10;
+  weaponEnergyRegen = 10;       // 10 einheiten pro Sekunde
+  engineSpeedBase   = 15;
+  shieldRegen       = 2;
+  shieldEnergyShare = 0.3;
+  weaponEnergyShare = 0.3;
+  engineEnergyShare = 0.4;
+  shieldCur         = 100;
+  shieldMax         = 100;
+  shieldTH          = .2 * shieldMax;   // shield power must be 20% before shield kicks in again
+  this->setHealth( 100);
+  this->setHealthMax( 100);
+  electronicCur = 50;
+  electronicMax = 50;
+  electronicRegen   = 3;
+  electronicTH      = .7 * electronicMax; // 30% of eDamage can be handled by the ship
+ this->loadModel("models/spaceships/human_spaceship_fighter.obj", .25);
+  this->bInit = false;
+  loadEnergyShare(.3,.3,.4);
+  loadShield(80, 100, .2, 2);
+  loadHealth(100, 100);
+  loadElectronic(40, 50, .7, 3.0);
+  loadReactor(10);
+  loadWeapon(10);
+  loadEngine(15);
+//   this->loadModel("models/spaceships/fighter_redesign9.obj");
   //this->setVisibiliy(false);
   bForward = bBackward = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = bFire = bSecFire = false;
   this->setHealthMax(shieldMax);
   this->setHealth(shieldCur);
+//   this->setHealthMax(shieldMax);
+//   this->setHealth(shieldCur);
   this->travelNode = new PNode();
 …
   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;
+//   this->electronicWidget = NULL;
+//   this->shieldWidget = NULL;
   //add events to the eventlist
 …
   registerEvent(EV_MOUSE_MOTION);
-  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->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->setSupportedPlaymodes(Playable::Horizontal | Playable::Vertical);
-  /// FIXME
-//   this->trail = new Trail( 5, 10, .2, this);
-//   this->trail->setTexture( "textures/engine.png");
-//
-//   this->trailL = new Trail( 5, 10, .2, this);
-//   this->trailL->setTexture( "textures/engine.png");
-//
-//   this->trailR = new Trail( 5, 10, .2, this);
-//   this->trailR->setTexture( "textures/engine.png");
   this->toList(OM_GROUP_00);
+  //FIXME Just testaddition to show the wobblegrid
+/*
   this->test  = new Wobblegrid(5);
   test->setTexture("textures/blub.png");
   test->setAbsCoor( this->getAbsCoor() + Vector(0, 2, 0));
   test->setParent( this);
+*/
+  dynamic_cast<WorldEntity*>(this)->createHealthWidget();
+  dynamic_cast<WorldEntity*>(this)->createShieldWidget();
+  dynamic_cast<WorldEntity*>(this)->createElectronicWidget();
+  if ( this->hasPlayer() ){
+    State::getPlayer()->hud().setShieldWidget(this->getShieldWidget());
+    State::getPlayer()->hud().setEnergyWidget(this->getElectronicWidget());
+  }
+}
 …
 void SpaceShip::loadParams(const TiXmlElement* root)
+{
+  if(!root)
+    return;
   Playable::loadParams(root);
 …
   LoadParam(root, "actionWidthPercentage", this, SpaceShip, setActionWidthPercentage);
+  State::getCamera()->setViewMode(Camera::ViewTop);
+  State::getCamera()->setViewMode(Camera::ViewNormal);
+  State::getCameraTargetNode()->setParent(this);
+  State::getCamera()->setParent(this);
+  LoadParam(root, "loadReactor", this, SpaceShip, loadReactor)
+  .describe("set reactor output");
+  LoadParam(root, "loadShield", this, WorldEntity, loadShield)
+  .describe("set shield parameters: current strenght , max strenght, threshhold value (0..1), regeneration rate");
+  LoadParam(root, "loadHealth", this, WorldEntity, loadHealth)
+  .describe("set armor/health parameters: current strenght , max strenght");
+  LoadParam(root, "loadElectronic", this, WorldEntity, loadElectronic)
+  .describe("set electronics parameters: current strenght , max strenght, threshhold value (0..1), regeneration rate");
+  LoadParam(root, "loadEngine", this, SpaceShip, loadEngine)
+  .describe("set base speed");
+  LoadParam(root, "loadEnergyShare", this, SpaceShip, loadEnergyShare)
+  .describe("set energy partitioning: shield, weapons, engine (sum should be 1)");
+  LoadParam(root, "loadWeapon", this, SpaceShip, loadWeapon)
+  .describe("set weapon regeneration");
+/*
+  LOAD_PARAM_START_CYCLE(root, element);
+  {
+    LoadParamXML_CYCLE(element, "weaponMan", this->weaponMan, WeaponManager, loadWeapons)
+    .describe("loads Weapons");
+  }
+  LOAD_PARAM_END_CYCLE(element);
+  LOAD_PARAM_START_CYCLE(root, element);
+  {
+    LoadParamXML_CYCLE(element, "secWeaponMan", this->secWeaponMan, WeaponManager, loadWeapons)
+    .describe("loads Weapons");
+  }
+  LOAD_PARAM_END_CYCLE(element);*/
+}
 …
   bForward = bBackward = bLeft = bRight = bAscend = bDescend = bRollL = bRollR = bFire = bSecFire = false;
   //xMouse = yMouse = 0;
   this->setHealth(80);
+  this->resetHealth();
+  this->resetShield();
+  this->resetElectronic();
   this->velocity = Vector(0.0, 0.0, 0.0);
+}
 …
   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);
+}
 …
   State::getCamera()->setEventHandling(true);
   State::getPlayer()->hud().setRadarCenterNode(NULL);
-  //dynamic_cast<Element2D*>(this->secWeaponMan.getFixedTarget())->setVisibility( false);
-  //this->detachCamera();
+}
 …
   if(this->hasPlayer())
     Playable::postSpawn();
-  //setCollision(new CollisionCluster(1.0, Vector(0,0,0)));
+}
 …
 void SpaceShip::tick (float time)
+{
+//   if( !this->bInit)
+//   {
+//     // now get slots from the mount points
+//     std::map<int, MountPoint*>::iterator it = this->mountPointMap.begin();
+//     for( ;it != this->mountPointMap.end(); it++)
+//     {
+//       WeaponSlot* ws = dynamic_cast<WeaponSlot*>((*it).second->getMount());
+//       if( ws != NULL && ws->isA(WeaponSlot::staticClassID()))
+//       {
+//         int slot = ws->getWeaponSlot();
+// //         int side = ws->getWeaponSide(); //FIXME / REMOVE: is not used// HACK needed for some weapons (left/right)
+//         this->getWeaponManager().setSlotPosition(slot, (*it).second->getCenter());
+//         this->getWeaponManager().setSlotDirection(slot, ws->getRelDir());
+// //         PRINTF(0)("setting slot %i\n", slot);
+// //         (*it).second->getCenter().debug();
+//       }
+//     }
+//   this->bInit = true;
+//   }
   // Playable::tick(time);
 …
   if (!(State::getCamera()->getEventHandling()))
+  {
+    //PRINTF(0)("\n\n\n\n\n\n\n\nSETCAMERA %x\n\n\n\n\n\n\n", State::getCamera());
     if( event.type == KeyMapper::PEV_VIEW0)
+    {
 …
   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*/ }
+  static float tmp = this->decreaseShield(pDamage);
+  if( tmp > 0)
+  if ( this->decreaseHealth(tmp / 2) > 0)
     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();
+  }
+}
+}
 …
 void SpaceShip::weaponRegen(float time)
+{
   float energy  = ( this->reactorOutput * this->weaponEnergyShare + this->weaponEnergyRegen) * time;
+  float energy = ( this->reactorOutput * this->weaponEnergyShare + this->weaponEnergyRegen) * time ;
   Weapon* weapon;
   for( unsigned int i=0; i < this->weaponMan.getSlotCount(); i++)
+  {
+  int weaponCount = 0;
+  for( unsigned int i=0; i < this->weaponMan.getSlotCount(); i++) {
     weapon = this->weaponMan.getWeapon(i);
+    if( weapon != NULL && weapon->isActive())
+    {
+    if( weapon != NULL && weapon->isActive()) {
+      weaponCount++;
+    }
+  }
+  if (weaponCount == 0)
+    return;
+  energy *= ( this->weaponMan.getSlotCount() / (float)weaponCount );
+  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)
+{
+void SpaceShip::enterPlaymode(Playable::Playmode playmode){
   switch(playmode)
+  {
 …
+      }
       break;
+    case Playable::Vertical:
+    {
+        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::ViewNormal);
+        State::getCamera()->setEventHandling(false);
+        PRINTF(0)("\n\n\n\n\n\n\n\nSETCAMERA %x\n\n\n\n\n\n\n", State::getCamera());
+        State::getCamera()->setViewMode(Camera::ViewNormal);
+        State::getCameraTargetNode()->setParent(this);
+        State::getCamera()->setParent(this);
+        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);
+      break;
+    }
     default:
 …
+    }
     case Playable::Vertical:
+    {
+      if ( !entityTrack || !entityTrack->getActionBox() )
+      {
+        break;
+      }
+      ActionBox * box = entityTrack->getActionBox();
+      this->travelVelocity = Vector(0, 0, 0);
+      float ssss = 50;
+      if ( this->bForward )
+      {
+        this->travelVelocity += Vector( 0, ssss, 0 );
+      }
+      if ( this->bBackward )
+      {
+        this->travelVelocity += Vector( 0, -ssss, 0 );
+      }
+      if ( this->bLeft )
+      {
+        this->travelVelocity += Vector( 0, 0, -ssss );
+      }
+      if ( this->bRight )
+      {
+        this->travelVelocity += Vector( 0, 0, ssss );
+      }
+      Vector ds = this->travelVelocity*dt;
+      Vector newPos = this->getRelCoor() + ds;
+      if ( newPos.y < -(box->getHeight_2()) || newPos.y > box->getHeight_2() )
+      {
+        this->travelVelocity.y = 0;
+      }
+      if ( newPos.z > box->getWidth_2() || newPos.z < -(box->getWidth_2()) )
+      {
+        this->travelVelocity.z = 0;
+      }
+    }
       break;
     default:
 …
+}
+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::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::getPlayer()->hud().setOverlayPercentage(100-int(100*this->actionWidthPercentage));
   PRINTF(0)("TravelDistance has been updated\n");
+//   PRINTF(0)("TravelDistance has been updated\n");
   this->isTravelDistanceInit = true;
+}
 …
     this->isTravelDistanceInit = false;
 };

trunk/src/world_entities/space_ships/space_ship.h

-                      r10531
+                      r10698
 #include "playable.h"
 #include "extendable.h"
+#include "world_entity.h"
 // Forward Declaration
 …
     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
+    //!< functions for XML loading
+    void loadReactor(float output) {this->reactorOutput = output; };
+    void loadEngine( float speedBase) {this->engineSpeedBase = speedBase; };
+    void loadEnergyShare(float shield, float weapon, float engine)
+        { float tmp = shield + weapon + engine; if (unlikely (tmp > 1)) { tmp = 1/tmp; }
+          // HACK dirty safety hack, prevents total share being bigger than 1!!
+          this->shieldEnergyShare = shield * tmp;
+          this->weaponEnergyShare = weapon * tmp;
+          this->engineEnergyShare = engine * tmp; };
+    inline void loadWeapon(float regen) { this->weaponEnergyRegen = regen; };
+    void addWeaponToSlot(int wm, int config, int slot, const std::string& weaponName);
     inline PNode* getTravelNode() { return this->travelNode; };
 …
     virtual void movement (float dt);
+    //
     void nextWeaponConfig();
 …
     virtual void hit(float damage, WorldEntity* killer);
     void                  setCameraDistance(float dist);
 …
     //void calculateVelocity(float time);
     void regen(float time);  //!< handler for shield and electronic regeneration
+//    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();
+//     inline bool systemFailure() {  return (this->getElectronic() < float(rand())/float(RAND_MAX) * this->getElectronicTH()); };
+//     void updateElectronicWidget();
+//     void updateShieldWidget();
     //WeaponManager         weaponMan;      //!< the primary weapon manager: managing a list of energy weapons to wepaon-slot mapping
 …
     //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?)
+//    float       shieldCur;          //!< current shield
+//    float       shieldMax;          //!< maximum shield
+//    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       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
 …
     int         enginePowerConsume; //!< energy needed
     float       engineEnergyShare;  //!< percentage of reactor output
+    float       shieldEnergyShare;  //!< percentage of reactor output
     int         weaponEnergySlot;   //!< number of energy weapon slots
 …
     float       reactorOutput;      //!< reactor output
     float       reactorCapacity;    //!< reactor capacity
+//    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                  bForward;           //!< up button pressed.
+    bool                  bBackward;          //!< down button pressed.
     bool                  bLeft;              //!< left button pressed.
     bool                  bRight;             //!< right button pressed.
 …
     bool                  bRollR;             //!< rolling button pressed (right)
     bool                  bSecFire;           //!< second fire button pressed
+    bool                  bInit;              //!< set true, if MP have been loaded
     /*
 …
     byte                  oldMask;            //!< used for synchronisation
+/*
     Trail*                trail;              //!< Burst trail
     Trail*                trailL;              //!< Burst trail
     Trail*                trailR;              //!< Burst trail
+*/
 };

trunk/src/world_entities/spectator.cc

-                      r10682
+                      r10698
 #include "player.h"
+#include "util/track/action_box.h"
 …
   else if( event.type == KeyMapper::PEV_BACKWARD)
     this->bBackward = event.bPressed; //this->shiftCoor(0,-.1,0);
+  else if ( event.type == KeyMapper::PEV_JUMP )
+  {
+    if ( State::getActionBox() && State::getActionBox()->isPointInBox( this->getAbsCoor() ) )
+    {
+      PRINTF(0)("IN BOX\n");
+    }
+    else
+    {
+      PRINTF(0)("NOT IN BOX\n");
+    }
+  }
   else if( event.type == EV_MOUSE_MOTION)
+  {

trunk/src/world_entities/tools/camera.cc

-                      r10618
+                      r10698
       this->setRelCoor(Vector(-0.05, this->viewTopDistance , 0));
       this->target->setRelCoor(0,0,0);
+      break;
+    }
+    case Camera::ViewFPS:
+    {
+      this->fovy = viewNormalFovy;
+      this->toFovy = viewNormalFovy;
+      this->setRelCoorSoft(this->viewFrontDistance, 0, 0, 5);
+      this->target->setRelCoorSoft(Vector(10,0,0), 5);
+      break;
+    }
+    case Camera::ViewFPSZoom:
+    {
+      this->fovy = viewNormalFovy;
+      this->toFovy = 30;
+      this->setRelCoorSoft(2, 0, 0, 5);
+      this->target->setRelCoorSoft(Vector(10,0,0), 5);
+    }
+  }

trunk/src/world_entities/tools/camera.h

-                      r10618
+                      r10698
     ViewLeft,
     ViewRight,
+    ViewTop
+    ViewTop,
+    ViewFPS,
+    ViewFPSZoom
   };
   public:

trunk/src/world_entities/tools/mount_point.cc

r10618	r10698
22	22
23	23	#include "weapons/weapon_slot.h"
	24	#include "weapons/weapon.h"
24	25
25	26	#include "particles/particle_system.h"
…	…
36	37	* construct
37	38	*/
38		MountPoint::MountPoint (const Vector& up, const Vector& forward, const Vector& center, const std::string& name)
	39	MountPoint::MountPoint (const Vector& up, const Vector& forward, const Vector& center, const std::string& name)
39	40	{
40	41	// PRINTF(0)("Created mount point %s\n", name.c_str());
…	…
153	154	this->getRelDir()*Quaternion(M_PI, Vector(0,1,0)));
154	155	}
	156
155	157	}
156	158	}

trunk/src/world_entities/weapons/aiming_system.cc

r10013	r10698
112	112	void AimingSystem::hit(float damage, WorldEntity* killer)
113	113	{
114		if( this->owner != killer)
	114	if( this->owner != killer && killer != this && !killer->isA( AimingSystem::staticClassID() ) )
115	115	{
116	116	//PRINTF(0)("real hit: %s\n", killer->getClassCName());
…	…
127	127	void AimingSystem::tick(float dt)
128	128	{
129
130
131	129	}
132	130

trunk/src/world_entities/weapons/heavy_blaster.cc

-                      r10618
+                      r10698
 //  this->model = (Model*)ResourceManager::getInstance()->load("models/guns/test_gun.obj", OBJ, RP_CAMPAIGN);
   this->loadModel("models/guns/frag_cannon.obj", .4);
+  this->loadModel("models/guns/frag_cannon2.obj", .4);
 …
     this->objComp[i] = new PNode* [this->getSegs()];
     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]->setParent(this);      //Parenting emissionPoint to Weapons
     this->emissionPoint[i]->setName("EmissionPoint");
     this->emissionPoint[i]->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
 …
-//   Animation3D* animB0Shoot = this->getAnimation(WS_SHOOTING0, this->objComp[0][0]);
-//   Animation3D* animB1Shoot = this->getAnimation(WS_SHOOTING1, this->objComp2);
-//   Animation3D* animB2Shoot = this->getAnimation(WS_SHOOTING2, this->objComp3);
-//   Animation3D* animT0Shoot = this->getAnimation(WS_SHOOTING3, this->objComp[0][1]);
-//   Animation3D* animT1Shoot = this->getAnimation(WS_SHOOTING4, this->objComp5);
-//   Animation3D* animT2Shoot = this->getAnimation(WS_SHOOTING5, this->objComp6);
-//   this->shootAnim[0][0]->setInfinity(ANIM_INF_CONSTANT);
-//   animB1Shoot->setInfinity(ANIM_INF_CONSTANT);
-//   animB2Shoot->setInfinity(ANIM_INF_CONSTANT);
-//   animT0Shoot->setInfinity(ANIM_INF_CONSTANT);
-//   animT1Shoot->setInfinity(ANIM_INF_CONSTANT);
-//   animT2Shoot->setInfinity(ANIM_INF_CONSTANT);
   for (int i = 0; i < this->getBarrels(); i++){
     this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.05, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.01, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][0]->addKeyFrame(Vector(-0.3, 0.0, 0.0), Quaternion(), 0.9, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.55, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.05, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.5, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.1, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][1]->addKeyFrame(Vector(-0.4, 0.0, 0.0), Quaternion(), 1.2, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.25, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.2, ANIM_LINEAR, ANIM_NULL);
+  }
 …
   animation2->setInfinity(ANIM_INF_CONSTANT);
   animation3->setInfinity(ANIM_INF_CONSTANT);
-//   this->setEmissionPoint(3.8, 1.2, 0, 0);
   animation2->addKeyFrame(Vector(0.0, -1.0, 0.0), Quaternion(), 0.3, ANIM_LINEAR, ANIM_NULL);
 …
   pj->setParent(PNode::getNullParent());
-//   pj->setVelocity(this->getAbsDir().apply(Vector(1,0,0))*250 + VECTOR_RAND(5));
-//   pj->setVelocity(this->getAbsDir().apply(Vector(1,0,0))*130 + VECTOR_RAND(1));
   pj->setVelocity(this->getAbsDir().apply(Vector(1,0,0))*130 + VECTOR_RAND(1));
   pj->setAbsCoor(this->emissionPoint[this->activeBarrel]->getAbsCoor());
-//   pj->setAbsCoor(this->getEmissionPoint(0));
   pj->setAbsDir(this->getAbsDir());
-//   pj->toList(OM_GROUP_01_PROJ);
   pj->activate();

trunk/src/world_entities/weapons/laser_cannon.cc

-                      r10415
+                      r10698
   this->registerObject(this, LaserCannon::_objectList);
 //  this->model = (Model*)ResourceManager::getInstance()->load("models/guns/laser_cannon.obj", OBJ, RP_CAMPAIGN);
+  this->setScaling (5);
   this->loadModel("models/guns/lasercannon.obj", 5.0f);
+  this->loadModel("models/guns/lasercannon.obj", this->getScaling());
   this->setStateDuration(WS_SHOOTING, .1);
 …
   this->setProjectileTypeC("RailProjectile");
   this->prepareProjectiles(100);
   this->setEmissionPoint(Vector(2.8,0,0) * 5.0);
+  this->setEmissionPoint(Vector(2.8,0,0) * this->getScaling());
+}

trunk/src/world_entities/weapons/light_blaster.cc

-                      r10618
+                      r10698
   this->setCapability(WTYPE_ALLDIRS | WTYPE_DIRECTIONAL | WTYPE_LIGHT);
   this->setProjectileTypeC("LBolt");
   this->prepareProjectiles(100);
+  this->prepareProjectiles(25);
   this->setBarrels(3);
 …
     this->emissionPoint[i]->setName("EmissionPoint");
     this->emissionPoint[i]->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
-//     this->shootAnim[i] = new Animation3D* [this->getSegs()];
     for(int j = 0; j < this->getSegs(); j++)
+    {
 …
+    }
+  }
-/*
-  this->emissionPoint[0]->setRelCoor(Vector(1.19, 0.0, 0.1));
-  this->emissionPoint[1]->setRelCoor(Vector(1.19, -0.07, -0.05));
-  this->emissionPoint[2]->setRelCoor(Vector(1.19, 0.07, -0.05));*/
   this->emissionPoint[0]->setRelCoor(Vector(2.2, 0.0, 0.1));
 …
   animation2->setInfinity(ANIM_INF_CONSTANT);
   animation3->setInfinity(ANIM_INF_CONSTANT);
-//   this->setEmissionPoint(3.8, 1.2, 0);
-//   for (int i = 0; i < this->getBarrels(); i++){
-//     this->shootAnim[i][0]->addKeyFrame(Vector(), Quaternion(i * 120, Vector(1.0, 0.0, 0.0)), 0.049, ANIM_NULL, ANIM_LINEAR);
-//     this->shootAnim[i][0]->addKeyFrame(Vector(), Quaternion((i+1)*120, Vector(1.0, 0.0, 0.0)), 0.001, ANIM_NULL, ANIM_LINEAR);
-//   }

trunk/src/world_entities/weapons/medium_blaster.cc

-                      r10618
+                      r10698
 void MediumBlaster::init()
+{
+  this->loadModel("models/guns/blaster.obj", .33);
+  this->setScaling(.3333);
+  this->loadModel("models/guns/blaster.obj", this->getScaling());
   this->setStateDuration(WS_SHOOTING, 0.2);   // 5 Schuss pro Sekunde
 …
   this->setActionSound(WA_SHOOT, "sounds/guns/laser.wav");
   this->setActionSound(WA_ACTIVATE, "sounds/voices/lasers.wav");
+//   this->setActionSound(WA_ACTIVATE, "sounds/voices/lasers.wav");
   this->setActionSound(WA_RELOAD, "sounds/spawn/alien_generator.wav");
   this->setCapability(WTYPE_ALLDIRS | WTYPE_DIRECTIONAL | WTYPE_LIGHT);
   this->setProjectileTypeC("MBolt");   // FIXME temp project type until the blaste class exist
   this->prepareProjectiles(100);
+  this->setProjectileTypeC("MBolt");
+  this->prepareProjectiles(10);
 …
   this->objComp = new PNode**[this->getBarrels()];
+  this->emissionPoint = new PNode*[this->getBarrels()];
   this->shootAnim = new Animation3D**[this->getBarrels()];
   for (int i = 0; i < this->getBarrels(); i++)
+  {
     this->objComp[i] = new PNode* [this->getSegs()];
+    this->emissionPoint[i] = new PNode;
+    this->emissionPoint[i]->setParent(this);  //Parenting emissionPoint to Weapon
+    this->emissionPoint[i]->setName("EmissionPoint");
+    this->emissionPoint[i]->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
     this->shootAnim[i] = new Animation3D* [this->getSegs()];
     for(int j = 0; j < this->getSegs(); j++)
 …
   for (int i = 0; i < this->getBarrels(); i++){
     this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.04, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][0]->addKeyFrame(Vector(-0.333, 0.0, 0.0), Quaternion(), 0.15, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.01, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.04, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][1]->addKeyFrame(Vector(.166, 0.0, 0.0), Quaternion(), 0.15, ANIM_LINEAR, ANIM_NULL);
     this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0), Quaternion(), 0.01, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0) * this->getScaling(), Quaternion(), 0.04, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][0]->addKeyFrame(Vector(-1.0, 0.0, 0.0) * this->getScaling(), Quaternion(), 0.15, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][0]->addKeyFrame(Vector(0.0, 0.0, 0.0) * this->getScaling(), Quaternion(), 0.01, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0) * this->getScaling(), Quaternion(), 0.04, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][1]->addKeyFrame(Vector(.5, 0.0, 0.0) * this->getScaling(), Quaternion(), 0.15, ANIM_LINEAR, ANIM_NULL);
+    this->shootAnim[i][1]->addKeyFrame(Vector(0.0, 0.0, 0.0) * this->getScaling(), Quaternion(), 0.01, ANIM_LINEAR, ANIM_NULL);
+  }
 …
   animation3->setInfinity(ANIM_INF_CONSTANT);
+  this->setEmissionPoint(1.3, 0, 0);
+  this->emissionPoint[0]->setRelCoor(Vector(3.9, 0.0, 0.0) * this->getScaling());
   animation2->addKeyFrame(Vector(0.0, -1.0, 0.0), Quaternion(), 0.3, ANIM_LINEAR, ANIM_NULL);

trunk/src/world_entities/weapons/medium_blaster.h

r10516	r10698
33	33	PNode*** objComp;
34	34	Animation3D*** shootAnim;
	35	PNode** emissionPoint;
35	36
36	37	int activeBarrel;

trunk/src/world_entities/weapons/weapon.cc

-                      r10529
+                      r10698
   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]->setParent(this);  //Parenting emissionPoint to Weapons
     this->emissionPoint[i]->setName("EmissionPoint");
     this->emissionPoint[i]->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
 …
   // set this object to be synchronized over network
   //this->setSynchronized(true);
+}
-/**
- * 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;
+}

trunk/src/world_entities/weapons/weapon.h

-                      r10516
+                      r10698
     Projectile* getProjectile();
+    inline void setScaling(float scaling) { this->scaling = scaling; };
+    inline float getScaling() { return this->scaling; };
     // EMISSION
 …
     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();
+//     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();
 …
     PNode*               defaultTarget;                    //!< A target for targeting Weapons.
+    float                scaling;                          //!< Local scaling factor. any scaling will be done through this vector.
     ////////////
     // PHASES //

trunk/src/world_entities/weapons/weapon_manager.cc

-                      r10544
+                      r10698
 /*
    orxonox - the future of 3D-vertical-scrollers
 …
 /**
  * @brief this initializes the weaponManager for a given nnumber of weapon slots
  * @param number of weapon slots of the model/ship <= 8 (limitied)
+ * @param number of weapon slots of the model/ship <= 10 (limitied)
  */
 WeaponManager::WeaponManager(WorldEntity* parent)
 …
   BaseObject::loadParams(root);
   LoadParam(root, "slot-count", this, WeaponManager, setSlotCount)
+  LoadParam(root, "slotCount", this, WeaponManager, setSlotCount)
   .describe("how many slots(cannons) the WeaponManager can handle");
   LOAD_PARAM_START_CYCLE(root, element);
 …
+  }
   LOAD_PARAM_END_CYCLE(element);
+}
 …
  * @param slotCapability the capability @see WeaponSlotCapability
  */
 void WeaponManager::setSlotCapability(int slot, long slotCapability)
+void WeaponManager::setSlotCapability(int slot, unsigned long slotCapability)
+{
   if (slot > slotCount)

trunk/src/world_entities/weapons/weapon_manager.h

-                      r10437
+                      r10698
     // setting up the WeaponManager with the following functions
     void setSlotPosition(int slot, const Vector& position, PNode* parent = NULL);
+//     inline void setSlotPosition(float slot, float x, float y,float z) {setSlotPosition((int)slot, Vector(x,y,z));};
     void setSlotDirection(int slot, const Quaternion& rotation);
     /** @param slot the slot to get the relative position from @returns the relative position of the Carrier to the Slot */
     const Vector& getSlotPosition(int slot) const;
     void setSlotCapability(int slot, long slotCapability);
+    void setSlotCapability(int slot, unsigned long slotCapability);
     /** @param slot the slot to get the capabilities from @returns the capabilies */
     long getSlotCapability(int slot) const;
 …
     bool addWeapon(Weapon* weapon, int configID = -1, int slotID = -1);
     void removeWeapon(Weapon* weapon, int configID = -1);
+    inline void createWeaponSlot(int slot, float x, float y, float z, long capability) {
+        this->setSlotPosition(slot, Vector( x, y, z));
+        this->setSlotCapability(slot, capability); };
+    inline void addWeaponToSlot(int config, int slot, const std::string& weaponName){
+      this->addWeapon( Weapon::createWeapon( weaponName ), config, slot); };
     Weapon* getWeapon(int slotID) const;

trunk/src/world_entities/weapons/weapon_slot.cc

-                      r10534
+                      r10698
 WeaponSlot::~WeaponSlot()
+{}
+{
+}
 …
   LoadParam(root, "slot", this, WeaponSlot, setWeaponConfig)
+      .describe("sets the weapon slot");
+  .describe("sets the weapon slot");
+  LoadParam(root, "currentWeapon", this, WeaponSlot, setCurrentWeapon)
+  .describe("creates and set next weapon");
+  LoadParam(root, "nextWeapon", this, WeaponSlot, setNextWeapon)
+  .describe("creates and set next weapon");
+}
 …
 void WeaponSlot::setWeaponClass()
+{
+}

trunk/src/world_entities/weapons/weapon_slot.h

-                      r10534
+                      r10698
 #include "p_node.h"
+#include "weapon.h"
 class Weapon;
 …
   inline void setNextWeapon(Weapon* weapon) { this->nextWeapon = weapon; }
+  inline void setNextWeapon(const std::string& weaponName){this->nextWeapon = Weapon::createWeapon(weaponName); };
+  inline void setCurrentWeapon(const std::string& weaponName){ this->currentWeapon = Weapon::createWeapon(weaponName); };
   inline void setWeaponConfig(int slot, int side) { this->weaponSlot = slot; this->weaponSide = side; }

trunk/src/world_entities/world_entity.cc

-                      r10618
+                      r10698
   this->aabbNode = NULL;
   this->healthWidget = NULL;
+  this->electronicWidget = NULL;
+  this->shieldWidget = NULL;
   this->healthMax = 1.0f;
   this->health = 1.0f;
 …
   // Delete the obbTree
   if( this->obbTree != NULL)
+  if( this->obbTree)
     delete this->obbTree;
   if (this->healthWidget != NULL)
+  if (this->healthWidget)
     delete this->healthWidget;
+  if(this->shieldWidget)
+    delete this->shieldWidget;
+  if( this->electronicWidget)
+    delete this->electronicWidget;
   this->unsubscribeReactions();
 …
   this->updateHealthWidget();
   return 0.0;
+}
+}
 /**
 …
   this->updateHealthWidget();
+}
+/**
+ * @param shiled the Shieldstength to add.
+ * @returns the shield left (this->shieldMax - shiled + this->shield)
+ */
+float WorldEntity::increaseShield(float shiled)
+{
+  this->shield += shield;
+  if (this->shield > this->shieldTH * this->shieldMax) { this->bShieldActive = true; }
+  if (this->shield > this->shieldMax)
+  {
+    float retShield = this->shieldMax - this->shield;
+    this->shield = this->shieldMax;
+//     this->updateShieldWidget();
+    return retShield;
+  }
+//   this->updateShieldWidget();
+  return 0.0;
+}
+/**
+ * @param shield the Shieldstrength to be removed
+ * @returns 0.0 or the rest, if the shield drops belew 0.0
+ */
+float WorldEntity::decreaseShield(float shield)
+{
+  this->shield -= shield;
+  if (this->shield <= 0)
+  {
+    float retShield = -this->shield;
+//     this->updateShieldWidget();
+    this->bShieldActive = false;
+    return retShield;
+  }
+//   this->updateShieldWidget();
+  return 0.0;
+}
 /**
 …
+}
+/**
+ * @brief creates the ImplantWidget
+ *
+ * since not all entities need an ImpantWidget, it is only created on request.
+ */
+void WorldEntity::createImplantWidget()
+{
+  if (this->implantWidget == NULL)
+  {
+    this->implantWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    //this->impantWidget->setDisplayedName("Implant");
+    //this->impantWidget->setSize2D(100,20);
+    //this->impantWidget->setAbsCoor2D(100,200);
+    //this->updateImplantWidget();
+  }
+  else
+    PRINTF(3)("Allready created the ImlpantWidget for %s::%s\n", this->getClassCName(), this->getCName());
+}
+void WorldEntity::createShieldWidget()
+{
+  if (this->shieldWidget == NULL)
+  {
+    this->shieldWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    this->updateShieldWidget();
+  }
+  else
+    PRINTF(3)("Allready created the ShieldWidget for %s::%s\n", this->getClassCName(), this->getCName());
+}
+void WorldEntity::createElectronicWidget()
+{
+  if (this->electronicWidget == NULL)
+  {
+    this->electronicWidget = new OrxGui::GLGuiEnergyWidgetVertical();
+    this->updateElectronicWidget();
+  }
+  else
+    PRINTF(3)("Allready created the ElectronicWidget for %s::%s\n", this->getClassCName(), this->getCName());
+}
 void WorldEntity::increaseHealthMax(float increaseHealth)
+{
 …
 OrxGui::GLGuiWidget* WorldEntity::getHealthWidget()
+{
+  this->createHealthWidget();
+  if ( this->healthWidget == NULL)
+    this->createHealthWidget();
   return this->healthWidget;
+}
+OrxGui::GLGuiWidget* WorldEntity::getImplantWidget()
+{
+  this->createImplantWidget();
+  return this->implantWidget;
+}
+OrxGui::GLGuiWidget* WorldEntity::getShieldWidget()
+{
+  if ( this->shieldWidget == NULL)
+    this->createShieldWidget();
+  return this->shieldWidget;
+}
+OrxGui::GLGuiWidget* WorldEntity::getElectronicWidget()
+{
+  if ( this->electronicWidget == NULL)
+    this->createElectronicWidget();
+  return this->electronicWidget;
+}
 /**
 …
  * (creates the widget if needed)
  */
 void WorldEntity::setHealthWidgetVisibilit(bool visibility)
+void WorldEntity::setHealthWidgetVisibility(bool visibility)
+{
   if (visibility)
 …
+  }
+}
+/**
+ * @brief updates the Electronic Widget
+ */
+//!< xferred from spaceship
+void WorldEntity::updateElectronicWidget(){
+  if (this->electronicWidget != NULL)
+  { //if it exists already: update it
+     this->electronicWidget->setMaximum(this->electronicMax);
+     this->electronicWidget->setValue(this->electronic);
+  }
+  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 ( dynamic_cast<SpaceShip*>(this)->hasPlayer() )
+//       State::getPlayer()->hud().setEnergyWidget(this->electronicWidget);
+  }
+}
+/**
+ * @brief updates the ShieldWidget
+ */
+//!< xferred from spaceship
+void WorldEntity::updateShieldWidget()
+{
+  if (this->shieldWidget != NULL)
+  {
+    this->shieldWidget->setMaximum(this->shieldMax);
+    this->shieldWidget->setValue(this->shield);;
+  }
+  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 (dynamic_cast<SpaceShip*>(this)->hasPlayer())
+//       State::getPlayer()->hud().setShieldWidget(this->shieldWidget);
+  }
+}
 …
+}
+void WorldEntity::regen(float time){
+  static float tmp;
+  increaseHealth(time * this->healthRegen);
+  increaseShield(time * this->shieldRegen);
+//   updateHealthWidget();
+//   updateShieldWidget();
+  //this->setHealth( this->shieldCur);      // FIXME currently just to test share system
+  if (this->electronic != this->electronicMax || this->electronicRegen != 0){
+    tmp = this->electronic + this->electronicRegen * time;
+    if ( tmp > electronicMax)
+      this->electronic = this->electronicMax;
+    else
+      this->electronic = tmp;
+    updateElectronicWidget();
+  }
+}

trunk/src/world_entities/world_entity.h

-                      r10540
+                      r10698
   void increaseHealthMax(float increaseHealth);
   OrxGui::GLGuiWidget* getHealthWidget();
+  OrxGui::GLGuiWidget* getImplantWidget();
+  OrxGui::GLGuiWidget* getShieldWidget();
+  OrxGui::GLGuiWidget* getElectronicWidget();
   bool hasHealthWidget() const { return this->healthWidget != NULL; };
+  float getShield() const { return this->shield; };
+  float getShieldMax() const { return this->shieldMax; };
+  float increaseShield(float shield);
+  float decreaseShield(float shield);
+  bool getShieldActive() { return this->bShieldActive; };
+  float getElectronic() const { return this->electronic; };
+  float getElectronicMax() const { return this->electronicMax; };
+  float increaseElectronic(float electronic);
+  float decreaseElectronic(float electronic);
+  bool systemFailure() {  return (this->electronic < float(rand())/float(RAND_MAX) * this->electronicTH); };
+  void resetElectronic() { this->electronic = this->electronicMax; };
+  void resetShield()  { this->shield = this->shieldMax; this->bShieldActive = true; };
+  void resetHealth() { this->health = this->healthMax; };
+  void createHealthWidget();
+  void createShieldWidget();
+  void createElectronicWidget();
+  void regen(float time);
+  void loadShield(float cur, float max, float th, float regen)
+      { this->setShield(cur); this->setShieldMax(max); this->setShieldTH(th); this->setShieldRegen(regen); };
+  void loadHealth(float cur, float max, float regen = 0) { this->setHealth(cur); this->setHealthMax(max); this->setHealthRegen(regen); };
+  void loadElectronic(float cur, float max, float th, float regen)
+      { this->setElectronic(cur); this->setElectronicMax(max); this->setElectronicTH(th); this->setElectronicRegen(regen); };
   virtual void varChangeHandler( std::list<int> & id );
 …
   void pauseTrack(bool stop);
+//   void updateHealthWidget();
+//   void updateElectronicWidget();
+//   void updateShieldWidget();
 protected:
   void setHealth(float health) { this->health = health; this->updateHealthWidget();};
   void setHealthWidgetVisibilit(bool visibility);
+  inline void setHealth(float health) { this->health = health; this->updateHealthWidget();};
+  void setHealthWidgetVisibility(bool visibility);
   void setHealthMax(float healthMax);
+  void createHealthWidget();
+//   void createHealthWidget();
+//   void createShieldWidget();
+//   void createElectronicWidget();
+  void setHealthRegen(float regen) { this->healthRegen = regen; };
+  void createImplantWidget();
     //  CharacterAttributes*    charAttr;         //!< the character attributes of a world_entity
+  void setShield(float shield) { this->shield = shield; };
+  void setShieldMax(float shield) { this->shieldMax = shield; };
+  void setShieldTH(float th) { this->shieldTH = th; };
+  void setShieldRegen(float regen) { this->shieldRegen = regen; };
+  void setShieldActive(bool active) { this->bShieldActive = active; };
+  void setElectronic(float electronic) { this->electronic = electronic; };
+  void setElectronicMax(float electronic) { this->electronicMax = electronic; };
+  void setElectronicTH(float th) { this->electronicTH = th; };
+  void setElectronicRegen(float regen) { this->electronicRegen = regen; };
   inline void drawDebugTrack(int flag) { this->bDrawTrack = (bool)flag; }
   inline bool isDrawTrack() const { return this->bDrawTrack; }
 private:
   void updateHealthWidget();
+  void updateElectronicWidget();
+  void updateShieldWidget();
   void addTrack(const TiXmlElement* root);
   protected:
       std::vector<MountPoint*> mountPoints;       //!< A list with mount points for this model
       std::map<int, MountPoint*> mountPointMap;
+protected:
+  std::vector<MountPoint*> mountPoints;       //!< A list with mount points for this model
+  std::map<int, MountPoint*> mountPointMap;
 private:
+  /// TODO maybe we will move the following three entries and the corresponding functions to Playable AND NPC
+  //!< TODO maybe we will move the following three entries and the corresponding functions to Playable AND NPC
+  //!< started transfering shield/electronic/health from spaceship to WE! (nico, 4.Jun.07)
   float                   damage;             //!< the damage dealt to other objects by colliding.
   float                   health;             //!< The Energy of this Entity, if the Entity has any energy at all.
+  float                   healthMax;          //!< The Maximal energy this entity can take.
+  float                   healthMax;          //!< The Maximal energy this entity can take.
+  float                                         implantEnergy;          //!< energy of implants
+  float                   healthRegen;        //!< Regeneration Rate of Health, mesured in units per second
   OrxGui::GLGuiEnergyWidgetVertical* healthWidget;    //!< The Slider (if wanted).
+  OrxGui::GLGuiEnergyWidgetVertical* implantWidget;
+  float       shield;             //!< current shield
+  float       shieldMax;          //!< maximum shield
+  float       shieldRegen;        //!< shield regeneration rate per second
+  float       shieldTH;           //!< shield threshhold for reactivation
+  bool        bShieldActive;      //!< wheather the shield is working
+  OrxGui::GLGuiEnergyWidgetVertical* shieldWidget; //!< holds the widget that shows the shield bar
+  float       electronic;         //!< 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
   std::vector<Model*>     models;             //!< The model that should be loaded for this entity.
 …
   float                   healthMax_write;
   int                     healthMax_handle;

Context Navigation

Changeset 10698 in orxonox.OLD

Legend:

Download in other formats: