Einiege Fehlenden Funktionsdefinitionen ergänzt

StickmanWorldOnline/Aktionen.cpp

@@ -354,7 +354,7 @@ SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions )
 
 void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue(), zSpiel );
 }
 
 
@@ -423,7 +423,7 @@ SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions )
 
 void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue(), zSpiel );
 }
 
 
@@ -609,7 +609,7 @@ BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions
 
 void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Bariere *)zParam( 1 ) )->setStyle( Bariere::Style::Aktiv, ( (Boolean *)zParam( 0 ) )->getValue() );
+    ( (Bariere *)zParam( 1 ) )->setStyle( Bariere::Style::Aktiv, ( (Boolean *)zParam( 0 ) )->getValue(), zSpiel );
 }
 
 
@@ -757,7 +757,7 @@ BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions )
 
 void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)zParam( 0 ) ) );
+    ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)zParam( 0 ) ), zSpiel );
 }
 
 TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )

StickmanWorldOnline/Bariere.cpp

@@ -23,12 +23,20 @@ Bariere::~Bariere()
         team->release();
 }
 
-void Bariere::setStyle( int style, bool add )
+void Bariere::setStyle( int style, bool add, Spiel *zSpiel )
 {
     if( add )
+    {
+        if( ( style | Style::Aktiv ) == style && ( this->style | Style::Aktiv ) != this->style )
+            zSpiel->setZuletztEingeschalteteBariere( (Bariere*)getThis() );
         this->style |= style;
+    }
     else
+    {
+        if( ( style | Style::Aktiv ) == style && ( this->style | Style::Aktiv ) == this->style )
+            zSpiel->setZuletztAusgeschalteteBariere( (Bariere *)getThis() );
         this->style &= ~style;
+    }
 }
 
 void Bariere::setAutoVerschiebungWeite( int pixel )
@@ -40,8 +48,9 @@ void Bariere::startAutoVerschiebung( Spiel *zSpiel )
 {
     if( !hatStyle( Style::AutoVerschiebung ) || hatStyle( Style::InVerschiebung ) )
         return;
+    zSpiel->setZuletztBewegteBariere( (Bariere *)getThis() );
     currentWeite = 0;
-    setStyle( Style::InVerschiebung, 1 );
+    setStyle( Style::InVerschiebung, 1, zSpiel );
     Ereignis *e = new Ereignis( BARIERE_WIRD_VERSCHOBEN );
     e->addParameter( "Betroffene Bariere", getThis() );
     e->addParameter( "Status", new String( "Start" ) );
@@ -53,12 +62,12 @@ void Bariere::setAutoSchaltungMaxTime( int seconds )
     autoSchaltungMaxTime = seconds;
 }
 
-void Bariere::startAutoSchaltung()
+void Bariere::startAutoSchaltung( Spiel *zSpiel )
 {
     if( !hatStyle( Style::AutoSchaltung ) || hatStyle( Style::InSchaltung ) )
         return;
     autoSchaltungCurrentTime = (float)autoSchaltungMaxTime;
-    setStyle( Style::InSchaltung, 1 );
+    setStyle( Style::InSchaltung, 1, zSpiel );
 }
 
 void Bariere::setTeam( Team *team )
@@ -75,8 +84,8 @@ void Bariere::tick( double time, Spiel* zSpiel)
         autoSchaltungCurrentTime -= (float)time;
         if( autoSchaltungCurrentTime < 0 )
         {
-            setStyle( Style::InSchaltung, 0 );
-            setStyle( Style::Aktiv, !hatStyle( Style::Aktiv ) );
+            setStyle( Style::InSchaltung, 0, zSpiel );
+            setStyle( Style::Aktiv, !hatStyle( Style::Aktiv ), zSpiel );
             schaltungAnzahl++;
 			Ereignis* e = new Ereignis(BARIERE_SWITCHED);
 			e->addParameter("Betroffene Bariere", getThis());
@@ -90,8 +99,8 @@ void Bariere::tick( double time, Spiel* zSpiel)
         if( currentWeite >= verschiebungWeite )
         {
             currentWeite = (float)verschiebungWeite;
-            setStyle( Style::InVerschiebung, 0 );
-            setStyle( Style::NextVerschiebungLinksOben, !hatStyle( Style::NextVerschiebungLinksOben ) );
+            setStyle( Style::InVerschiebung, 0, zSpiel );
+            setStyle( Style::NextVerschiebungLinksOben, !hatStyle( Style::NextVerschiebungLinksOben ), zSpiel );
             verschiebungAnzahl++;
 			Ereignis* e = new Ereignis(BARIERE_WIRD_VERSCHOBEN);
 			e->addParameter( "Betroffene Bariere", getThis() );

StickmanWorldOnline/Bariere.h

@@ -34,11 +34,11 @@ private:
 public:
     Bariere( int id, int x, int y, int breite, int height, int style, int verschiebungWeite = 0, int autoSchaltungMaxTime = 0, Team * team = 0 );
     ~Bariere();
-    void setStyle( int style, bool add );
+    void setStyle( int style, bool add, Spiel *zSpiel );
     void setAutoVerschiebungWeite( int pixel );
     void startAutoVerschiebung( Spiel *zSpiel );
     void setAutoSchaltungMaxTime( int seconds );
-    void startAutoSchaltung();
+    void startAutoSchaltung( Spiel *zSpiel );
     void setTeam( Team *team );
     void tick( double time, Spiel *zSpiel );
     bool hatStyle( int style ) const;

StickmanWorldOnline/Base.cpp

@@ -22,11 +22,12 @@ Base::~Base()
         nextTeam->release();
 }
 
-void Base::setTeam( Team *team )
+void Base::setTeam( Team *team, Spiel *zSpiel )
 {
     if( this->team )
         this->team->release();
     this->team = team;
+    zSpiel->setLastTeamChangedBase( (Base *)getThis() );
 }
 
 void Base::startChange( Team *team )
@@ -35,7 +36,7 @@ void Base::startChange( Team *team )
     {
         inChange = 0;
         if( nextTeam )
-            nextTeam = (Team*)nextTeam->release();
+            nextTeam = (Team *)nextTeam->release();
         team->release();
         return;
     }
@@ -83,7 +84,7 @@ int Base::getId() const
 
 Team *Base::getTeam() const
 {
-    return team ? (Team*)team->getThis() : 0;
+    return team ? (Team *)team->getThis() : 0;
 }
 
 Team *Base::zTeam() const

StickmanWorldOnline/Base.h

@@ -18,7 +18,7 @@ private:
 public:
     Base( int id, int x, int y, int width, int height, int maxTime = 10, Team *team = 0 );
     ~Base();
-    void setTeam( Team *team );
+    void setTeam( Team *team, Spiel *zSpiel );
     void startChange( Team *team );
     void tick( double time, Spiel *zSpiel );
     int getId() const;

StickmanWorldOnline/Drop.cpp

@@ -52,10 +52,8 @@ void Drop::setTime( float time )
 
 void Drop::doDrop( Spiel *zSpiel )
 {
+    zSpiel->setLastDrop( (Drop *)getThis() );
     nextDrop = (float)maxTime;
-    Ereignis *e = new Ereignis( DROP_AKTION );
-    e->addParameter( "Betroffener Drop", getThis() );
-    zSpiel->throwEvent( e );
     for( int i = 0; i < numDrops; i++ )
     {
         double p = zSpiel->getRand();
@@ -71,6 +69,9 @@ void Drop::doDrop( Spiel *zSpiel )
         if( x >= minX + 50 && x < maxX - 50 && y >= minY + 50 && y < maxY - 50 )
             zSpiel->addGegenstand( new Gegenstand( zSpiel->getNextId(), (GegenstandTyp)typ, x, y ) );
     }
+    Ereignis *e = new Ereignis( DROP_AKTION );
+    e->addParameter( "Betroffener Drop", getThis() );
+    zSpiel->throwEvent( e );
 }
 
 void Drop::tick( double time, Spiel *zSpiel )
@@ -105,6 +106,11 @@ int Drop::getMaxY() const
     return maxY;
 }
 
