Objekte zum Spiel hinzugefügt

Asteroids/Spiel/Karte/Karte.cpp

@@ -149,27 +149,35 @@ Team *Karte::createTeam( int tNum ) const
 
 SpielObjekt *Karte::createObjekt( int oNum, Schrift *zSchrift ) const
 {
-    if( oNum < 0 || oNum > objekte->getEintragAnzahl() )
+    if( oNum <= 0 )
         return 0;
     ObjektStr *obj = 0;
     for( auto o = objekte->getIterator(); o; o++ )
     {
-        if( o->id == oNum + 1 )
+        if( o->id == oNum )
             obj = o;
     }
     if( !obj )
         return 0;
     SpielObjekt *ret = new SpielObjekt( obj, zSchrift );
+    Bild *bild = 0;
     for( auto i = ressources->getIterator(); i && i._; i++ )
     {
         if( i->getId() == obj->m2d )
             ret->setModel( i->zReccourceM2()->getThis() );
         if( i->getId() == obj->bild )
-            ret->setTextur( i->zReccourceTxt()->getThis() );
+            bild = i->zReccourceTxt()->getThis();
     }
+    if( bild )
+        ret->setTextur( bild );
     return ret;
 }
 
+Iterator< ObjektStr * > Karte::getObjekte() const
+{
+    return objekte->getIterator();
+}
+
 int Karte::getMaxTeamAnzahl() const
 {
     return teamAnzahl;
@@ -180,7 +188,7 @@ int Karte::getMaxSpielerAnzahl() const
     return spielerAnzahl;
 }
 
-int Karte::getZeichnungAnzahl() const
+int Karte::getObjektAnzahl() const
 {
     return objekte->getEintragAnzahl();
 }

Asteroids/Spiel/Karte/Karte.h

@@ -40,9 +40,10 @@ public:
 	Spieler *createSpieler( int sNum, Schrift *zSchrift, KSGClient::InformationServerClient *zInfoK, Animation2DData *zFStart, Animation2DData *zFBurn ) const;
 	Team *createTeam( int tNum ) const;
 	SpielObjekt *createObjekt( int oNum, Schrift *zSchrift ) const;
+    Iterator< ObjektStr * > getObjekte() const;
 	int getMaxTeamAnzahl() const;
 	int getMaxSpielerAnzahl() const;
-	int getZeichnungAnzahl() const;
+	int getObjektAnzahl() const;
 	int getTeamNummer( int sNum ) const;
 	// Reference Counting
 	Karte *getThis();

Asteroids/Spiel/Objekt/SpielObjekt.cpp

@@ -8,99 +8,246 @@
 SpielObjekt::SpielObjekt( ObjektStr *zStr, Schrift *zSchrift )
     : Model2DObject()
 {
-	id = zStr->id;
-	style = zStr->style;
-	stabilität = zStr->maxStabilität;
-	energie = zStr->maxEnergie;
-	maxStabilität = zStr->maxStabilität;
-	maxEnergie = zStr->maxEnergie;
-	energieRadius = zStr->energieRadius;
-	reparatur = zStr->reparatur;
-	akkuLeistung = zStr->akkuLeistung;
-	team = 0;
-	nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
-						  TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
+    id = zStr->id;
+    style = zStr->style;
+    stabilität = zStr->maxStabilität;
+    energie = zStr->maxEnergie;
+    maxStabilität = zStr->maxStabilität;
+    maxEnergie = zStr->maxEnergie;
+    energieRadius = zStr->energieRadius;
+    reparatur = zStr->reparatur;
+    akkuLeistung = zStr->akkuLeistung;
+    zteam = 0;
+    amLeben = 1;
+    level = 1;
+    ep = 0;
+    nextSkillEp = 80;
+    setCollision( ( style | 0x4 ) == style );
+    deadPlayer = 0;
+    nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
+                          TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
+    save();
 }
 
 // Destruktor
 SpielObjekt::~SpielObjekt()
 {
-	if( team )
-		team->release();
-	nText->release();
+    nText->release();
+    if( deadPlayer )
+        deadPlayer->release();
 }
 
 // nicht constant
