Aktive Skills hinzugefügt

Asteroids Linux/Asteroids Linux.vcxproj

@@ -59,6 +59,7 @@
     <ClCompile Include="..\Asteroids\Klient.cpp" />
     <ClCompile Include="..\Asteroids\Karte.cpp" />
     <ClCompile Include="..\Asteroids\Pixel.cpp" />
+    <ClCompile Include="..\Asteroids\Skill.cpp" />
     <ClCompile Include="..\Asteroids\Strukturen.cpp" />
     <ClCompile Include="..\Asteroids\SpielObjekt.cpp" />
     <ClCompile Include="..\Asteroids\Laser.cpp" />
@@ -74,6 +75,7 @@
   <ItemGroup>
     <ClInclude Include="..\Asteroids\Asteroid.h" />
     <ClInclude Include="..\Asteroids\Pixel.h" />
+    <ClInclude Include="..\Asteroids\Skill.h" />
     <ClInclude Include="..\Asteroids\SSDatenbankV.h" />
     <ClInclude Include="..\Asteroids\Editor.h" />
     <ClInclude Include="..\Asteroids\ESEditorV.h" />

Asteroids Linux/Asteroids Linux.vcxproj.filters

@@ -46,6 +46,9 @@
     <Filter Include="Spiel\Asteroid">
       <UniqueIdentifier>{ce5d6af0-1b38-4f8c-8303-65676c647e93}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Spiel\Skill">
+      <UniqueIdentifier>{7e762269-457c-4c5f-84d6-9e2ddc87dec5}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\Asteroids\Editor.cpp">
@@ -99,6 +102,9 @@
     <ClCompile Include="..\Asteroids\Pixel.cpp">
       <Filter>Spiel\Asteroid</Filter>
     </ClCompile>
+    <ClCompile Include="..\Asteroids\Skill.cpp">
+      <Filter>Spiel\Skill</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\Asteroids\SSDatenbankV.h">
@@ -167,5 +173,8 @@
     <ClInclude Include="..\Asteroids\Pixel.h">
       <Filter>Spiel\Asteroid</Filter>
     </ClInclude>
+    <ClInclude Include="..\Asteroids\Skill.h">
+      <Filter>Spiel\Skill</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

Asteroids/Klient.cpp

@@ -100,6 +100,20 @@ void Klient::sendeSkillNachricht( int sNum, char art, int spielZeit )
     delete[] bytes;
 }
 