+float Drop::getZeit() const
+{
+    return nextDrop;
+}
+
 int Drop::getMaxTime() const
 {
     return maxTime;

StickmanWorldOnline/Geschoss.cpp

@@ -1,4 +1,5 @@
 #include "Geschoss.h"
+#include "Spiel.h"
 
 
 Geschoss::Geschoss( int id, float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer )
@@ -33,18 +34,21 @@ void Geschoss::invertDirection()
     richtung = invert( richtung );
 }
 
-void Geschoss::addUmlenkung()
+void Geschoss::addUmlenkung( Spiel *zSpiel )
 {
+    zSpiel->setGeschossZuletztUmgelenkt( (Geschoss *)getThis() );
     umgelenkt++;
 }
 
-void Geschoss::addGeschossTreffer()
+void Geschoss::addGeschossTreffer( Spiel *zSpiel )
 {
+    zSpiel->setGeschossZuletztGeschossGetroffen( (Geschoss *)getThis() );
     geschosseGetroffen++;
 }
 
-void Geschoss::addTunnel()
+void Geschoss::addTunnel( Spiel *zSpiel )
 {
+    zSpiel->setGeschossZuletztTunnelBenutzt( (Geschoss *)getThis() );
     schalter++;
 }
 
@@ -103,7 +107,7 @@ void Geschoss::tick( double zeit )
     case LINKS:
         x -= (float)zeit * speed;
         break;
-    case MITTE:
+    default:
         break;
     }
 }

StickmanWorldOnline/Geschoss.h

@@ -3,6 +3,8 @@
 #include "GameObject.h"
 #include "Spieler.h"
 
+class Spiel;
+
 #define PFEIL_DAMAGE 100
 #define KUGEL_DAMAGE 100
 
@@ -23,9 +25,9 @@ public:
     Geschoss( int id, float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer );
     ~Geschoss();
     void invertDirection();
-    void addUmlenkung();
-    void addGeschossTreffer();
-    void addTunnel();
+    void addUmlenkung( Spiel *zSpiel );
+    void addGeschossTreffer( Spiel *zSpiel );
+    void addTunnel( Spiel *zSpiel );
     void addSchalter();
     void setSpeed( float speed );
     void setBesitzer( Spieler *besitzer );

StickmanWorldOnline/Schalter.cpp

@@ -1,4 +1,5 @@
 #include "Schalter.h"
+#include "Spiel.h"
 
 
 Schalter::Schalter( int id, int x, int y, int width, int height, bool aktive )
@@ -14,9 +15,13 @@ void Schalter::setAktive( bool aktiv )
     this->aktiv = aktiv;
 }
 
-void Schalter::press()
+void Schalter::press( Spiel *zSpiel )
 {
+    zSpiel->setSchalterZuletztAktiviert( (Schalter *)getThis() );
     aktivierungen++;
+    Ereignis *e = new Ereignis( SCHALTER_AKTIVIERT );
+    e->addParameter( "Betroffener Schalter", getThis() );
+    zSpiel->throwEvent( e );
 }
 
 int Schalter::getAnzahlAktivierungen() const

StickmanWorldOnline/Schalter.h

@@ -2,6 +2,8 @@
 
 #include "GameObject.h"
 
+class Spiel;
+
 class Schalter : public GameObject
 {
 private:
@@ -12,7 +14,7 @@ private:
 public:
     Schalter( int id, int x, int y, int width, int height, bool aktive );
     void setAktive( bool aktiv );
-    void press();
+    void press( Spiel *zSpiel );
     int getAnzahlAktivierungen() const;
     bool isAktive() const;
     int getId() const;

StickmanWorldOnline/Spiel.cpp

@@ -18,6 +18,40 @@ Spiel::Spiel()
     gameTicks = 0;
     ende = 1;
     stat = new Statistik();
+    zWinner = 0;
+    lastRunnedTrigger = 0;
+    zuletztEingeschalteteBariere = 0;
+    zuletztAusgeschalteteBariere = 0;
+    zuletztBewegteBariere = 0;
+    lastTeamChangedBase = 0;
+    lastDropedDrop = 0;
+    zuletztAufgehobenerGegenstand = KEIN_GEGENSTAND;
+    zuletztBenutzterGegenstand = KEIN_GEGENSTAND;
+    zuletztGedropterGegenstand = KEIN_GEGENSTAND;
+    zuletztAbgefeuertesGeschoss = 0;
+    zuletztUmgelenktesGeschoss = 0;
+    zuletztBariereGetroffenesGeschoss = 0;
+    zuletztTunnelBenutztesGeschoss = 0;
+    zuletztGeschossGetroffenesGeschoss = 0;
+    zuletztAktivierterSchalter = 0;
+    zuletztSchadenGemachterSpieler = 0;
+    zuletztSchadenGenommenerSpieler = 0;
+    zuletztGeheilterSpieler = 0;
+    zuletztLevelUpSpieler = 0;
+    zuletztErfahrungBekommenerSpieler = 0;
+    zuletztGegenstandAktivierterSpieler = 0;
+    zuletztGegenstandAufgehobenerSpieler = 0;
+    zuletztSchalterAktivierterSpieler = 0;
+    zuletztTunnelBenutzterSpieler = 0;
+    zuletztGestorbenerSpieler = 0;
+    zuletztWiederbelebterSpieler = 0;
+    zuletztGeschossenerSpieler = 0;
+    zuletztAbgelaufenerTimer = 0;
+    zuletztGestarteterTimer = 0;
+    zuletztPausierterTimer = 0;
+    zuletztFortgesetzterTimer = 0;
+    zuletztBenutzterTunnel = 0;
+    zuletztBenutzteUmlenkung = 0;
     ref = 1;
 }
 
@@ -27,6 +61,66 @@ Spiel::~Spiel()
     stat->release();
     if( psqldb )
         psqldb->release();