-void SpielObjekt::setTextur( Bild *textur )
+void SpielObjekt::save()
+{
+    last.rSpeed = rSpeed;
+    last.pos = position;
+    last.speed = speed;
+    last.rotation = rotation;
+    last.amLeben = amLeben;
+    last.akkuAbk = akkuAbk;
+    last.repAbk = repAbk;
+    last.energie = energie;
+    last.stabilität = stabilität;
+    last.reparatur = reparatur;
+    last.akkuLeistung = akkuLeistung;
+    last.maxEnergie = maxEnergie;
+    last.maxStabilität = maxStabilität;
+    last.level = level;
+}
+
+void SpielObjekt::load()
+{
+    rSpeed = last.rSpeed;
+    position = last.pos;
+    speed = last.speed;
+    rotation = last.rotation;
+    amLeben = last.amLeben;
+    akkuAbk = last.akkuAbk;
+    repAbk = last.repAbk;
+    energie = last.energie;
+    stabilität = last.stabilität;
+    reparatur = last.reparatur;
+    akkuLeistung = last.akkuLeistung;
+    maxEnergie = last.maxEnergie;
+    maxStabilität = last.maxStabilität;
+    level = last.level;
+}
+
+void SpielObjekt::setTextur( Bild * textur )
 {
     Textur2D *t = new Textur2D();
     t->setTexturZ( textur );
     __super::setTextur( t );
 }
 
-void SpielObjekt::setTeam( Team *team )
+void SpielObjekt::setTeam( Team * team )
 {
-	if( this->team )
-		this->team->release();
-	this->team = team;
+    this->zteam = team;
+    nText->setHintergrundFarbe( 0xA0000000 | ( zteam->farbe & 0x00FFFFFF ) );
+    nText->setRahmenFarbe( zteam->farbe );
 }
 