+void Klient::sendeUseSkillNachricht( int sNum, char id, int spielZeit )
+{
+    if( !klient )
+        return;
+    short len = 10;
+    char *bytes = new char[ len ];
+    *(int *)bytes = spielZeit;
+    *(char *)( bytes + 4 ) = 0x15;
+    *(int *)( bytes + 5 ) = sNum;
+    *(char *)( bytes + 9 ) = id;
+    klient->spielNachricht( len, bytes );
+    delete[] bytes;
+}
+
 void Klient::sendeAsteroid( int id, Vertex pos, Vertex speed, float rot, float rotS, int index, int spielZeit )
 {
     if( !klient )

Asteroids/SSKlient.h

@@ -31,6 +31,7 @@ public:
 	void sendeStart( int spielZeit );
 	void sendeTastaturStatus( int spielerId, TastaturStatus ts, bool aktiv, int spielZeit );
 	void sendeSkillNachricht( int sNum, char art, int spielZeit );
+    void sendeUseSkillNachricht( int sNum, char id, int spielZeit );
     void sendeAsteroid( int id, Vertex pos, Vertex speed, float rot, float rotS, int index, int spielZeit );
 	void sendeSchuss( int id, int sNum, Vertex pos, Vertex speed, double intensity, int spielZeit );
     void sendePixel( int asteroid, int pixelId, int spielZeit );

Asteroids/Skill.cpp

@@ -0,0 +1,229 @@
+#include "Skill.h"
+
+ActiveSkill::ActiveSkill()
+{
+    active = 0;
+    time = 0;
+    maxTime = 0;
+    reloadTimeFactor = 1;
+
+    beschleunigungBonus = 0;
+    reparaturBonus = 0;
+    laserIntensityBonus = 0;
+    laserEffizienzBonus = 0;
+    akkuLeistungBonus = 0;
+    maxEnergieBonus = 0;
+    maxStabilityBonus = 0;
+    laserTempoBonus = 0;
+    wendigkeitBonus = 0;
+    antriebEffizienzBonus = 0;
+    energieSchildBonus = 0;
+    energieSchildEffizienzBonus = 0;
+
+    beschleunigungFactor = 1;
+    reparaturFactor = 1;
+    laserIntensityFactor = 1;
+    laserEffizienzFactor = 1;
+    akkuLeistungFactor = 1;
+    maxEnergieFactor = 1;
+    maxStabilityFactor = 1;
+    laserTempoFactor = 1;
+    wendigkeitFactor = 1;
+    antriebEffizienzFactor = 1;
+    energieSchildFactor = 1;
+    energieSchildEffizienzFactor = 1;
+
+    ref = 1;
+}
+
+ActiveSkill::~ActiveSkill()
+{}
+
+void ActiveSkill::tick( double time )
+{
+    if( active )
+    {
+        if( time < time )
+            active = 0;
+        else
+            time -= time;
+    }
+    if( !active )
+    {
+        time += time * reloadTimeFactor;
+        if( time > maxTime )
+            time = maxTime;
+    }
+}
+
+bool ActiveSkill::isActive() const
+{
+    return active;
+}
+
+void ActiveSkill::activate()
+{
+    active = 1;
+}
+
+void ActiveSkill::reset()
+{
+    time = 0;
+    active = 0;
+}
+
+
+double ActiveSkill::getBeschleunigungBonus()
+{
+    return active ? beschleunigungBonus : 0;
+}
+
+double ActiveSkill::getReparaturBonus()
+{
+    return active ? reparaturBonus : 0;
+}
+
+double ActiveSkill::getLaserIntensityBonus()
+{
+    return active ? laserIntensityBonus : 0;
+}
+
+double ActiveSkill::getLaserEffizienzBonus()
+{
+    return active ? laserEffizienzBonus : 0;
+}
+
+double ActiveSkill::getAkkuLeistungBonus()
+{
+    return active ? akkuLeistungBonus : 0;
+}
+
+double ActiveSkill::getMaxEnergieBonus()
+{
+    return active ? maxEnergieBonus : 0;
+}
+
+double ActiveSkill::getMaxStabilityBonus()
+{
+    return active ? maxStabilityBonus : 0;
+}
+
+double ActiveSkill::getLaserTempoBonus()
+{
+    return active ? laserTempoBonus : 0;
+}
+
+double ActiveSkill::getWendigkeitBonus()
+{
+    return active ? wendigkeitBonus : 0;
+}
+
+double ActiveSkill::getAntriebEffizienzBonus()
+{
+    return active ? antriebEffizienzBonus : 0;
+}
+
+double ActiveSkill::getEnergieSchildBonus()
+{
+    return active ? energieSchildBonus : 0;
+}
+
+double ActiveSkill::getEnergieSchildEffizienzBonus()
+{
+    return active ? energieSchildEffizienzBonus : 0;
+}
+
+
+double ActiveSkill::getBeschleunigungFactor()
+{
+    return active ? beschleunigungFactor : 1;
+}
+
+double ActiveSkill::getReparaturFactor()
+{
+    return active ? reparaturFactor : 1;
+}
+
+double ActiveSkill::getLaserIntensityFactor()
+{
+    return active ? laserIntensityFactor : 1;
+}
+
+double ActiveSkill::getLaserEffizienzFactor()
+{
+    return active ? laserEffizienzFactor : 1;
+}
+
+double ActiveSkill::getAkkuLeistungFactor()
+{
+    return active ? akkuLeistungFactor : 1;
+}
+
+double ActiveSkill::getMaxEnergieFactor()
+{
+    return active ? maxEnergieFactor : 1;
+}
+
+double ActiveSkill::getMaxStabilityFactor()
+{
+    return active ? maxStabilityFactor : 1;
+}
+
+double ActiveSkill::getLaserTempoFactor()
+{
+    return active ? laserTempoFactor : 1;
+}
+
+double ActiveSkill::getWendigkeitFactor()
+{
+    return active ? wendigkeitFactor : 1;
+}
+
+double ActiveSkill::getAntriebEffizienzFactor()
+{
+    return active ? antriebEffizienzFactor : 1;
+}
+
+double ActiveSkill::getEnergieSchildFactor()
+{
+    return active ? energieSchildFactor : 1;
+}
+
+double ActiveSkill::getEnergieSchildEffizienzFactor()
+{
+    return active ? energieSchildEffizienzFactor : 1;
+}
+
+ActiveSkill *ActiveSkill::getThis()
+{
+    ref++;
+    return this;
+}
+
+ActiveSkill *ActiveSkill::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+SpeedBoost::SpeedBoost()
+    : ActiveSkill()
+{
+    beschleunigungFactor = 2;
+    wendigkeitFactor = 2;
+    antriebEffizienzFactor = 2;
+    reloadTimeFactor = 0.02;
+    maxTime = 2;
+}
+
+
+ShieldBoost::ShieldBoost()
+    : ActiveSkill()
+{
+    energieSchildFactor = 2;
+    energieSchildEffizienzFactor = 2;
+    reloadTimeFactor = 0.01;
+    maxTime = 1;
+}

Asteroids/Skill.h

@@ -0,0 +1,88 @@
+#pragma once
+
+class ActiveSkill
+{
+protected:
+    bool active;
+    double time;
+    double maxTime;
+    int ref;
+    double reloadTimeFactor;
+
+    // skill bonus added when active
+    double beschleunigungBonus;
+    double reparaturBonus;
+    double laserIntensityBonus;
+    double laserEffizienzBonus;
+    double akkuLeistungBonus;
+    double maxEnergieBonus;
+    double maxStabilityBonus;
+    double laserTempoBonus;
+    double wendigkeitBonus;
+    double antriebEffizienzBonus;
+    double energieSchildBonus;
+    double energieSchildEffizienzBonus;
+
+    // skil multiplier when active
+    double beschleunigungFactor;
+    double reparaturFactor;
+    double laserIntensityFactor;
+    double laserEffizienzFactor;
+    double akkuLeistungFactor;
+    double maxEnergieFactor;
+    double maxStabilityFactor;
+    double laserTempoFactor;
+    double wendigkeitFactor;
+    double antriebEffizienzFactor;
+    double energieSchildFactor;
+    double energieSchildEffizienzFactor;
+
+public:
+    ActiveSkill();
+    ~ActiveSkill();
+    void tick( double time );
+    bool isActive() const;
+    void activate();
+    void reset();
+
+    double getBeschleunigungBonus();
+    double getReparaturBonus();
+    double getLaserIntensityBonus();
+    double getLaserEffizienzBonus();
+    double getAkkuLeistungBonus();
+    double getMaxEnergieBonus();
+    double getMaxStabilityBonus();
+    double getLaserTempoBonus();
+    double getWendigkeitBonus();
+    double getAntriebEffizienzBonus();
+    double getEnergieSchildBonus();
+    double getEnergieSchildEffizienzBonus();
+
+    double getBeschleunigungFactor();
+    double getReparaturFactor();
+    double getLaserIntensityFactor();
+    double getLaserEffizienzFactor();
+    double getAkkuLeistungFactor();
+    double getMaxEnergieFactor();
+    double getMaxStabilityFactor();
+    double getLaserTempoFactor();
+    double getWendigkeitFactor();
+    double getAntriebEffizienzFactor();
+    double getEnergieSchildFactor();
+    double getEnergieSchildEffizienzFactor();
+
+    ActiveSkill *getThis();
+    ActiveSkill *release();
+};
+
+class SpeedBoost : public ActiveSkill
+{
+public:
+    SpeedBoost();
+};
+
+class ShieldBoost : public ActiveSkill
+{
+public:
+    ShieldBoost();
+};

Asteroids/Spiel.cpp

@@ -87,7 +87,7 @@ int Spiel::getTeamVonSpieler( int sNum )
 }
 
 // nicht constant