+    if( lastRunnedTrigger )
+        lastRunnedTrigger->release();
+    if( zuletztEingeschalteteBariere )
+        zuletztEingeschalteteBariere->release();
+    if( zuletztAusgeschalteteBariere )
+        zuletztAusgeschalteteBariere->release();
+    if( zuletztBewegteBariere )
+        zuletztBewegteBariere->release();
+    if( lastTeamChangedBase )
+        lastTeamChangedBase->release();
+    if( lastDropedDrop )
+        lastDropedDrop->release();
+    if( zuletztAbgefeuertesGeschoss )
+        zuletztAbgefeuertesGeschoss->release();
+    if( zuletztUmgelenktesGeschoss )
+        zuletztUmgelenktesGeschoss->release();
+    if( zuletztBariereGetroffenesGeschoss )
+        zuletztBariereGetroffenesGeschoss->release();
+    if( zuletztTunnelBenutztesGeschoss )
+        zuletztTunnelBenutztesGeschoss->release();
+    if( zuletztGeschossGetroffenesGeschoss )
+        zuletztGeschossGetroffenesGeschoss->release();
+    if( zuletztAktivierterSchalter )
+        zuletztAktivierterSchalter->release();
+    if( zuletztSchadenGemachterSpieler )
+        zuletztSchadenGemachterSpieler->release();
+    if( zuletztSchadenGenommenerSpieler )
+        zuletztSchadenGenommenerSpieler->release();
+    if( zuletztGeheilterSpieler )
+        zuletztGeheilterSpieler->release();
+    if( zuletztLevelUpSpieler )
+        zuletztLevelUpSpieler->release();
+    if( zuletztErfahrungBekommenerSpieler )
+        zuletztErfahrungBekommenerSpieler->release();
+    if( zuletztGegenstandAktivierterSpieler )
+        zuletztGegenstandAktivierterSpieler->release();
+    if( zuletztGegenstandAufgehobenerSpieler )
+        zuletztGegenstandAufgehobenerSpieler->release();
+    if( zuletztSchalterAktivierterSpieler )
+        zuletztSchalterAktivierterSpieler->release();
+    if( zuletztTunnelBenutzterSpieler )
+        zuletztTunnelBenutzterSpieler->release();
+    if( zuletztGestorbenerSpieler )
+        zuletztGestorbenerSpieler->release();
+    if( zuletztWiederbelebterSpieler )
+        zuletztWiederbelebterSpieler->release();
+    if( zuletztGeschossenerSpieler )
+        zuletztGeschossenerSpieler->release();
+    if( zuletztAbgelaufenerTimer )
+        zuletztAbgelaufenerTimer->release();
+    if( zuletztGestarteterTimer )
+        zuletztGestarteterTimer->release();
+    if( zuletztPausierterTimer )
+        zuletztPausierterTimer->release();
+    if( zuletztFortgesetzterTimer )
+        zuletztFortgesetzterTimer->release();
+    if( zuletztBenutzterTunnel )
+        zuletztBenutzterTunnel->release();
+    if( zuletztBenutzteUmlenkung )
+        zuletztBenutzteUmlenkung->release();
 }
 
 // nicht constant
@@ -114,7 +208,7 @@ void Spiel::run()
             int sNum = tmp->getSpielerNummer();
             log->schreibe( (char *)& sNum, 4 );
             tmp->zKlient()->sendeSpielerNummer( sNum, -1 );
-            Text * name = psqldb->getAccountRufName( tmp->getAccountId() );
+            Text *name = psqldb->getAccountRufName( tmp->getAccountId() );
             char len = (char)( name ? name->getLength() : 0 );
             log->schreibe( &len, 1 );
             if( len )
@@ -126,7 +220,7 @@ void Spiel::run()
     __int64 randSeed = randG.getSeed();
     log->schreibe( (char *)& randSeed, 8 );
     Array< char > spielerStatus;
-    ZeitMesser * zeit = new ZeitMesser();
+    ZeitMesser *zeit = new ZeitMesser();
     zeit->messungStart();
     isRunning = 1;
     ende = 0;