-bool SpielObjekt::tick( const WeltInfo &info, double zeit )
-{
-	repAbk -= zeit;
-	if( repAbk < 0 )
-		repAbk = 0;
-	akkuAbk -= zeit;
-	if( akkuAbk < 0 )
-		akkuAbk = 0;
-	if( !repAbk )
-	{
-		stabilität += reparatur * zeit;
-		if( stabilität > maxStabilität )
-			stabilität = maxStabilität;
-	}
-	if( !akkuAbk )
-	{
-		if( !team )
-		{
-			energie -= akkuLeistung * zeit;
-			if( energie < 0 )
-				energie = 0;
-		}
-		else
-		{
-			energie += akkuLeistung * zeit;
-			if( energie > maxEnergie )
-				energie = maxEnergie;
-		}
-	}
-    __super::tick( info, zeit );
-    return 1;
+bool SpielObjekt::tick( const WeltInfo & info, double zeit )
+{
+    if( !amLeben )
+        return 0;
+    repAbk -= zeit;
+    if( repAbk < 0 )
+        repAbk = 0;
+    akkuAbk -= zeit;
+    if( akkuAbk < 0 )
+        akkuAbk = 0;
+    if( !repAbk )
+    {
+        stabilität += reparatur * zeit;
+        if( stabilität > maxStabilität )
+            stabilität = maxStabilität;
+    }
+    if( !akkuAbk )
+    {
+        if( !zteam )
+        {
+            energie -= akkuLeistung * zeit;
+            if( energie < 0 )
+                energie = 0;
+        }
+        else
+        {
+            energie += akkuLeistung * zeit;
+            if( energie > maxEnergie )
+                energie = maxEnergie;
+        }
+    }
+    if( ( style | 0x2 ) != style )
+    {
+        speed.x = 0;
+        speed.y = 0;
+        rSpeed = 0;
+    }
+    return Model2DObject::tick( info, zeit );
 }
 
-void SpielObjekt::render( Mat3<float> &kamMat, Bild &zRObj, const char *kamName )
+void SpielObjekt::render( Mat3<float> & kamMat, Bild & zRObj, const char *kamName )
 {
+    if( !amLeben )
+        return;
+    Model2DObject::render( kamMat, zRObj, kamName );
     if( Text( "minimap" ).istGleich( kamName ) )
         return;
-	nText->setPosition( (Punkt)( kamMat * (getPosition() - Punkt( 76, (int)( zModel()->maxP.y * getSize() ) + 30 ) ) ) );
-	nText->render( zRObj );
-	int teamF = team ? team->farbe : 0;
-	double teamStab = team ? team->maxStabilität : 0;
-	double teamEner = team ? team->maxEnergie : 0;
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, teamF );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, teamF );
-	int l = (int)( stabilität * 100 / ( maxStabilität + teamStab ) * 1.5 + 0.5 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
-	int e = (int)( energie * 100 / ( maxEnergie + teamEner ) * 1.5 + 0.5 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFFFFFF00 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFFFFFF00 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFFFFFF00 );
+    nText->setPosition( (Punkt)( kamMat * ( getPosition() - Punkt( 76, (int)( zModel()->maxP.y * getSize() ) + 30 ) ) ) );
+    nText->setText( Text( " (" ) + level + ")" );
+    nText->render( zRObj );
+    int teamF = zteam ? zteam->farbe : 0;
+    double teamStab = zteam ? zteam->maxStabilität : 0;
+    double teamEner = zteam ? zteam->maxEnergie : 0;
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, teamF );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, teamF );
+    int l = (int)( stabilität * 100 / ( maxStabilität + teamStab ) * 1.5 + 0.5 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
+    int e = (int)( energie * 100 / ( maxEnergie + teamEner ) * 1.5 + 0.5 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFFFFFF00 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFFFFFF00 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFFFFFF00 );
+}
+
+void SpielObjekt::nimmSchaden( double &intensity, int sLevel )
+{
+    if( ( style | 0x1 ) != style )
+    {
+        intensity = 0;
+        return;
+    }
+    double originalIntens = intensity;
+    /*double schieldVal = intensity - intensity / calculateEnergieSchild();
+    double schieldEVal = schieldVal / ( calculateEnergieSchildEffizienz() / 100 );
+    if( schieldEVal > energie )
+    {
+        schieldEVal = energie;
+        schieldVal = schieldEVal * ( calculateEnergieSchildEffizienz() / 100 );
+    }
+    intensity -= schieldVal;
+    energie -= schieldEVal;*/
+    stabilität -= intensity;
+    akkuAbk = 1.5;
+    repAbk = 2;
+    if( stabilität > 0 && doesShotAddEp() )
+    {
+        float levelFactor = (float)sLevel / (float)level;
+        addEp( ( (float)originalIntens / 20 ) * levelFactor );
+    }
+}
+
+void SpielObjekt::addEp( float ep )
+{
+    this->ep += ep;
+    while( this->ep >= nextSkillEp )
+    {
+        level++;
+        this->ep -= nextSkillEp;
+        nextSkillEp *= 1.025f;
+    }
+}
+
+void SpielObjekt::calcDeadPlayerObject( Laser * zSchuss )
+{
+    Vertex hp;
+    Polygon2D a;
+    Polygon2D b;
+    Punkt pa;
+    Punkt pb;
+    if( calcHitPoint( zSchuss->getPosition() - zSchuss->getSpeed(), zSchuss->getSpeed(), hp ) )
+    {
+        zModel()->split( getObjectPos( hp ), getObjectDir( zSchuss->getSpeed() ) * 0.1f, "ship", a, b, pa, pb, []()
+        {
+            return rand() / (double)RAND_MAX;
+        } );
+        hp = ( hp * getSize() ).rotation( getDrehung() ) + getPosition();
+        pa = pa.rotation( getDrehung() ) + getPosition();
+        pb = pb.rotation( getDrehung() ) + getPosition();
+        Array< Polygon2D > *npaA = new Array< Polygon2D >();
+        npaA->add( a );
+        Model2DData *npdA = new Model2DData();
+        npdA->erstelleModell( npaA );
+        Array< Polygon2D > *npaB = new Array< Polygon2D >();
+        npaB->add( b );
+        Model2DData *npdB = new Model2DData();
+        npdB->erstelleModell( npaB );
+        if( deadPlayer )
+            deadPlayer->release();
+        deadPlayer = new DeadPlayer( npdA, npdB, pa, pb, getSpeed() * ( rand() / (float)RAND_MAX ), getSpeed() * ( rand() / (float)RAND_MAX ), getDrehung(), getDrehung(), getDrehungSpeed() * ( rand() / (float)RAND_MAX ), getDrehungSpeed() * ( rand() / (float)RAND_MAX ), zTextur( "ship" ) );
+    }
+}
+
+DeadPlayer * SpielObjekt::sterben()
+{
+    amLeben = 0;
+    setCollision( 0 );
+    stabilität = 0;
+    return deadPlayer ? (DeadPlayer *)deadPlayer->getThis() : 0;
 }
 
 // constant
 Team *SpielObjekt::zTeam() const
 {
-	return team;
+    if( ( style | 0x10 ) == style )
+        return 0;
+    return zteam;
+}
+
+bool SpielObjekt::doesShotAddEp() const
+{
+    return ( style | 0x20 ) == style;;
+}
+
+int SpielObjekt::getLevel() const
+{
+    return level;
+}
+
+int SpielObjekt::getObjektId() const
+{
+    return id;
 }