-void Spiel::setPSQLK( SSDatenbankV *psqldb )
+void Spiel::setPSQLK( SSDatenbankV * psqldb )
 {
     if( this->psqldb )
         this->psqldb->release();
@@ -113,18 +113,18 @@ void Spiel::setTempPfad( char *pfad )
     mapPfad += "/";
 }
 
-void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
+void Spiel::setAccounts( int anzahl, Array< int > * zAccounts )
 {
     this->zAccounts = zAccounts->getThis();
     spielerAnzahl = anzahl;
 }
 
-void Spiel::setKlients( int anzahl, RCArray< SSKlientV > *zKlients )
+void Spiel::setKlients( int anzahl, RCArray< SSKlientV > * zKlients )
 {
     this->zKlients = zKlients->getThis();
 }
 
-void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
+void Spiel::setSpielerNummern( int anzahl, Array< int > * spielerNummern )
 {
     if( !sts )
     {
@@ -194,7 +194,7 @@ void Spiel::klientOffline( int accountId )
     }
 }
 
-void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
+void Spiel::klientOnline( int accountId, SSKlientV * zKlient )
 {
     for( int i = 0; i < spielerAnzahl; i++ )
     {
@@ -282,7 +282,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         if( 1 )
         {
             bytes++;
-            char art = *bytes;
+            char id = *bytes;
             len--;
             for( int i = 0; i < spielerAnzahl; i++ )
             {
@@ -291,16 +291,12 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                 {
                     if( !tmp->istAmLeben() )
                         break;
-                    if( !tmp->setSkill( art ) )
-                    {
-                        saveMSG = 0;
-                        break;
-                    }
+                    tmp->useSkill( id );
                     for( int j = 0; j < spielerAnzahl; j++ )
                     {
                         Spieler *s = spieler->z( j );
                         if( s && s->zKlient() )
-                            s->zKlient()->sendeSkillNachricht( tmp->getSpielerNummer(), art, spielZeit );
+                            s->zKlient()->sendeSkillNachricht( tmp->getSpielerNummer(), id, spielZeit );
                     }
                     break;
                 }
@@ -308,6 +304,29 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
             break;
         }
         break;
+    case 0xA: // Use active skill
+    {
+        bytes++;
+        char id = *bytes;
+        len--;
+        for( int i = 0; i < spielerAnzahl; i++ )
+        {
+            Spieler *tmp = spieler->z( i );
+            if( tmp && tmp->getAccountId() == accountId )
+            {
+                if( !tmp->istAmLeben() )
+                    break;
+                for( int j = 0; j < spielerAnzahl; j++ )
+                {
+                    Spieler *s = spieler->z( j );
+                    if( s && s->zKlient() )
+                        s->zKlient()->sendeUseSkillNachricht( tmp->getSpielerNummer(), id, spielZeit );
+                }
+                break;
+            }
+        }
+        break;
+    }
     default:
         saveMSG = 0;
     }
@@ -329,9 +348,9 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                 break;
             }
         }
