Index: branches/playability/src/world_entities/projectiles/projectile.cc
===================================================================
--- branches/playability/src/world_entities/projectiles/projectile.cc	(revision 9956)
+++ branches/playability/src/world_entities/projectiles/projectile.cc	(revision 9957)
@@ -122,4 +122,12 @@
 
 
+
+void Projectile::collidesWith (WorldEntity* entity, const Vector& location)
+{
+  //if (entity->isA(CL_SPACE_SHIP)) /* FIXME make sure that entity is a spaceship*/
+  //  entity->damage(this->physDamage, this->elecDamage); /* and do some damage*/
+  this->destroy(entity);
+}
+
 /**
  * signal tick, time dependent things will be handled here
@@ -145,6 +153,4 @@
 }
 
-
-
 int Projectile::getPhysDamage () { return this->physDamage; }
 
Index: branches/playability/src/world_entities/projectiles/projectile.h
===================================================================
--- branches/playability/src/world_entities/projectiles/projectile.h	(revision 9956)
+++ branches/playability/src/world_entities/projectiles/projectile.h	(revision 9957)
@@ -44,4 +44,6 @@
     virtual void destroy (WorldEntity* killer);
 
+    virtual void collidesWith (WorldEntity* entity, const Vector& location);   //!< collision handler as used in diverse weapons
+
     virtual void tick (float dt);
     /** @brief convenience function
Index: branches/playability/src/world_entities/space_ships/space_ship.cc
===================================================================
--- branches/playability/src/world_entities/space_ships/space_ship.cc	(revision 9956)
+++ branches/playability/src/world_entities/space_ships/space_ship.cc	(revision 9957)
@@ -521,14 +521,5 @@
 
 
-int SpaceShip::getShieldCur () { return this->shieldCur; }
-int SpaceShip::getShieldMax () { return this->shieldMax; }
-
-int SpaceShip::getArmorCur () { return this->armorCur; }
-int SpaceShip::getArmorMax () { return this->armorMax; }
-
-int SpaceShip::getElectronicCur () { return this->electronicCur; }
-int SpaceShip::getElectronicMax () { return this->electronicMax; }
-
-void SpaceShip::damage(int pDamage, int eDamage){
+void SpaceShip::damage(float pDamage, float eDamage){
 if( this->shieldActive) {
     if( this->shieldCur > pDamage) {
@@ -540,5 +531,5 @@
       pDamage = pDamage - this->shieldCur;
       if( !this->shieldActive) {
-        this->armorCur = pDamage / 2; // remaining damages hits armor at half rate
+        this->armorCur -= pDamage / 2; // remaining damages hits armor at half rate
         this->electronicCur -= eDamage;
       }
@@ -552,22 +543,20 @@
 }
 
-void SpaceShip::regen(){
-  int time = 1; // FIXME implement tick time calculation
-  if (this->shieldCur == this->shieldMax){}
-  else {
-    if( this->shieldCur + this->shieldRegen * time > shieldMax)
+void SpaceShip::regen(float time){
+  float tmp;
+  if (this->shieldCur != this->shieldMax){
+    tmp =  this->shieldCur + this->shieldRegen * time;
+    if( tmp > shieldMax)
       this->shieldCur = this->shieldMax;
     else
-      this->shieldCur += this->shieldRegen * time;
-    if( this->shieldCur > shieldTH)
-      this->shieldActive = true;
-  }
-  if (this->electronicCur == this->electronicMax){}
-  else{
-    if (this->electronicCur + this->electronicRegen * time > electronicMax)
+      this->shieldCur = tmp;
+    this->shieldActive = ( this->shieldActive || this->shieldCur > shieldTH);
+  }
+  if (this->electronicCur != this->electronicMax){
+    tmp = this->electronicCur + this->electronicRegen * time;
+    if ( tmp > electronicMax)
       this->electronicCur = this->electronicMax;
     else
-      this->electronicCur += this->electronicRegen * time;
-  }
-}
-
+      this->electronicCur = tmp;
+  }
+}
Index: branches/playability/src/world_entities/space_ships/space_ship.h
===================================================================
--- branches/playability/src/world_entities/space_ships/space_ship.h	(revision 9956)
+++ branches/playability/src/world_entities/space_ships/space_ship.h	(revision 9957)
@@ -48,15 +48,15 @@
 
     //Functions for GUI
-    virtual int getShieldCur();     //!< returns current shield value
-    virtual int getShieldMax();     //!< returns maximum shield value
+    inline float getShieldCur() { return this->shieldCur; };        //!< returns current shield value
+    inline float getShieldMax() { return this->shieldMax; };        //!< returns maximum shield value
 
-    virtual int getArmorCur();      //!< returns current armor value
-    virtual int getArmorMax();      //!< returns current armor value
+    inline float getArmorCur() { return this->armorCur; };          //!< returns current armor value
+    inline float getArmorMax() { return this->armorMax; };          //!< returns current armor value
 
-    virtual int getElectronicCur(); //!< returns current electronic value
-    virtual int getElectronicMax(); //!< returns current electronic value
+    inline float getElectronicCur() { return this->electronicCur; }; //!< returns current electronic value
+    inline float getElectronicMax() { return this->electronicMax; }; //!< returns current electronic value
 
     //damage handler
-    virtual void damage(int pDamage, int eDamage);  //!< pDamage physical damage, eDamage electronic damage
+    virtual void damage(float pDamage, float eDamage);  //!< pDamage physical damage, eDamage electronic damage
 
   private:
@@ -65,20 +65,20 @@
     void calculateVelocity(float time);
 
-    void regen();  //!< handler for shield and electronic regeneration
+    void regen(float time);  //!< handler for shield and electronic regeneration
 
     //ship atributes
-    int         shieldCur;          //!< current shield
-    int         shieldMax;          //!< maximum shield
+    float       shieldCur;          //!< current shield
+    float       shieldMax;          //!< maximum shield
     float       shieldEnergyShare;  //!< percentage of reactor output
-    int         shieldRegen;        //!< shield regeneration rate
-    int         shieldTH;           //!< shield threshhold for reactivation
+    float       shieldRegen;        //!< shield regeneration rate per tick
+    float       shieldTH;           //!< shield threshhold for reactivation
     bool        shieldActive;       //!< wheather the shield is working
 
-    int         armorCur;           //!< current armor
-    int         armorMax;           //!< maximum armor
+    float       armorCur;           //!< current armor
+    float       armorMax;           //!< maximum armor
 
-    int         electronicCur;      //!< current electronic
-    int         electronicMax;      //!< maximum electronic
-    int         electronicRegen;    //!< electronic regenration rate
+    float       electronicCur;      //!< current electronic
+    float       electronicMax;      //!< maximum electronic
+    float       electronicRegen;    //!< electronic regenration rate per tick
 
     int         engineSpeedCur;     //!< speed output