Asteroids/Spiel/Objekt/SpielObjekt.h

@@ -7,25 +7,49 @@
 #include "../Karte/Strukturen.h"
 #include <TextFeld.h>
 #include <Welt2D.h>
+#include "../Schuss/Laser.h"
+#include "../Spieler/DeadPlayer.h"
 
 using namespace Framework;
 
 class SpielObjekt : public Model2DObject
 {
 private:
+    struct ObjektDataSave
+    {
+        float rSpeed;
+        Vertex pos;
+        Vertex speed;
+        float rotation;
+        bool amLeben;
+        double akkuAbk;
+        double repAbk;
+        double energie;
+        double stabilität;
+        double reparatur;
+        double akkuLeistung;
+        double maxEnergie;
+        double maxStabilität;
+        int level;
+    } last;
 	int id;
 	int style;
 	double stabilität;
 	double energie;
-	int maxStabilität;
-	int maxEnergie;
+    double maxStabilität;
+    double maxEnergie;
 	int energieRadius;
 	double reparatur;
 	double akkuLeistung;
 	double repAbk;
 	double akkuAbk;
-	Team *team;
+    bool amLeben;
+    int level;
+    float ep;
+    float nextSkillEp;
+	Team *zteam;
 	TextFeld *nText;
+    DeadPlayer *deadPlayer;
 
 public:
 	// Konstruktor
@@ -34,11 +58,20 @@ public:
 	~SpielObjekt();
 	// nicht constant
 	void setTextur( Bild *textur );
-	void setTeam( Team *team );
+	void setTeam( Team *zTeam );
 	bool tick( const WeltInfo &info, double zeit ) override;
 	void render( Mat3<float> &kamMat, Bild &zRObj, const char *kamName ) override;
+    void nimmSchaden( double &intensity, int sLevel );
+    void addEp( float ep );
+    DeadPlayer *sterben();
+    void calcDeadPlayerObject( Laser *zSchuss );
+    void save();
+    void load();
 	// constant
 	Team *zTeam() const;
+    bool doesShotAddEp() const;
+    int getLevel() const;
+    int getObjektId() const;
 };
 
 #endif