-        log->schreibe( (char*)&spielerNum, 4 );
+        log->schreibe( (char *)& spielerNum, 4 );
         short l = (short)msgLen;
-        log->schreibe( (char*)&l, 2 );
+        log->schreibe( (char *)& l, 2 );
         log->schreibe( msgBeg, l );
     }
     LeaveCriticalSection( &cs );
@@ -432,7 +451,7 @@ void Spiel::tick( double zeit )
                     Vertex pos;
                     __int64 seed = randG.getSeed();
                     double intens = tmp->getIntensity() * ( ( tmp->getSpeed() - a->getSpeed() ).getLength() / 200 );
-                    Asteroid *b = a->istTreffer( tmp, &randG, asteroidId, pos );
+                    Asteroid * b = a->istTreffer( tmp, &randG, asteroidId, pos );
                     if( b )
                     {
                         float erf = 0;
@@ -457,7 +476,7 @@ void Spiel::tick( double zeit )
                         shots->remove( i );
                         if( b->getMasse() > intens * 50 )
                         {
-                            asteroids->add( (Asteroid*)b->getThis() );
+                            asteroids->add( (Asteroid *)b->getThis() );
                             welt->addObject( b );
                         }
                         else
@@ -595,24 +614,26 @@ void Spiel::run()
     time_t t;
     time( &t );
     srand( (unsigned int)t );
-    log->schreibe( (char*)&spielerAnzahl, 4 );
+    log->schreibe( (char *)& spielerAnzahl, 4 );
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         Spieler *tmp = spieler->z( i );
         if( tmp && tmp->zKlient() )
         {
+            tmp->addSkill( new ShieldBoost() );
+            tmp->addSkill( new SpeedBoost() );
             tmp->zKlient()->sendeInit( spieler, -1 );
-            log->schreibe( (char*)&i, 4 );
+            log->schreibe( (char *)& i, 4 );
             int sNum = tmp->getSpielerNummer();
-            log->schreibe( (char*)&sNum, 4 );
+            log->schreibe( (char *)& sNum, 4 );
             tmp->zKlient()->sendeSpielerNummer( sNum, -1 );
             int team = tmp->zTeam()->id;
-            log->schreibe( (char*)&team, 4 );
+            log->schreibe( (char *)& team, 4 );
             int farbe = tmp->getSpielerFarbe();
-            log->schreibe( (char*)&farbe, 4 );
+            log->schreibe( (char *)& farbe, 4 );
             farbe = tmp->zTeam()->farbe;
-            log->schreibe( (char*)&farbe, 4 );
-            Text *name = psqldb->getAccountRufName( tmp->getAccountId() );
+            log->schreibe( (char *)& farbe, 4 );
+            Text * name = psqldb->getAccountRufName( tmp->getAccountId() );
             char len = (char)( name ? name->getLength() : 0 );
             log->schreibe( &len, 1 );
             if( len )
@@ -627,9 +648,9 @@ void Spiel::run()
         }
     }
     __int64 randSeed = randG.getSeed();