@@ -167,7 +261,12 @@ void Spiel::run()
     {
         if( spieler.z( i ) && spieler.z( i )->zKlient() )
         {
-            if( !spieler.z( i )->zTeam()->getPunkte() )
+            if( !zWinner )
+            {
+                spielerStatus.set( 5, i ); // Datenbank Unentschieden
+                spieler.z( i )->zKlient()->sendeSpielEnde( 2, 0 );
+            }
+            else if( zWinner != spieler.z( i )->zTeam() )
             {
                 spielerStatus.set( 1, i ); // Datenbank Verloren
                 spieler.z( i )->zKlient()->sendeSpielEnde( 0, 0 );
@@ -205,7 +304,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++ )
     {
@@ -275,7 +374,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
             Spieler *tmp = spieler.z( i );
             if( tmp && tmp->getAccountId() == accountId )
             {
-                if( !tmp->setTastenStand( (unsigned char)*bytes, 0 ) )
+                if( !tmp->setTastenStand( (unsigned char)* bytes, 0 ) )
                 {
                     saveMSG = 0;
                     break;
@@ -393,6 +492,9 @@ void Spiel::tick( double zeit )
         }
         if( intersectsWithBariere || g->getX() < 0 || g->getY() < 0 || g->getX() + g->getWidth() >= mapSize.x || g->getY() + g->getHeight() >= mapSize.y )
         {
+            if( zuletztBariereGetroffenesGeschoss )
+                zuletztBariereGetroffenesGeschoss->release();
+            zuletztBariereGetroffenesGeschoss = (Geschoss *)g->getThis();
             g->tick( -zeit );
             switch( g->getTyp() )
             {
@@ -441,7 +543,7 @@ void Spiel::tick( double zeit )
                 {
                     g->setX( g->getX() + (float)t->getZielX() - t->getX() );
                     g->setY( g->getY() + (float)t->getZielY() - t->getY() );
-                    g->addTunnel();
+                    g->addTunnel( this );
                     Ereignis *e = new Ereignis( TUNNEL_BENUTZT );
                     e->addParameter( "Betroffes Geschoss", g->getThis() );
                     e->addParameter( "Betroffer Tunnel", t->getThis() );
@@ -473,7 +575,7 @@ void Spiel::tick( double zeit )
                         if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
                         {
                             g->setRichtung( u->getRichtung() );
-                            g->addUmlenkung();
+                            g->addUmlenkung( this );
                             u->addBenutzt();
                             Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
                             e->addParameter( "Betroffes Geschoss", g->getThis() );
@@ -494,7 +596,7 @@ void Spiel::tick( double zeit )
                         {
                             if( g2->getTyp() == GESCHOSS_PFEIL )
                                 removed = 1;
-                            g->addGeschossTreffer();
+                            g->addGeschossTreffer( this );
                             if( j < i )
                                 i--;
                             shots.remove( j );
@@ -600,7 +702,7 @@ void Spiel::tick( double zeit )
     }
 }
 
-void Spiel::addVariable( const char *name, Variable * var )
+void Spiel::addVariable( const char *name, Variable *var )
 {
     bool found = 0;
     for( auto v = variablen.getIterator(); v; v++ )
@@ -617,7 +719,7 @@ void Spiel::addVariable( const char *name, Variable * var )
         var->release();
 }
 
-void Spiel::setVariable( const char *name, Variable * var )
+void Spiel::setVariable( const char *name, Variable *var )
 {
     bool found = 0;
     for( auto v = variablen.getIterator(); v; v++ )
@@ -632,78 +734,121 @@ void Spiel::setVariable( const char *name, Variable * var )
         var->release();
 }
 
-void Spiel::addTeam( Team * team )
+void Spiel::addTeam( Team *team )
 {
     teams.add( team );
 }
 
-void Spiel::addSpieler( Spieler * spieler )
+void Spiel::addSpieler( Spieler *spieler )
 {
     this->spieler.add( spieler );
 }
 
-void Spiel::addBariere( Bariere * bariere )
+void Spiel::addBariere( Bariere *bariere )
 {
     barieren.add( bariere );
 }
 
-void Spiel::addBase( Base * base )
+void Spiel::addBase( Base *base )
 {
     basen.add( base );
 }
 
-void Spiel::addDrop( Drop * drop )
+void Spiel::addDrop( Drop *drop )
 {
     drops.add( drop );
 }
 
-void Spiel::addGegenstand( Gegenstand * gegenstand )
+void Spiel::addGegenstand( Gegenstand *gegenstand )
 {
     items.add( gegenstand );
+    zuletztGedropterGegenstand = gegenstand->getTyp();
     Ereignis *e = new Ereignis( GEGENSTAND_DROPED );
     e->addParameter( "Betroffener Gegenstand", gegenstand->getThis() );
     throwEvent( e );
 }
 
-void Spiel::addGeschoss( Geschoss * geschoss )
+void Spiel::addGeschoss( Geschoss *geschoss )
 {
+    if( zuletztAbgefeuertesGeschoss )
+        zuletztAbgefeuertesGeschoss->release();
+    zuletztAbgefeuertesGeschoss = geschoss;
     shots.add( geschoss );
 }
 
-void Spiel::addSchalter( Schalter * schalter )
+void Spiel::addSchalter( Schalter *schalter )
 {
     this->schalter.add( schalter );
 }
 
-void Spiel::addSchiene( Schiene * schiene )
+void Spiel::addSchiene( Schiene *schiene )
 {
     schienen.add( schiene );
 }
 
-void Spiel::addTimer( Timer * timer )
+void Spiel::addTimer( Timer *timer )
 {
     this->timer.add( timer );
 }
 
-void Spiel::addTunnel( Tunnel * tunnel )
+void Spiel::addTunnel( Tunnel *tunnel )
 {
     this->tunnel.add( tunnel );
 }
 
-void Spiel::addUmlenkung( Umlenkung * umlenkung )
+void Spiel::addUmlenkung( Umlenkung *umlenkung )
 {
     umlenkungen.add( umlenkung );
 }
 
-void Spiel::addTrigger( Trigger * trigger )
+void Spiel::addTrigger( Trigger *trigger )
 {
     this->trigger.add( trigger );
 }
 
-void Spiel::addTriggerRun( TriggerRun * tRun )
+void Spiel::addTriggerRun( TriggerRun *tRun )
 {
     if( tRun )
+    {
+        if( lastRunnedTrigger )
+            lastRunnedTrigger->release();
+        lastRunnedTrigger = tRun->getTrigger();
         triggerRuns.add( tRun );
+    }
+}
+
+void Spiel::spielerActivate( Spieler *zSpieler )
+{
+    // spieler - item intersection
+    for( int i = 0; i < items.getEintragAnzahl(); i++ )
+    {
+        if( items.z( i )->intersectsWith( zSpieler ) )
+        {
+            items.remove( i );
+            zSpieler->addItem( items.z( i )->getTyp(), 1, this );
+            i--;
+        }
+    }
+    // Spieler - schalter intersection
+    for( int i = 0; i < schalter.getEintragAnzahl(); i++ )
+    {
+        if( schalter.z( i )->intersectsWith( zSpieler ) )
+        {
+            zSpieler->addSchalterBenutzung( this );
+            schalter.z( i )->press( this );
+        }
+    }
+    // Spieler - tunnel intersection
+    for( int i = 0; i < tunnel.getEintragAnzahl(); i++ )
+    {
+        if( tunnel.z( i )->intersectsWith( zSpieler ) )
+        {
+            zSpieler->addTunnelBenutzung( this );
+            zSpieler->setX( (float)tunnel.z( i )->getZielX() - zSpieler->getWidth() / 2.f );
+            zSpieler->setY( (float)tunnel.z( i )->getZielY() - zSpieler->getHeight() / 2.f );
+            tunnel.z( i )->addBenutzung();
+        }
+    }
 }
 
 Team *Spiel::getTeam( int id ) const
@@ -721,7 +866,7 @@ Spieler *Spiel::getSpieler( int id ) const
     for( auto s = spieler.getIterator(); s; s++ )
     {
         if( s->getId() == id )
-            return (Spieler*)s->getThis();
+            return (Spieler *)s->getThis();
     }
     return 0;
 }
@@ -856,12 +1001,7 @@ void Spiel::activateShalter( int id )
     for( auto s = schalter.getIterator(); s; s++ )
     {
         if( s->getId() == id )
-        {
-            s->press();
-            Ereignis *e = new Ereignis( SCHALTER_AKTIVIERT );
-            e->addParameter( "Betroffener Schalter", s->getThis() );
-            throwEvent( e );
-        }
+            s->press( this );
     }
 }
 
@@ -904,6 +1044,367 @@ int Spiel::getTickCount() const
     return gameTicks;
 }
 
+void Spiel::setEnde( Team *zGewinner )
+{
+    zWinner = zGewinner;
+    ende = true;
+}
+
+Trigger *Spiel::getRandomTrigger()
+{
+    if( !trigger.getEintragAnzahl() )
+        return 0;
+    return trigger.get( (int)( randG.rand() * trigger.getEintragAnzahl() ) );
+}
+
+Trigger *Spiel::getLastRunnedTrigger() const
+{
+    return lastRunnedTrigger ? (Trigger *)lastRunnedTrigger->getThis() : 0;
+}
+
+Bariere *Spiel::getRandomBariere()
+{
+    return barieren.get( (int)( randG.rand() * barieren.getEintragAnzahl() ) );
+}
+
+void Spiel::setZuletztEingeschalteteBariere( Bariere *b )
+{
+    if( zuletztEingeschalteteBariere )
+        zuletztEingeschalteteBariere->release();
+    zuletztEingeschalteteBariere = b;
+}
+
+Bariere *Spiel::getZuletztEingeschalteteBariere() const
+{
+    return zuletztEingeschalteteBariere ? (Bariere *)zuletztEingeschalteteBariere->getThis() : 0;
+}
+
+void Spiel::setZuletztAusgeschalteteBariere( Bariere *b )
+{
+    if( zuletztAusgeschalteteBariere )
+        zuletztAusgeschalteteBariere->release();
+    zuletztAusgeschalteteBariere = b;
+}
+
+Bariere *Spiel::getZuletztAusgeschalteteBariere() const
+{
+    return zuletztAusgeschalteteBariere ? (Bariere *)zuletztAusgeschalteteBariere->getThis() : 0;
+}
+
+void Spiel::setZuletztBewegteBariere( Bariere *b )
+{
+    if( zuletztBewegteBariere )
+        zuletztBewegteBariere->release();
+    zuletztBewegteBariere = b;
+}
+
+Bariere *Spiel::getZuletztBewegteBariere() const
+{
+    return zuletztBewegteBariere ? (Bariere *)zuletztBewegteBariere->getThis() : 0;
+}
+
+Base *Spiel::getRandomBase()
+{
+    if( !basen.getEintragAnzahl() )
+        return 0;
+    return basen.get( (int)( randG.rand() * basen.getEintragAnzahl() ) );
+}
+
+void Spiel::setLastTeamChangedBase( Base *b )
+{
+    if( lastTeamChangedBase )
+        lastTeamChangedBase->release();
+    lastTeamChangedBase = b;
+}
+
+Base *Spiel::getLastTeamChangedBase() const
+{
+    return lastTeamChangedBase ? (Base *)lastTeamChangedBase->getThis() : 0;
+}
+
+Drop *Spiel::getRandomDrop()
+{
+    if( !drops.getEintragAnzahl() )
+        return 0;
+    return drops.get( (int)( randG.rand() * drops.getEintragAnzahl() ) );
+}
+
+void Spiel::setLastDrop( Drop *d )
+{
+    if( lastDropedDrop )
+        lastDropedDrop->release();
+    lastDropedDrop = d;
+}
+
+Drop *Spiel::getLastDrop() const
+{
+    return lastDropedDrop ? (Drop *)lastDropedDrop->getThis() : 0;
+}
+
+void Spiel::setItemZuletztAufgehoben( GegenstandTyp g )
+{
+    zuletztAufgehobenerGegenstand = g;
+}
+
+GegenstandTyp Spiel::getItemZuletztAufgehoben() const
+{
+    return zuletztAufgehobenerGegenstand;
+}
+
+void Spiel::setItemZuletztAktiviert( GegenstandTyp g )
+{
+    zuletztBenutzterGegenstand = g;
+}
+
+GegenstandTyp Spiel::getItemZuletztAktiviert() const
+{
+    return zuletztBenutzterGegenstand;
+}
+
+GegenstandTyp Spiel::getItemZuletztGedropt() const
+{
+    return zuletztGedropterGegenstand;
+}
+
+Geschoss *Spiel::getRandomGeschoss()
+{
+    if( !shots.getEintragAnzahl() )
+        return 0;
+    return shots.get( (int)( randG.rand() * shots.getEintragAnzahl() ) );
+}
+
+Geschoss *Spiel::getGeschossZuletztAbgefeuert() const
+{
+    return zuletztAbgefeuertesGeschoss ? (Geschoss *)zuletztAbgefeuertesGeschoss->getThis() : 0;
+}
+
+void Spiel::setGeschossZuletztUmgelenkt( Geschoss *g )
+{
+    if( zuletztUmgelenktesGeschoss )
+        zuletztUmgelenktesGeschoss->release();
+    zuletztUmgelenktesGeschoss = g;
+}
+
+Geschoss *Spiel::getGeschossZuletztUmgelenkt() const
+{
+    return zuletztUmgelenktesGeschoss ? (Geschoss *)zuletztUmgelenktesGeschoss->getThis() : 0;
+}
+
+Geschoss *Spiel::getGeschossZuletztBariereGetroffen() const
+{
+    return zuletztBariereGetroffenesGeschoss ? (Geschoss *)zuletztBariereGetroffenesGeschoss->getThis() : 0;
+}
+
+void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss *g )
+{
+    if( zuletztTunnelBenutztesGeschoss )
+        zuletztTunnelBenutztesGeschoss->release();
+    zuletztTunnelBenutztesGeschoss = g;
+}
+
+Geschoss *Spiel::getGeschossZuletztTunnelBenutzt() const
+{
+    return zuletztTunnelBenutztesGeschoss ? (Geschoss *)zuletztTunnelBenutztesGeschoss->getThis() : 0;
+}
+
+void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss *g )
+{
+    if( zuletztGeschossGetroffenesGeschoss )
+        zuletztGeschossGetroffenesGeschoss->release();
+    zuletztGeschossGetroffenesGeschoss = g;
+}
+
+Geschoss *Spiel::getGeschossZuletztGeschossGetroffen() const
+{
+    return zuletztGeschossGetroffenesGeschoss ? (Geschoss *)zuletztGeschossGetroffenesGeschoss->getThis() : 0;
+}
+
+Schalter *Spiel::getRandomSchalter()
+{
+    if( !schalter.getEintragAnzahl() )
+        return 0;
+    return schalter.get( (int)( randG.rand() * schalter.getEintragAnzahl() ) );
+}
+
+void Spiel::setSchalterZuletztAktiviert( Schalter *s )
+{
+    if( zuletztAktivierterSchalter )
+        zuletztAktivierterSchalter->release();
+    zuletztAktivierterSchalter = s;
+}
+
+Schalter *Spiel::getSchalterZuletztAktiviert() const
+{
+    return zuletztAktivierterSchalter ? (Schalter *)zuletztAktivierterSchalter->getThis() : 0;
+}
+
+Spieler *Spiel::getRandomSpieler()
+{
+    if( !spieler.getEintragAnzahl() )
+        return 0;
+    return spieler.get( (int)( randG.rand() * spieler.getEintragAnzahl() ) );
+}
+
+Spieler *Spiel::getRandomSpieler( Team *zTeam )
+{
+    if( !zTeam || !zTeam->getSpielerAnzahl() )
+        return 0;
+    int index = (int)( randG.rand() * zTeam->getSpielerAnzahl() );
+    for( auto s = spieler.getIterator(); s; s++ )
+    {
+        if( s->zTeam() == zTeam )
+        {
+            if( index-- <= 0 )
+                return (Spieler *)s->getThis();
+        }
+    }
+    return 0;
+}
+
+void Spiel::setSpielerZuletztSchadenGemacht( Spieler *s )
+{
+    if( zuletztSchadenGemachterSpieler )
+        zuletztSchadenGemachterSpieler->release();
+    zuletztSchadenGemachterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztSchadenGemacht() const
+{
+    return zuletztSchadenGemachterSpieler ? (Spieler *)zuletztSchadenGemachterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztSchadenGenommen( Spieler *s )
+{
+    if( zuletztSchadenGenommenerSpieler )
+        zuletztSchadenGenommenerSpieler->release();
+    zuletztSchadenGenommenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztSchadenGenommen() const
+{
+    return zuletztSchadenGenommenerSpieler ? (Spieler *)zuletztSchadenGenommenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGeheilt( Spieler *s )
+{
+    if( zuletztGeheilterSpieler )
+        zuletztGeheilterSpieler->release();
+    zuletztGeheilterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGeheilt() const
+{
+    return zuletztGeheilterSpieler ? (Spieler *)zuletztGeheilterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztLevelUp( Spieler *s )
+{
+    if( zuletztLevelUpSpieler )
+        zuletztLevelUpSpieler->release();
+    zuletztLevelUpSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztLevelUp() const
+{
+    return zuletztLevelUpSpieler ? (Spieler *)zuletztLevelUpSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztErfahrungBekommen( Spieler *s )
+{
+    if( zuletztErfahrungBekommenerSpieler )
+        zuletztErfahrungBekommenerSpieler->release();
+    zuletztErfahrungBekommenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztErfahrungBekommen() const
+{
+    return zuletztErfahrungBekommenerSpieler ? (Spieler *)zuletztErfahrungBekommenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler *s )
+{
+    if( zuletztGegenstandAktivierterSpieler )
+        zuletztGegenstandAktivierterSpieler->release();
+    zuletztGegenstandAktivierterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGegenstandAktiviert() const
+{
+    return zuletztGegenstandAktivierterSpieler ? (Spieler *)zuletztGegenstandAktivierterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler *s )
+{
+    if( zuletztGegenstandAufgehobenerSpieler )
+        zuletztGegenstandAufgehobenerSpieler->release();
+    zuletztGegenstandAufgehobenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGegenstandAufgehoben() const
+{
+    return zuletztGegenstandAufgehobenerSpieler ? (Spieler *)zuletztGegenstandAufgehobenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztSchalterAktiviert( Spieler *s )
+{
+    if( zuletztSchalterAktivierterSpieler )
+        zuletztSchalterAktivierterSpieler->release();
+    zuletztSchalterAktivierterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztSchalterAktiviert() const
+{
+    return zuletztSchalterAktivierterSpieler ? (Spieler *)zuletztSchalterAktivierterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztTunnelBenutzt( Spieler *s )
+{
+    if( zuletztTunnelBenutzterSpieler )
+        zuletztTunnelBenutzterSpieler->release();
+    zuletztTunnelBenutzterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztTunnelBenutzt() const
+{
+    return zuletztTunnelBenutzterSpieler ? (Spieler *)zuletztTunnelBenutzterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGestorben( Spieler *s )
+{
+    if( zuletztGestorbenerSpieler )
+        zuletztGestorbenerSpieler->release();
+    zuletztGestorbenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGestorben() const
+{
+    return zuletztGestorbenerSpieler ? (Spieler *)zuletztGestorbenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztWiederbelebt( Spieler *s )
+{
+    if( zuletztWiederbelebterSpieler )
+        zuletztWiederbelebterSpieler->release();
+    zuletztWiederbelebterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztWiederbelebt() const
+{
+    return zuletztWiederbelebterSpieler ? (Spieler*)zuletztWiederbelebterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGeschossen( Spieler *s )
+{
+    if( zuletztGeschossenerSpieler )
+        zuletztGeschossenerSpieler->release();
+    zuletztGeschossenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGeschossen() const
+{
+    return zuletztGeschossenerSpieler ? (Spieler*)zuletztGeschossenerSpieler->getThis() : 0;
+}
+
 StatistikV *Spiel::getStatistik() const
 {
     return stat->getThis();

StickmanWorldOnline/Spiel.h

@@ -50,6 +50,40 @@ private:
     Critical c;
     Datei *log;
     Punkt mapSize;
+    Team *zWinner;
+    Trigger *lastRunnedTrigger;
+    Bariere *zuletztEingeschalteteBariere;
+    Bariere *zuletztAusgeschalteteBariere;
+    Bariere *zuletztBewegteBariere;
+    Base *lastTeamChangedBase;
+    Drop *lastDropedDrop;
+    GegenstandTyp zuletztAufgehobenerGegenstand;
+    GegenstandTyp zuletztBenutzterGegenstand;
+    GegenstandTyp zuletztGedropterGegenstand;
+    Geschoss *zuletztAbgefeuertesGeschoss;
+    Geschoss *zuletztUmgelenktesGeschoss;
+    Geschoss *zuletztBariereGetroffenesGeschoss;
+    Geschoss *zuletztTunnelBenutztesGeschoss;
+    Geschoss *zuletztGeschossGetroffenesGeschoss;
+    Schalter *zuletztAktivierterSchalter;
+    Spieler *zuletztSchadenGemachterSpieler;
+    Spieler *zuletztSchadenGenommenerSpieler;
+    Spieler *zuletztGeheilterSpieler;
+    Spieler *zuletztLevelUpSpieler;
+    Spieler *zuletztErfahrungBekommenerSpieler;
+    Spieler *zuletztGegenstandAktivierterSpieler;
+    Spieler *zuletztGegenstandAufgehobenerSpieler;
+    Spieler *zuletztSchalterAktivierterSpieler;
+    Spieler *zuletztTunnelBenutzterSpieler;
+    Spieler *zuletztGestorbenerSpieler;
+    Spieler *zuletztWiederbelebterSpieler;
+    Spieler *zuletztGeschossenerSpieler;
+    Timer *zuletztAbgelaufenerTimer;
+    Timer *zuletztGestarteterTimer;
+    Timer *zuletztPausierterTimer;
+    Timer *zuletztFortgesetzterTimer;
+    Tunnel *zuletztBenutzterTunnel;
+    Umlenkung *zuletztBenutzteUmlenkung;
     int nextId;
     bool ende;
     int spielerAnzahl;
@@ -95,6 +129,7 @@ public:
     void addUmlenkung( Umlenkung *umlenkung );
     void addTrigger( Trigger *trigger );
     void addTriggerRun( TriggerRun *tRun );
+    void spielerActivate( Spieler *zSpieler );
     void activateShalter( int id );
     void throwEvent( Ereignis *e );
     Variable *getVariable( const char *name ) const;
@@ -118,50 +153,79 @@ public:
     double getRand();
     int getTickCount() const;
     void setEnde( Team *zGewinner );
-    Trigger *getRandomTrigger() const;
+    Trigger *getRandomTrigger();
     Trigger *getLastRunnedTrigger() const;
-    Bariere *getRandomBariere() const;
+    Bariere *getRandomBariere();
+    void setZuletztEingeschalteteBariere( Bariere *b );
     Bariere *getZuletztEingeschalteteBariere() const;
+    void setZuletztAusgeschalteteBariere( Bariere *b );
     Bariere *getZuletztAusgeschalteteBariere() const;
+    void setZuletztBewegteBariere( Bariere *b );
     Bariere *getZuletztBewegteBariere() const;
-    Base *getRandomBase() const;
+    Base *getRandomBase();
+    void setLastTeamChangedBase( Base *b );
     Base *getLastTeamChangedBase() const;
-    Drop *getRandomDrop() const;
+    Drop *getRandomDrop();
+    void setLastDrop( Drop *d );
     Drop *getLastDrop() const;
+    void setItemZuletztAufgehoben( GegenstandTyp g );
     GegenstandTyp getItemZuletztAufgehoben() const;
+    void setItemZuletztAktiviert( GegenstandTyp g );
     GegenstandTyp getItemZuletztAktiviert() const;
     GegenstandTyp getItemZuletztGedropt() const;
-    Geschoss *getRandomGeschoss() const;
+    Geschoss *getRandomGeschoss();
     Geschoss *getGeschossZuletztAbgefeuert() const;
+    void setGeschossZuletztUmgelenkt( Geschoss *g );
     Geschoss *getGeschossZuletztUmgelenkt() const;
     Geschoss *getGeschossZuletztBariereGetroffen() const;
+    void setGeschossZuletztTunnelBenutzt( Geschoss *g );
     Geschoss *getGeschossZuletztTunnelBenutzt() const;
+    void setGeschossZuletztGeschossGetroffen( Geschoss *g );
     Geschoss *getGeschossZuletztGeschossGetroffen() const;
-    Schalter *getRandomSchalter() const;
+    Schalter *getRandomSchalter();
+    void setSchalterZuletztAktiviert( Schalter *s );
     Schalter *getSchalterZuletztAktiviert() const;
-    Spieler *getRandomSpieler() const;
-    Spieler *getRandomSpieler( Team *zTeam ) const;
+    Spieler *getRandomSpieler();
+    Spieler *getRandomSpieler( Team *zTeam );
+    void setSpielerZuletztSchadenGemacht( Spieler *s );
     Spieler *getSpielerZuletztSchadenGemacht() const;
+    void setSpielerZuletztSchadenGenommen( Spieler *s );
     Spieler *getSpielerZuletztSchadenGenommen() const;
+    void setSpielerZuletztGeheilt( Spieler *s );
     Spieler *getSpielerZuletztGeheilt() const;
+    void setSpielerZuletztLevelUp( Spieler *s );
     Spieler *getSpielerZuletztLevelUp() const;
+    void setSpielerZuletztErfahrungBekommen( Spieler *s );
     Spieler *getSpielerZuletztErfahrungBekommen() const;
+    void setSpielerZuletztGegenstandAktiviert( Spieler *s );
     Spieler *getSpielerZuletztGegenstandAktiviert() const;
+    void setSpielerZuletztGegenstandAufgehoben( Spieler *s );
     Spieler *getSpielerZuletztGegenstandAufgehoben() const;
+    void setSpielerZuletztSchalterAktiviert( Spieler *s );
     Spieler *getSpielerZuletztSchalterAktiviert() const;
+    void setSpielerZuletztTunnelBenutzt( Spieler *s );
     Spieler *getSpielerZuletztTunnelBenutzt() const;
+    void setSpielerZuletztGestorben( Spieler *s );
     Spieler *getSpielerZuletztGestorben() const;
+    void setSpielerZuletztWiederbelebt( Spieler *s );
     Spieler *getSpielerZuletztWiederbelebt() const;
+    void setSpielerZuletztGeschossen( Spieler *s );
     Spieler *getSpielerZuletztGeschossen() const;
-    Team *getRandomTeam() const;
-    Timer *getRandomTimer() const;
+    Team *getRandomTeam();
+    Timer *getRandomTimer();
+    void setTimerZuletztAbgelaufen( Timer *t );
     Timer *getTimerZuletztAbgelaufen() const;
+    void setTimerZuletztGestartet( Timer *t );
     Timer *getTimerZuletztGestartet() const;
+    void setTimerZuletztPausiert( Timer *t );
     Timer *getTimerZuletztPausiert() const;
+    void setTimerZuletztFortgesetzt( Timer *t );
     Timer *getTimerZuletztFortgesetzt() const;
-    Tunnel *getRandomTunnel() const;
+    Tunnel *getRandomTunnel();
+    void setTunnelZuletztBenutzt( Tunnel *t );
     Tunnel *getTunnelZuletztBenutzt() const;
-    Umlenkung *getRandomUmlenkung() const;
+    Umlenkung *getRandomUmlenkung();
+    void setUmlenkungZuletztBenutzt( Umlenkung *t );
     Umlenkung *getUmlenkungZuletztBenutzt() const;
     // constant
     StatistikV *getStatistik() const override;

StickmanWorldOnline/Spieler.cpp

@@ -140,6 +140,22 @@ GegenstandTyp Inventar::getItemTyp( int index ) const
     return slots[ index ];
 }
 
+void Inventar::removeItem( GegenstandTyp typ, int anzahl )
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] == typ )
+        {
+            this->anzahl[ i ] -= anzahl;
+            if( this->anzahl[ i ] < 0 )
+            {
+                slots[ i ] = KEIN_GEGENSTAND;
+                abklingzeit[ i ] = 0;
+            }
+        }
+    }
+}
+
 
 Spieler::Spieler( int id, Team *team, int spawnX, int spawnY, int farbe )
     : GameObject( SPIELER, spawnX, spawnY, 40, 50 )
@@ -268,38 +284,82 @@ void Spieler::setLaufTempo( float pps )
 void Spieler::addErfahrung( float anz, Spiel *zSpiel )
 {
     erfahrung += anz;
+    zSpiel->setSpielerZuletztErfahrungBekommen( (Spieler *)getThis() );
     Ereignis *e = new Ereignis( SPIELER_BEKOMMT_ERFAHRUNG );
     e->addParameter( "Betroffener Spieler", getThis() );
     e->addParameter( "Wert", new Float( anz ) );
     zSpiel->throwEvent( e );
-    if( erfahrung > maxErfahrung )
+    while( erfahrung > maxErfahrung )
+        levelUp( zSpiel );
+    while( erfahrung < 0 )
+        levelDown( zSpiel );
+}
+
+void Spieler::levelUp( Spiel *zSpiel )
+{
+    level++;
+    erfahrung -= (float)maxErfahrung;
+    maxErfahrung += ( maxErfahrung / level ) + 2;
+    maxLeben += 20;
+    heilung( 20, zSpiel );
+    if( level <= 10 )
     {
-        level++;
-        erfahrung -= (float)maxErfahrung;
-        maxErfahrung += ( maxErfahrung / level ) + 2;
-        maxLeben += 20;
-        heilung( 20, zSpiel );
-        if( level <= 10 )
-        {
-            laufTempo += 2;
-            geschossTempo += 2;
-        }
-        if( level <= 50 )
-        {
-            armor += 1;
-            abklingZeitVerringerung += 1;
-        }
-        if( level <= 75 )
-        {
-            schadensBonus += 1;
-            lebensraub += 1;
-        }
-        if( level <= 100 )
-            lebensRegeneration += 0.25f;
-        Ereignis *e = new Ereignis( SPIELER_LEVEL_UP );
-        e->addParameter( "Betroffener Spieler", getThis() );
-        zSpiel->throwEvent( e );
+        laufTempo += 2;
+        geschossTempo += 2;
+    }
+    if( level <= 50 )
+    {
+        armor += 1;
+        abklingZeitVerringerung += 1;
+    }
+    if( level <= 75 )
+    {
+        schadensBonus += 1;
+        lebensraub += 1;
+    }
+    if( level <= 100 )
+        lebensRegeneration += 0.25f;
+    zSpiel->setSpielerZuletztLevelUp( (Spieler *)getThis() );
+    Ereignis *e = new Ereignis( SPIELER_LEVEL_UP );
+    e->addParameter( "Betroffener Spieler", getThis() );
+    zSpiel->throwEvent( e );
+}
+
+void Spieler::levelDown( Spiel *zSpiel )
+{
+    if( level <= 100 )
+        lebensRegeneration -= 0.25f;
+    if( level <= 75 )
+    {
+        schadensBonus -= 1;
+        lebensraub -= 1;
+    }
+    if( level <= 50 )
+    {
+        armor -= 1;
+        abklingZeitVerringerung -= 1;
     }
+    if( level <= 10 )
+    {
+        laufTempo -= 2;
+        geschossTempo -= 2;
+    }
+    maxLeben -= 20;
+    maxErfahrung -= ( maxErfahrung / level ) + 2;
+    erfahrung += (float)maxErfahrung;
+    level--;
+}
+
+void Spieler::addTunnelBenutzung( Spiel *zSpiel )
+{
+    tunnelBenutzt++;
+    zSpiel->setSpielerZuletztTunnelBenutzt( (Spieler *)getThis() );
+}
+
+void Spieler::addSchalterBenutzung( Spiel *zSpiel )
+{
+    schalterAktiviert++;
+    zSpiel->setSpielerZuletztSchalterAktiviert( (Spieler *)getThis() );
 }
 
 // aktualisiert auch die team statistik
@@ -341,6 +401,7 @@ void Spieler::wiederbelebung( Spiel *zSpiel )
 {
     amLeben = 1;
     leben = (float)maxLeben;
+    zSpiel->setSpielerZuletztWiederbelebt( (Spieler *)getThis() );
     Ereignis *e = new Ereignis( SPIELER_WIEDERBELEBT );
     e->addParameter( "Betroffener Spieler", getThis() );
     zSpiel->throwEvent( e );
@@ -362,6 +423,8 @@ void Spieler::tick( double zeit, Spiel *zSpiel )
         }
         if( tastenStand[ ' ' ] )
             useItem( zSpiel );
+        if( tastenStand[ 'e' ] )
+            zSpiel->spielerActivate( this );
         heilung( lebensRegeneration * (float)zeit, zSpiel );
     }
     else
@@ -379,16 +442,15 @@ void Spieler::useItem( Spiel *zSpiel )
 {
     if( istAmLeben() && inv.selectedItem() != KEIN_GEGENSTAND && istGegenstandErlaubt( inv.selectedItem() ) )
     {
+        zSpiel->setSpielerZuletztGegenstandAktiviert( (Spieler *)getThis() );
         itemsVerwendet++;
         GegenstandTyp typ = inv.useItem();
-        Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
-        e->addParameter( "Betroffener Spieler", getThis() );
-        e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
-        zSpiel->throwEvent( e );
+        zSpiel->setItemZuletztAktiviert( typ );
         switch( typ )
         {
         case PFEIL:
             geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
             zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         case LEBEN:
@@ -405,6 +467,7 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case KUGEL:
             geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
             zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         case ROLLE:
@@ -415,10 +478,12 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case DRACHENAUGE:
             geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
             zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         case FEUERBALL:
             geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
             zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         case ENTERHAKEN:
@@ -426,11 +491,16 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case MINE:
             geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
             zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x, (int)y, (Spieler *)getThis() ) );
             break;
         default:
             break;
         }
+        Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
+        e->addParameter( "Betroffener Spieler", getThis() );
+        e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
+        zSpiel->throwEvent( e );
     }
 }
 
@@ -440,6 +510,8 @@ bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
     {
         if( inv.canAddItem( typ ) )
         {
+            zSpiel->setItemZuletztAufgehoben( typ );
+            zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
             itemsAufgehoben += anz;
             inv.addItem( typ, anz );
             Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
@@ -452,6 +524,8 @@ bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
     }
     else
     {
+        zSpiel->setItemZuletztAufgehoben( typ );
+        zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
         itemsAufgehoben += anz;
         Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
         e->addParameter( "Betroffener Spieler", getThis() );
@@ -493,12 +567,13 @@ bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
 // heilt auch um den lebensraub prozentsatz
 void Spieler::addGemachterSchaden( float schaden, Spiel *zSpiel )
 {
+    zSpiel->setSpielerZuletztSchadenGemacht( (Spieler *)getThis() );
     schadenGemacht += schaden;
+    heilung( schaden / 100 * lebensraub, zSpiel );
     Ereignis *e = new Ereignis( SPIELER_MACHT_SCHADEN );
     e->addParameter( "Betroffener Spieler", getThis() );
     e->addParameter( "Wert", new Float( schaden ) );
     zSpiel->throwEvent( e );
-    heilung( schaden / 100 * lebensraub, zSpiel );
 }
 
 // zieht die rüstung ab
@@ -512,24 +587,26 @@ void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spi
     schaden = leben < schaden ? leben : schaden;
     schadenGenommen += schaden;
     leben -= schaden;
+    zSpiel->setSpielerZuletztSchadenGenommen( (Spieler *)getThis() );
+    if( zVerursacher )
+        zVerursacher->addGemachterSchaden( schaden, zSpiel );
     Ereignis *e = new Ereignis( SPIELER_NIMMT_SCHADEN );
     e->addParameter( "Betroffener Spieler", getThis() );
     e->addParameter( "Wert", new Float( schaden ) );
     zSpiel->throwEvent( e );
-    if( zVerursacher )
-        zVerursacher->addGemachterSchaden( schaden, zSpiel );
     if( leben == 0 )
     {
-        wiederbelebungsZeit = (float)( maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
+        wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
         wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
         team->addTod();
         amLeben = 0;
         tode++;
+        zSpiel->setSpielerZuletztGestorben( (Spieler *)getThis() );
+        if( zVerursacher )
+            zVerursacher->addKill();
         Ereignis *e = new Ereignis( SPIELER_STIRBT );
         e->addParameter( "Betroffener Spieler", getThis() );
         zSpiel->throwEvent( e );
-        if( zVerursacher )
-            zVerursacher->addKill();
     }
 }
 
@@ -539,6 +616,7 @@ void Spieler::heilung( float heal, Spiel *zSpiel )
     {
         lebenGeheilt += heal;
         leben += heal;
+        zSpiel->setSpielerZuletztGeheilt( (Spieler *)getThis() );
         Ereignis *e = new Ereignis( SPIELER_WIRD_GEHEILT );
         e->addParameter( "Betroffener Spieler", getThis() );
         e->addParameter( "Wert", new Float( heal ) );
@@ -576,6 +654,62 @@ void Spieler::setName( const char *name )
     this->name = name;
 }
 
+void Spieler::setLevel( int level, Spiel *zSpiel )
+{
+    if( level < 0 || level > 100 )
+        return;
+    while( level > this->level )
+        levelUp( zSpiel );
+    while( level < this->level )
+        levelDown( zSpiel );
+    erfahrung = 0;
+}
+
+void Spieler::removeItem( GegenstandTyp typ, int anzahl )
+{
+    inv.removeItem( typ, anzahl );
+}
+
+void Spieler::setLeben( float leben )
+{
+    this->leben = leben;
+    if( this->leben < 0 )
+    {
+        this->leben = 0;
+        // the player is now undead :D
+    }
+    if( this->leben > maxLeben )
+        this->leben = (float)maxLeben;
+}
+
+void Spieler::setMaxLeben( int leben )
+{
+    maxLeben = leben;
+    if( maxLeben < 1 )
+        maxLeben = 1;
+    if( this->leben > maxLeben )
+        this->leben = (float)maxLeben;
+}
+
+void Spieler::setErfahrung( float erf, Spiel *zSpiel )
+{
+    erfahrung = erf;
+    while( erfahrung < 0 )
+        levelDown( zSpiel );
+    while( erfahrung >= maxErfahrung )
+        levelUp( zSpiel );
+}
+
+void Spieler::setMaxErfahrung( int erf )
+{
+    this->maxErfahrung = erf;
+}
+
+void Spieler::setAbklingZeitVerringerung( float verringerung )
+{
+    abklingZeitVerringerung = verringerung;
+}
+
 float Spieler::getLebensRegenneration() const
 {
     return lebensRegeneration;

StickmanWorldOnline/Spieler.h

@@ -29,6 +29,7 @@ public:
     int getItemAnzahl() const;
     int getItemAnzahl( GegenstandTyp typ ) const;
     GegenstandTyp getItemTyp( int index ) const;
+    void removeItem( GegenstandTyp typ, int anzahl );
 };
 
 class Spieler : public GameObject
@@ -87,6 +88,10 @@ public:
     void addEffekt( Effect *e );
     void setLaufTempo( float pps );
     void addErfahrung( float anz, Spiel *zSpiel );
+    void levelUp( Spiel *zSpiel );
+    void levelDown( Spiel *zSpiel );
+    void addTunnelBenutzung( Spiel *zSpiel );
+    void addSchalterBenutzung( Spiel *zSpiel );
     // aktualisiert auch die team statistik
     void addKill();
     void addTreffer( Spiel *zSpiel );
@@ -108,12 +113,12 @@ public:
     void setLebensRegeneration( float reg );
     void setName( const char *name );
     // setzt alle eigenschafften, die mit dem level gesetzt werden entsprechend
-    void setLevel( int level );
+    void setLevel( int level, Spiel *zSpiel );
     void removeItem( GegenstandTyp typ, int anzahl );
     void setLeben( float leben );
     void setMaxLeben( int leben );
     // steuert auch level up oder level downs bei negativer erfahrung
-    void setErfahrung( float erf );
+    void setErfahrung( float erf, Spiel *zSpiel );
     void setMaxErfahrung( int erf );
     void setAbklingZeitVerringerung( float verringerung );
     float getLebensRegenneration() const;

StickmanWorldOnline/Team.cpp

@@ -5,7 +5,7 @@ Team::Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit,
     : Variable( TEAM )
 {
     teamNummer = id;
-    this->maxSpielerAnzahl = (float)maxSpielerAnzahl;
+    this->maxSpielerAnzahl = maxSpielerAnzahl;
     spielerAnzahl = 0;
     this->punkte = punkte;
     kills = 0;
@@ -48,6 +48,11 @@ void Team::addPunkte( int punkte )
     this->punkte += punkte;
 }
 
+void Team::setPunkte( int punkte )
+{
+    this->punkte = punkte;
+}
+
 Text Team::getName() const
 {
     return name;

StickmanWorldOnline/Timer.cpp

@@ -69,6 +69,11 @@ void Timer::tick( double time, Spiel *zSpiel )
     }
 }
 
+void Timer::setZeit( float zeit )
+{
+    currentTime = zeit;
+}
+
 float Timer::getTimeLeft() const
 {
     return currentTime;

StickmanWorldOnline/Umlenkung.cpp

@@ -52,7 +52,7 @@ void Umlenkung::addBenutzt()
         case LINKS:
             richtung = OBEN;
             break;
-        case MITTE:
+        default:
             break;
         }
     }
@@ -94,6 +94,11 @@ Richtung Umlenkung::getRichtung() const
     return richtung;
 }
 
+int Umlenkung::getBenutzungen() const
+{
+    return benutzt;
+}
+
 int Umlenkung::getId() const
 {
     return id;

StickmanWorldOnline/Variablen.cpp

@@ -179,6 +179,8 @@ String::String( Richtung r )
     case MITTE:
         value = "MITTE";
         break;
+    default:
+        break;
     }
 }