Asteroids/Spiel/SpielKlasse.cpp

@@ -141,6 +141,8 @@ void SpielKlasse::load()
     spielZeit = last.spielZeit;
     for( auto i = spieler->getIterator(); i; i++ )
         i->load();
+    for( auto i = objekte->getIterator(); i; i++ )
+        i->load();
     for( auto i = schüsse->getIterator(); i; i++ )
         i->load();
     for( auto i = asteroids->getIterator(); i; i++ )
@@ -156,6 +158,8 @@ void SpielKlasse::save()
     last.spielZeit = spielZeit;
     for( auto i = spieler->getIterator(); i; i++ )
         i->save();
+    for( auto i = objekte->getIterator(); i; i++ )
+        i->save();
     for( auto i = schüsse->getIterator(); i; i++ )
         i->save();
     for( auto i = asteroids->getIterator(); i; i++ )
@@ -298,11 +302,12 @@ void SpielKlasse::ladeDaten()
     flammenStart->release();
     flammenBurn->release();
     spielKlient->setLadenProzent( 75 );
-    for( int i = 0; i < map->getZeichnungAnzahl(); i++ )
+    for( auto o = map->getObjekte(); o; o++ )
     {
-        SpielObjekt *obj = map->createObjekt( i, schrift );
+        SpielObjekt *obj = map->createObjekt( o->id, schrift );
+        obj->setTeam( teams->get( o->team - 1 ) );
         welt->addObject( obj->getThis() );
-        objekte->set( obj, i );
+        objekte->add( obj );
     }
     bestenliste->setTeamAnzahl( map->getMaxTeamAnzahl() );
     welt->setSize( map->getSize().x, map->getSize().y );
@@ -1200,6 +1205,127 @@ void SpielKlasse::stknVerarbeitung()
             goToPresence( presence );
             break;
         }