-    log->schreibe( (char*)&randSeed, 8 );
+    log->schreibe( (char *)& randSeed, 8 );
     Array< char > spielerStatus;
-    ZeitMesser *zeit = new ZeitMesser();
+    ZeitMesser * zeit = new ZeitMesser();
     zeit->messungStart();
     isRunning = 1;
     ende = 0;

Asteroids/Spieler.cpp

@@ -11,6 +11,7 @@
 Spieler::Spieler( SpielerStr *zStr )
     : Model2DObject()
 {
+    activeSkills = new RCArray< ActiveSkill >();
     accountId = 0;
     sNum = zStr->id;
     farbe = 0;
@@ -66,9 +67,165 @@ Spieler::~Spieler()
         team->release();
     if( klient )
         klient->release();
+    activeSkills->release();
+}
+
+double Spieler::calculateBeschleunigung()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getBeschleunigungFactor();
+        bonus += s->getBeschleunigungBonus();
+    }
+    return ( beschleunigung + team->beschleunigung ) * factor + bonus;
+}
+
+double Spieler::calculateReparatur()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getReparaturFactor();
+        bonus += s->getReparaturBonus();
+    }
+    return ( reparatur + team->reparatur ) * factor + bonus;
+}
+
+double Spieler::calculateLaserIntensity()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getLaserIntensityFactor();
+        bonus += s->getLaserIntensityBonus();
+    }
+    return ( laserIntensity + team->laserIntensity ) * factor + bonus;
+}
+
+double Spieler::calculateLaserEffizienz()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getLaserEffizienzFactor();
+        bonus += s->getLaserEffizienzBonus();
+    }
+    return ( laserEffizienz + team->laserEffizienz ) * factor + bonus;
+}
+
+double Spieler::calculateAkkuLeistung()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getAkkuLeistungFactor();
+        bonus += s->getAkkuLeistungBonus();
+    }
+    return ( akkuLeistung + team->akkuLeistung ) * factor + bonus;
+}
+
+double Spieler::calculateMaxEnergie()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getMaxEnergieFactor();
+        bonus += s->getMaxEnergieBonus();
+    }
+    return ( maxEnergie + team->maxEnergie ) * factor + bonus;
+}
+
+double Spieler::calculateMaxStability()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getMaxStabilityFactor();
+        bonus += s->getMaxStabilityBonus();
+    }
+    return ( maxStability + team->maxStability ) * factor + bonus;
+}
+
+double Spieler::calculateLaserTempo()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getLaserTempoFactor();
+        bonus += s->getLaserTempoBonus();
+    }
+    return ( laserTempo + team->laserTempo ) * factor + bonus;
+}
+
+double Spieler::calculateWendigkeit()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getWendigkeitFactor();
+        bonus += s->getWendigkeitBonus();
+    }
+    return ( wendigkeit + team->wendigkeit ) * factor + bonus;
+}
+
+double Spieler::calculateAntriebEffizienz()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getAntriebEffizienzFactor();
+        bonus += s->getAntriebEffizienzBonus();
+    }
+    return ( antriebEffizienz + team->antriebEffizienz ) * factor + bonus;
+}
+
+double Spieler::calculateEnergieSchild()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getEnergieSchildFactor();
+        bonus += s->getEnergieSchildBonus();
+    }
+    return ( energieSchild + team->energieSchild ) * factor + bonus;
+}
+
+double Spieler::calculateEnergieSchildEffizienz()
+{
+    double factor = 1;
+    double bonus = 0;
+    for( auto s = activeSkills->getIterator(); s; s++ )
+    {
+        factor *= s->getEnergieSchildEffizienzFactor();
+        bonus += s->getEnergieSchildEffizienzBonus();
+    }
+    return ( energieSchildEffizienz + team->energieSchildEffizienz ) * factor + bonus;
 }
 
 // nicht constant