+        case 0x16: // Objekt treffer
+        {
+            bytes++;
+            int schuss = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int oId = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            float erf = *(float *)bytes;
+            bytes += 4;
+            län -= 4;
+            int skillP = *(int *)bytes;
+            län -= 4;
+            goBackInTime( zeit );
+            int sAnz = schüsse->getEintragAnzahl();
+            for( int i = 0; i < sAnz; i++ )
+            {
+                Laser *tmp = schüsse->z( i );
+                if( tmp && tmp->getId() == schuss )
+                {
+                    if( sNum >= 0 )
+                    {
+                        double intens = 0;
+                        Spieler *attacker = 0;
+                        SpielObjekt *attacked = 0;
+                        for( auto s = spieler->getIterator(); s; s++ )
+                        {
+                            if( s->getSpielerNummer() == tmp->getSpieler() )
+                                attacker = s;
+                        }
+                        for( auto o = objekte->getIterator(); o; o++ )
+                        {
+                            if( o->getObjektId() == oId )
+                                attacked = o;
+                        }
+                        if( attacked && attacker )
+                        {
+                            intens = tmp->getIntensität( attacked->getSpeed() );
+                            attacked->nimmSchaden( intens, attacker ? attacker->getLevel() : 1 );
+                            if( tmp->getSpeed().getLengthSq() > 0 )
+                                attacked->impuls( tmp->getPosition() - tmp->getSpeed(), tmp->getSpeed() * 0.3f );
+                            attacked->calcDeadPlayerObject( schüsse->z( i ) );
+                            attacker->machSchaden( intens, attacked->getLevel(), attacked->doesShotAddEp() );
+                            if( attacker->getEp() != erf )
+                                chat->addNachricht( Text( "asynchrony detected ep difference: " ) += ( erf - attacker->getEp() ), 0xFFFF0000 );
+                            if( attacker->getSkillP() != skillP )
+                                chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += ( skillP - attacker->getSkillP() ), 0xFFFF0000 );
+                            bestenliste->updateSpieler( attacker );
+                        }
+                    }
+                    welt->removeObject( tmp );
+                    schüsse->remove( i );
+                    break;
+                }
+            }
+            goToPresence( presence );
+            if( sNum == spielerNummer )
+            {
+                for( auto s = spieler->getIterator(); s; s++ )
+                {
+                    if( s->getSpielerNummer() == spielerNummer )
+                    {
+                        shipGUI->update( s );
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+        case 0x17: // Objekt Tod
+        {
+            bytes++;
+            int oId = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            int killer = *(int *)bytes;
+            län -= 4;
+            goBackInTime( zeit );
+            SpielObjekt *dead = 0;
+            Spieler *kill = 0;
+            for( auto s = spieler->getIterator(); s; s++ )
+            {
+                if( s->getSpielerNummer() == killer )
+                    kill = s;
+            }
+            for( auto o = objekte->getIterator(); o; o++ )
+            {
+                if( o->getObjektId() == oId )
+                    dead = o;
+            }
+            if( dead )
+            {
+                DeadPlayer *dp = dead->sterben();
+                if( dp )
+                {
+                    welt->addObject( dp->getThis() );
+                    deads->add( dp );
+                }
+            }
+            if( kill )
+            {
+                kill->addKill( dead ? dead->getLevel() : 1, dead ? dead->doesShotAddEp() : 1 );
+                kill->zTeam()->punkte++;
+                bestenliste->updateTeam( kill->zTeam() );
+                bestenliste->updateSpieler( kill );
+            }
+            goToPresence( presence );
+            if( sNum == spielerNummer )
+            {
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                    {
+                        shipGUI->update( spieler->z( i ) );
+                        break;
+                    }
+                }
+            }
+            break;
+        }
         default:
             // Fehler beim verarbeiten
             break;

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -631,16 +631,17 @@ void Spieler::calcDeadPlayerObject( Laser * zSchuss )
     }
 }
 
-void Spieler::machSchaden( double intensität, int sLevel )
+void Spieler::machSchaden( double intensität, int sLevel, bool erf )
 {
     schadenGemacht += intensität;
-    addTreffer( (float)intensität, sLevel );
+    addTreffer( (float)intensität, sLevel, erf );
 }
 
-void Spieler::addKill( int sLevel )
+void Spieler::addKill( int sLevel, bool erf )
 {
     float levelFactor = (float)sLevel / (float)level;
-    addEp( 80 * levelFactor );
+    if( erf )
+        addEp( 80 * levelFactor );
     kills++;
     punkte++;
     maxReinkAbk--;
@@ -691,11 +692,12 @@ void Spieler::hatGeschossen()
     schüsse++;
 }
 
-void Spieler::addTreffer( float indens, int sLevel )
+void Spieler::addTreffer( float indens, int sLevel, bool erf )
 {
     treffer++;
     float levelFactor = (float)sLevel / (float)level;
-    addEp( ( indens / 10 ) * levelFactor );
+    if( erf )
+        addEp( ( indens / 10 ) * levelFactor );
 }
 
 void Spieler::addEp( float ep )

Asteroids/Spiel/Spieler/Spieler.h

@@ -159,12 +159,12 @@ public:
 	void setSkill( int art );
 	void nimmSchaden( double &intensität, int sLevel );
     void calcDeadPlayerObject( Laser *zSchuss );
-	void machSchaden( double intensität, int sLevel );
-	void addKill( int sLevel );
+	void machSchaden( double intensität, int sLevel, bool erf = 1 );
+	void addKill( int sLevel, bool erf = 1 );
     DeadPlayer *sterben();
 	void wiederbelebung();
 	void hatGeschossen();
-    void addTreffer( float indens, int sLevel );
+    void addTreffer( float indens, int sLevel, bool erf = 1 );
     void addEp( float ep );
     void save();
     void load();