+void Spieler::addSkill( ActiveSkill *skill )
+{
+    activeSkills->add( skill );
+}
+
+void Spieler::useSkill( int id )
+{
+    if( activeSkills->z( id ) )
+        activeSkills->z( id )->activate();
+}
+
 void Spieler::offline()
 {
     klient->offline();
@@ -185,6 +342,8 @@ bool Spieler::tick( const WeltInfo& info, double zeit )
     }
     if( amLeben )
     {
+        for( auto s = activeSkills->getIterator(); s; s++ )
+            s->tick( zeit );
         schussAbk -= zeit;
         energieAbk -= zeit;
         if( schussAbk < 0 )
@@ -196,52 +355,52 @@ bool Spieler::tick( const WeltInfo& info, double zeit )
             repAbk = 0;
         if( tastatur[ T_GAS ] )
         {
-            double treibstoff = 0.5 * ( ( beschleunigung + team->beschleunigung ) / 15 )
-                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            double treibstoff = 0.5 * ( calculateBeschleunigung() / 15 )
+                * zeit * ( 100 / calculateAntriebEffizienz() );
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
                 factor = (float)( energie / treibstoff );
             if( factor > 0 )
-                impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)zeit * (float)( beschleunigung + team->beschleunigung ) * factor );
+                impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)zeit * (float)calculateBeschleunigung() * factor );
             energie -= treibstoff * factor;
         }
         if( tastatur[ T_ROT_R ] )
         {
-            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 15 )
-                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
+                * zeit * ( 100 / calculateAntriebEffizienz() );
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
                 factor = (float)( energie / treibstoff );
             if( factor > 0 )
-                impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)zeit * (float)( wendigkeit + team->wendigkeit ) * factor );
+                impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)zeit * (float)calculateWendigkeit() * factor );
             energie -= treibstoff * factor;
         }
         if( tastatur[ T_ROT_L ] )
         {
-            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 15 )
-                * zeit * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
+                * zeit * ( 100 / calculateAntriebEffizienz() );
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
                 factor = (float)( energie / treibstoff );
             if( factor > 0 )
-                impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)zeit * (float)( wendigkeit + team->wendigkeit ) * factor );
+                impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)zeit * (float)calculateWendigkeit() * factor );
             energie -= treibstoff * factor;
         }
         Model2DObject::tick( info, zeit );
         if( !energieAbk )
         {
-            energie += ( akkuLeistung + team->akkuLeistung ) * zeit;
-            if( energie > ( maxEnergie + team->maxEnergie ) )
-                energie = ( maxEnergie + team->maxEnergie );
+            energie += calculateAkkuLeistung() * zeit;
+            if( energie > calculateMaxEnergie() )
+                energie = calculateMaxEnergie();
         }
         if( !repAbk )
         {
-            stability += ( reparatur + team->reparatur ) * zeit;
-            if( stability > ( maxStability + team->maxStability ) )
-                stability = ( maxStability + team->maxStability );
+            stability += calculateReparatur() * zeit;
+            if( stability > calculateMaxStability() )
+                stability = calculateMaxStability();
         }
         zeitAmLeben += zeit;
     }
@@ -329,9 +488,9 @@ Laser *Spieler::getLaser( int sId )
 {
     if( !amLeben || !tastatur[ T_FEUER ] || schussAbk || !team )
         return 0;
-    double kosten = ( ( laserIntensity + team->laserIntensity ) / 2 +
-        ( laserTempo + team->laserTempo ) / 9 ) *
-                      ( 1 / ( ( laserEffizienz + team->laserEffizienz ) / 25 ) );
+    double kosten = ( calculateLaserIntensity() / 2 +
+        calculateLaserTempo() / 9 ) *
+                      ( 1 / ( calculateLaserEffizienz() / 25 ) );
     if( kosten < 1 )
         kosten = 1;
     if( kosten > energie )
@@ -340,20 +499,20 @@ Laser *Spieler::getLaser( int sId )
     schussAbk = 1;
     energieAbk = 1.5;
     shots++;
-    Vertex sSpeed = ( Vertex( lowPrecisionCos( rotation ), lowPrecisionSin( rotation ) ) * (float)( laserTempo + team->laserTempo ) );
+    Vertex sSpeed = ( Vertex( lowPrecisionCos( rotation ), lowPrecisionSin( rotation ) ) * (float)calculateLaserTempo() );
     sSpeed += speed;
-    return new Laser( sId, getPosition(), sSpeed, sNum, laserIntensity + team->laserIntensity );
+    return new Laser( sId, getPosition(), sSpeed, sNum, calculateLaserIntensity() );
 }
 
 bool Spieler::nimmSchaden( double &intensity, int sLevel )
 {
     double originalIntens = intensity;
-    double schieldVal = intensity - intensity / ( energieSchild + team->energieSchild );
-    double schieldEVal = schieldVal / ( ( energieSchildEffizienz + team->energieSchildEffizienz ) / 100 );
+    double schieldVal = intensity - intensity / calculateEnergieSchild();
+    double schieldEVal = schieldVal / ( calculateEnergieSchildEffizienz() / 100 );
     if( schieldEVal > energie )
     {
         schieldEVal = energie;
-        schieldVal = schieldEVal * ( ( energieSchildEffizienz + team->energieSchildEffizienz ) / 100 );
+        schieldVal = schieldEVal * ( calculateEnergieSchildEffizienz() / 100 );
     }
     intensity -= schieldVal;
     energie -= schieldEVal;
@@ -405,11 +564,13 @@ void Spieler::addTreffer( float intensity, int sLevel )
 
 void Spieler::wiederbeleben()
 {
+    for( auto s = activeSkills->getIterator(); s; s++ )
+        s->reset();
     needWiederbelebung = 0;
     setPosition( startPos );
     reinkAbk = maxReinkAbk * 2;
-    energie = maxEnergie + team->maxEnergie;
-    stability = maxStability + team->maxStability;
+    energie = calculateMaxEnergie();
+    stability = calculateMaxStability();
     schussAbk = 0;
     energieAbk = 0;
     repAbk = 0;

Asteroids/Spieler.h

@@ -4,6 +4,7 @@
 #include <Bild.h>
 #include <Model2D.h>
 #include "Strukturen.h"
+#include "Skill.h"
 
 class Team;
 class Laser;
@@ -33,6 +34,7 @@ private:
     Vertex stM;
     Vertex kM;
     WeltInfo wInfo;
+    RCArray< ActiveSkill > *activeSkills;
 
     int level;
 	int accountId;
@@ -80,12 +82,27 @@ private:
     float nextSkillEp;
     bool needWiederbelebung;
 
+    double calculateBeschleunigung();
+    double calculateReparatur();
+    double calculateLaserIntensity();
+    double calculateLaserEffizienz();
+    double calculateAkkuLeistung();
+    double calculateMaxEnergie();
+    double calculateMaxStability();
+    double calculateLaserTempo();
+    double calculateWendigkeit();
+    double calculateAntriebEffizienz();
+    double calculateEnergieSchild();
+    double calculateEnergieSchildEffizienz();
+
 public:
 	// Konstruktor
 	Spieler( SpielerStr *zStr );
 	// Destruktor
 	~Spieler();
 	// nicht constant
+    void addSkill( ActiveSkill *skill );
+    void useSkill( int id );
 	void offline();
 	void online( SSKlientV *zKlient );
 	void setModelData( Model2DData *data );