change array iteration

StickmanWorldOnline/Bestenliste.cpp

@@ -2,7 +2,7 @@
 #include "Initialisierung.h"
 
 
-Bestenliste::Bestenliste( int id, UIInit &uiFactory )
+Bestenliste::Bestenliste( int id, UIInit& uiFactory )
     : Variable( BESTENLISTE )
 {
     this->uiFactory = uiFactory;
@@ -44,26 +44,26 @@ void Bestenliste::setSichtbar( bool sichtbar )
     this->sichtbar = sichtbar;
 }
 
-void Bestenliste::addSpalte( const char *name )
+void Bestenliste::addSpalte( const char* name )
 {
     spalten.add( initTextFeld( 0, 0, -1, -1, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, name ) );
 }
 
-void Bestenliste::addZeile( const char *name )
+void Bestenliste::addZeile( const char* name )
 {
     zeilen.add( initTextFeld( 0, 0, -1, -1, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, name ) );
 }
 
-void Bestenliste::setWert( const char *spalte, const char *zeile, const char *wert )
+void Bestenliste::setWert( const char* spalte, const char* zeile, const char* wert )
 {
     int spalteI = 0;
-    for( auto s = spalten.getIterator(); s; s++, spalteI++ )
+    for( auto s = spalten.begin(); s; s++, spalteI++ )
     {
         if( s->zText() && s->zText()->istGleich( spalte ) )
             break;
     }
     int zeileI = 0;
-    for( auto z = zeilen.getIterator(); z; z++, zeileI++ )
+    for( auto z = zeilen.begin(); z; z++, zeileI++ )
     {
         if( z->zText() && z->zText()->istGleich( zeile ) )
             break;
@@ -73,16 +73,16 @@ void Bestenliste::setWert( const char *spalte, const char *zeile, const char *we
     werte.z( zeileI )->set( initTextFeld( 0, 0, -1, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, wert ), spalteI );
 }
 
-const char *Bestenliste::getWert( const char *spalte, const char *zeile )
+const char* Bestenliste::getWert( const char* spalte, const char* zeile )
 {
     int spalteI = 0;
-    for( auto s = spalten.getIterator(); s; s++, spalteI++ )
+    for( auto s = spalten.begin(); s; s++, spalteI++ )
     {
         if( s->zText() && s->zText()->istGleich( spalte ) )
             break;
     }
     int zeileI = 0;
-    for( auto z = zeilen.getIterator(); z; z++, spalteI++ )
+    for( auto z = zeilen.begin(); z; z++, spalteI++ )
     {
         if( z->zText() && z->zText()->istGleich( zeile ) )
             break;
@@ -92,7 +92,7 @@ const char *Bestenliste::getWert( const char *spalte, const char *zeile )
     return werte.z( zeileI )->z( spalteI )->zText()->getText();
 }
 
-void Bestenliste::render( int x, int y, Bild &rObj )
+void Bestenliste::render( int x, int y, Bild& rObj )
 {
     ram.setPosition( x, y );
     ram.setSize( getBreite(), getHeight() );
@@ -109,7 +109,7 @@ void Bestenliste::render( int x, int y, Bild &rObj )
     {
         rObj.drawLinieV( x++, y, hi - 2, 0xFFFFFFFF );
         int sbr = getSpaltenBreite( i );
-        TextFeld *tf = spalten.z( i );
+        TextFeld* tf = spalten.z( i );
         tf->setSize( sbr, 20 );
         tf->setPosition( x, y );
         tf->render( rObj );
@@ -121,7 +121,7 @@ void Bestenliste::render( int x, int y, Bild &rObj )
     for( int i = 0; i < zeilen.getEintragAnzahl(); i++ )
     {
         rObj.drawLinieH( x, y++, br - 2, 0xFFFFFFFF );
-        TextFeld *tf = zeilen.z( i );
+        TextFeld* tf = zeilen.z( i );
         tf->setSize( ssbr, 20 );
         tf->setPosition( x, y );
         tf->render( rObj );
@@ -129,7 +129,7 @@ void Bestenliste::render( int x, int y, Bild &rObj )
         for( int j = 0; j < spalten.getEintragAnzahl(); j++ )
         {
             int sbr = spaltenBr.get( j );
-            TextFeld *tf = werte.z( i ) ? werte.z( i )->z( j ) : 0;
+            TextFeld* tf = werte.z( i ) ? werte.z( i )->z( j ) : 0;
             if( tf )
             {
                 tf->setSize( sbr, 20 );

StickmanWorldOnline/Ereignis.cpp

@@ -15,14 +15,14 @@ EreignisTyp Ereignis::getTyp() const
     return typ;
 }
 
-void Ereignis::addParameter( const char *name, Variable *var )
+void Ereignis::addParameter( const char* name, Variable* var )
 {
     params.add( new VarPointer( name, var ) );
 }
 
-Variable *Ereignis::getParameter( const char *name ) const
+Variable* Ereignis::getParameter( const char* name ) const
 {
-    for( auto v = params.getIterator(); v; v++ )
+    for( auto v : params )
     {
         if( v->getName().istGleich( name ) )
             return v->getVariable();
@@ -30,9 +30,9 @@ Variable *Ereignis::getParameter( const char *name ) const
     return 0;
 }
 
-Variable *Ereignis::zParameter( const char *name ) const
+Variable* Ereignis::zParameter( const char* name ) const
 {
-    for( auto v = params.getIterator(); v; v++ )
+    for( auto v : params )
     {
         if( v->getName().istGleich( name ) )
             return v->zVariable();

StickmanWorldOnline/Model.cpp

@@ -12,13 +12,13 @@ Model::~Model()
     views->release();
 }
 
-void Model::addView( View *view )
+void Model::addView( View* view )
 {
     views->add( view );
 }
 
 void Model::update()
 {
-    for( auto v = views->getIterator(); v; v++ )
+    for( auto v : *views )
         v->update( this );
 }

StickmanWorldOnline/Reader.cpp

@@ -14,7 +14,7 @@ struct SpielerTeamStruktur
 
 
 // Konstruktor
-MapReader::MapReader( int karteId, char *tmpPfad )
+MapReader::MapReader( int karteId, char* tmpPfad )
     : ReferenceCounter()
 {
     this->karteId = karteId;
@@ -28,11 +28,11 @@ MapReader::~MapReader()
         pfad->release();
 }
 
-Array<int> *MapReader::getSpielerFarben()
+Array<int>* MapReader::getSpielerFarben()
 {
-    Text *pf = new Text( pfad->getText() );
+    Text* pf = new Text( pfad->getText() );
     pf->append( "data.sts" );
-    Datei *datei = new Datei();
+    Datei* datei = new Datei();
     datei->setDatei( pf );
     if( !datei->existiert() || datei->istOrdner() )
     {
@@ -42,13 +42,13 @@ Array<int> *MapReader::getSpielerFarben()
     int spielerAnzahl;
     int teamAnzahl;
     datei->open( Datei::Style::lesen );
-    datei->lese( (char *)&spielerAnzahl, 4 );
-    datei->lese( (char *)&teamAnzahl, 4 );
-    Array< int > *result = new Array< int >();
+    datei->lese( (char*)&spielerAnzahl, 4 );
+    datei->lese( (char*)&teamAnzahl, 4 );
+    Array< int >* result = new Array< int >();
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         int f = 0;
-        datei->lese( (char *)&f, 4 );
+        datei->lese( (char*)&f, 4 );
         result->add( f );
     }
     datei->close();
@@ -56,11 +56,11 @@ Array<int> *MapReader::getSpielerFarben()
     return result;
 }
 
-Array<int> *MapReader::getTeamFarben()
+Array<int>* MapReader::getTeamFarben()
 {
-    Text *pf = new Text( pfad->getText() );
+    Text* pf = new Text( pfad->getText() );
     pf->append( "data.sts" );
-    Datei *datei = new Datei();
+    Datei* datei = new Datei();
     datei->setDatei( pf );
     if( !datei->existiert() || datei->istOrdner() )
     {
@@ -70,18 +70,18 @@ Array<int> *MapReader::getTeamFarben()
     int spielerAnzahl;
     int teamAnzahl;
     datei->open( Datei::Style::lesen );
-    datei->lese( (char *)&spielerAnzahl, 4 );
-    datei->lese( (char *)&teamAnzahl, 4 );
+    datei->lese( (char*)&spielerAnzahl, 4 );
+    datei->lese( (char*)&teamAnzahl, 4 );
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         int f = 0;
-        datei->lese( (char *)&f, 4 );
+        datei->lese( (char*)&f, 4 );
     }
-    Array< int > *result = new Array< int >();
+    Array< int >* result = new Array< int >();
     for( int i = 0; i < teamAnzahl; i++ )
     {
         int f = 0;
-        datei->lese( (char *)&f, 4 );
+        datei->lese( (char*)&f, 4 );
         result->add( f );
     }
     datei->close();
@@ -89,13 +89,13 @@ Array<int> *MapReader::getTeamFarben()
     return result;
 }
 
-Aktion *MapReader::readAktion( StreamReader &dat )
+Aktion* MapReader::readAktion( StreamReader& dat )
 {
     int id;
-    dat.lese( (char *)&id, 4 );
+    dat.lese( (char*)&id, 4 );
     char pAnz = 0;
     dat.lese( &pAnz, 1 );
-    RCArray< Aktion > *params = new RCArray< Aktion >();
+    RCArray< Aktion >* params = new RCArray< Aktion >();
     for( int i = 0; i < pAnz; i++ )
         params->add( readAktion( dat ) );
     switch( id )
@@ -350,35 +350,35 @@ Aktion *MapReader::readAktion( StreamReader &dat )
     {
         params->release();
         bool b;
-        dat.lese( (char *)&b, 1 );
+        dat.lese( (char*)&b, 1 );
         return new KonstantBoolean( b );
     }
     case KONSTANT_FLOAT:
     {
         params->release();
         float f;
-        dat.lese( (char *)&f, 4 );
+        dat.lese( (char*)&f, 4 );
         return new KonstantFloat( f );
     }
     case KONSTANT_INTEGER:
     {
         params->release();
         int i;
-        dat.lese( (char *)&i, 4 );
+        dat.lese( (char*)&i, 4 );
         return new KonstantInteger( i );
     }
     case KONSTANT_GEGENSTAND_TYP:
     {
         params->release();
         int i;
-        dat.lese( (char *)&i, 4 );
+        dat.lese( (char*)&i, 4 );
         return new KonstantGegenstandTyp( (GegenstandTyp)i );
     }
     case KONSTANT_TASTE:
     {
         params->release();
         unsigned char i;
-        dat.lese( (char *)&i, 1 );
+        dat.lese( (char*)&i, 1 );
         return new KonstantTaste( i );
     }
     case KONSTANT_NICHTS:
@@ -389,10 +389,10 @@ Aktion *MapReader::readAktion( StreamReader &dat )
         params->release();
         char len;
         dat.lese( &len, 1 );
-        char *txt = new char[ (__int64)len + 1 ];
+        char* txt = new char[ (__int64)len + 1 ];
         dat.lese( txt, len );
         txt[ (int)len ] = 0;
-        Aktion *ret = new KonstantString( txt );
+        Aktion* ret = new KonstantString( txt );
         delete[] txt;
         return ret;
     }
@@ -401,10 +401,10 @@ Aktion *MapReader::readAktion( StreamReader &dat )
         params->release();
         char len;
         dat.lese( &len, 1 );
-        char *txt = new char[ (__int64)len + 1 ];
+        char* txt = new char[ (__int64)len + 1 ];
         dat.lese( txt, len );
         txt[ (int)len ] = 0;
-        Aktion *ret = new KonstantVariable( txt );
+        Aktion* ret = new KonstantVariable( txt );
         delete[] txt;
         return ret;
     }
@@ -429,10 +429,10 @@ Aktion *MapReader::readAktion( StreamReader &dat )
     {
         char len;
         dat.lese( &len, 1 );
-        char *txt = new char[ (__int64)len + 1 ];
+        char* txt = new char[ (__int64)len + 1 ];
         dat.lese( txt, len );
         txt[ (int)len ] = 0;
-        Aktion *ret = new SetVariable( txt, params );
+        Aktion* ret = new SetVariable( txt, params );
         delete[] txt;
         return ret;
     }
@@ -637,13 +637,13 @@ Aktion *MapReader::readAktion( StreamReader &dat )
     return new KonstantNichts();
 }
 
-void MapReader::writeAktion( Aktion *zAk, StreamWriter &dat )
+void MapReader::writeAktion( Aktion* zAk, StreamWriter& dat )
 {
     int id = zAk->getTyp();
-    dat.schreibe( (char *)&id, 4 );
+    dat.schreibe( (char*)&id, 4 );
     unsigned char pAnz = (unsigned char)zAk->zSubActions()->getEintragAnzahl();
-    dat.schreibe( (char *)&pAnz, 1 );
-    for( auto e = zAk->zSubActions()->getIterator(); e; e++ )
+    dat.schreibe( (char*)&pAnz, 1 );
+    for( auto e : *zAk->zSubActions() )
     {
         writeAktion( e, dat );
         e->writeOptions( dat );
@@ -651,14 +651,14 @@ void MapReader::writeAktion( Aktion *zAk, StreamWriter &dat )
 }
 
 // nicht constant
-void MapReader::ladeKarte( Spiel *zSpiel )
+void MapReader::ladeKarte( Spiel* zSpiel )
 {
     if( !pfad )
         return;
     SpielerTeamStruktur sts;
-    Text *pf = new Text( pfad->getText() );
+    Text* pf = new Text( pfad->getText() );
     pf->append( "data.sts" );
-    Datei *datei = new Datei();
+    Datei* datei = new Datei();
     datei->setDatei( pf );
     if( !datei->existiert() || datei->istOrdner() )
     {
@@ -666,35 +666,35 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         return;
     }
     datei->open( Datei::Style::lesen );
-    datei->lese( (char *)&sts.spielerAnzahl, 4 );
-    datei->lese( (char *)&sts.teamAnzahl, 4 );
+    datei->lese( (char*)&sts.spielerAnzahl, 4 );
+    datei->lese( (char*)&sts.teamAnzahl, 4 );
     for( int i = 0; i < sts.spielerAnzahl; i++ )
     {
         int farbe = 0;
-        datei->lese( (char *)&farbe, 4 );
+        datei->lese( (char*)&farbe, 4 );
         sts.spielerFarbe.set( farbe, i );
     }
     for( int i = 0; i < sts.teamAnzahl; i++ )
     {
         int farbe = 0;
-        datei->lese( (char *)&farbe, 4 );
+        datei->lese( (char*)&farbe, 4 );
         sts.teamFarbe.set( farbe, i );
     }
     for( int i = 0; i < sts.teamAnzahl; i++ )
     {
         char len = 0;
         datei->lese( &len, 1 );
-        char *txt = new char[ (__int64)len + 1 ];
+        char* txt = new char[ (__int64)len + 1 ];
         txt[ (int)len ] = 0;
         datei->lese( txt, len );
-        Text *name = new Text( txt );
+        Text* name = new Text( txt );
         delete[] txt;
         sts.teamName.set( name, i );
     }
     for( int i = 0; i < sts.teamAnzahl; i++ )
     {
         int size = 0;
-        datei->lese( (char *)&size, 4 );
+        datei->lese( (char*)&size, 4 );
         sts.teamSize.set( size, i );
     }
     datei->close();
@@ -709,16 +709,16 @@ void MapReader::ladeKarte( Spiel *zSpiel )
     // map Size
     int width;
     int height;
-    mapFile.lese( (char *)&width, 4 );
-    mapFile.lese( (char *)&height, 4 );
+    mapFile.lese( (char*)&width, 4 );
+    mapFile.lese( (char*)&height, 4 );
     zSpiel->setMapSize( width, height );
     // teams
     for( int i = 0; i < sts.teamAnzahl; i++ )
     {
         int maxWbZeit;
         int punkte;
-        mapFile.lese( (char *)&maxWbZeit, 4 );
-        mapFile.lese( (char *)&punkte, 4 );
+        mapFile.lese( (char*)&maxWbZeit, 4 );
+        mapFile.lese( (char*)&punkte, 4 );
         zSpiel->addTeam( new Team( i, sts.teamSize.get( i ), punkte, maxWbZeit, sts.teamFarbe.get( i ), sts.teamName.z( i )->getText() ) );
     }
     // spieler
@@ -728,8 +728,8 @@ void MapReader::ladeKarte( Spiel *zSpiel )
     {
         int spawnX;
         int spawnY;
-        mapFile.lese( (char *)&spawnX, 4 );
-        mapFile.lese( (char *)&spawnY, 4 );
+        mapFile.lese( (char*)&spawnX, 4 );
+        mapFile.lese( (char*)&spawnY, 4 );
         if( i >= maxT )
         {
             team++;
@@ -740,7 +740,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
     }
     // Barieren
     int anz = 0;
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -752,19 +752,19 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         int autoSchaltungMaxTime;
         int team;
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&breite, 4 );
-        mapFile.lese( (char *)&height, 4 );
-        mapFile.lese( (char *)&style, 4 );
-        mapFile.lese( (char *)&verschiebungWeite, 4 );
-        mapFile.lese( (char *)&autoSchaltungMaxTime, 4 );
-        mapFile.lese( (char *)&team, 4 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&breite, 4 );
+        mapFile.lese( (char*)&height, 4 );
+        mapFile.lese( (char*)&style, 4 );
+        mapFile.lese( (char*)&verschiebungWeite, 4 );
+        mapFile.lese( (char*)&autoSchaltungMaxTime, 4 );
+        mapFile.lese( (char*)&team, 4 );
         zSpiel->addBariere( new Bariere( zSpiel->zResources(), id, x, y, breite, height, style, verschiebungWeite, autoSchaltungMaxTime, zSpiel->getTeam( team ) ) );
     }
     // Basen
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -778,21 +778,21 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         int timerX;
         int timerY;
         int timerFarbe;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&breite, 4 );
-        mapFile.lese( (char *)&height, 4 );
-        mapFile.lese( (char *)&maxTime, 4 );
-        mapFile.lese( (char *)&team, 4 );
-        mapFile.lese( (char *)&showTimer, 1 );
-        mapFile.lese( (char *)&timerX, 4 );
-        mapFile.lese( (char *)&timerY, 4 );
-        mapFile.lese( (char *)&timerFarbe, 4 );
-        zSpiel->addBase( new Base( zSpiel->zResources(), id, x, y, breite, height, showTimer, Punkt( timerX, timerY ), timerFarbe, new TextRenderer( dynamic_cast<Schrift *>( zSpiel->zResources()->getUIFactory().initParam.schrift->getThis() ) ), maxTime, zSpiel->getTeam( team ) ) );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&breite, 4 );
+        mapFile.lese( (char*)&height, 4 );
+        mapFile.lese( (char*)&maxTime, 4 );
+        mapFile.lese( (char*)&team, 4 );
+        mapFile.lese( (char*)&showTimer, 1 );
+        mapFile.lese( (char*)&timerX, 4 );
+        mapFile.lese( (char*)&timerY, 4 );
+        mapFile.lese( (char*)&timerFarbe, 4 );
+        zSpiel->addBase( new Base( zSpiel->zResources(), id, x, y, breite, height, showTimer, Punkt( timerX, timerY ), timerFarbe, new TextRenderer( dynamic_cast<Schrift*>(zSpiel->zResources()->getUIFactory().initParam.schrift->getThis()) ), maxTime, zSpiel->getTeam( team ) ) );
     }
     // Drops
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int minX;
@@ -803,25 +803,25 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         int numDrops;
         float wahrscheinlichkeit[ ITEMANZAHL ];
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&minX, 4 );
-        mapFile.lese( (char *)&minY, 4 );
-        mapFile.lese( (char *)&maxX, 4 );
-        mapFile.lese( (char *)&maxY, 4 );
-        mapFile.lese( (char *)&maxTime, 4 );
-        mapFile.lese( (char *)&numDrops, 4 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&minX, 4 );
+        mapFile.lese( (char*)&minY, 4 );
+        mapFile.lese( (char*)&maxX, 4 );
+        mapFile.lese( (char*)&maxY, 4 );
+        mapFile.lese( (char*)&maxTime, 4 );
+        mapFile.lese( (char*)&numDrops, 4 );
         for( int j = KEIN_GEGENSTAND; j < ITEMANZAHL; j++ )
-            mapFile.lese( (char *)&wahrscheinlichkeit[ j ], 4 );
+            mapFile.lese( (char*)&wahrscheinlichkeit[ j ], 4 );
         char len;
-        mapFile.lese( (char *)&len, 1 );
-        char *name = new char[ (__int64)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (__int64)len + 1 ];
         mapFile.lese( name, len );
         name[ (int)len ] = 0;
         zSpiel->addDrop( new Drop( id, minX, maxX, minY, maxY, maxTime, numDrops, name, wahrscheinlichkeit ) );
         delete[] name;
     }
     // Schalter
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -830,16 +830,16 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         int height;
         bool aktive;
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&breite, 4 );
-        mapFile.lese( (char *)&height, 4 );
-        mapFile.lese( (char *)&aktive, 1 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&breite, 4 );
+        mapFile.lese( (char*)&height, 4 );
+        mapFile.lese( (char*)&aktive, 1 );
         zSpiel->addSchalter( new Schalter( zSpiel->zResources(), id, x, y, breite, height, aktive ) );
     }
     // Schiene
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -847,15 +847,15 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         int breite;
         int height;
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&breite, 4 );
-        mapFile.lese( (char *)&height, 4 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&breite, 4 );
+        mapFile.lese( (char*)&height, 4 );
         zSpiel->addSchiene( new Schiene( zSpiel->zResources(), id, x, y, breite, height ) );
     }
     // Timer
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -866,24 +866,24 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         bool runns;
         int farbe;
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&maxZeit, 4 );
-        mapFile.lese( (char *)&sichtbar, 1 );
-        mapFile.lese( (char *)&autoWiederhohlung, 1 );
-        mapFile.lese( (char *)&runns, 1 );
-        mapFile.lese( (char *)&farbe, 4 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&maxZeit, 4 );
+        mapFile.lese( (char*)&sichtbar, 1 );
+        mapFile.lese( (char*)&autoWiederhohlung, 1 );
+        mapFile.lese( (char*)&runns, 1 );
+        mapFile.lese( (char*)&farbe, 4 );
         char len;
-        mapFile.lese( (char *)&len, 1 );
-        char *name = new char[ (__int64)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (__int64)len + 1 ];
         mapFile.lese( name, len );
         name[ (int)len ] = 0;
         zSpiel->addTimer( new Timer( zSpiel->zResources()->getUIFactory().initParam.schrift, id, name, maxZeit, x, y, sichtbar, autoWiederhohlung, runns, farbe ) );
         delete[] name;
     }
     // Tunnel
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -894,18 +894,18 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         int zielY;
         bool aktiv;
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&breite, 4 );
-        mapFile.lese( (char *)&height, 4 );
-        mapFile.lese( (char *)&zielX, 4 );
-        mapFile.lese( (char *)&zielY, 4 );
-        mapFile.lese( (char *)&aktiv, 1 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&breite, 4 );
+        mapFile.lese( (char*)&height, 4 );
+        mapFile.lese( (char*)&zielX, 4 );
+        mapFile.lese( (char*)&zielY, 4 );
+        mapFile.lese( (char*)&aktiv, 1 );
         zSpiel->addTunnel( new Tunnel( zSpiel->zResources(), id, x, y, breite, height, zielX, zielY, aktiv ) );
     }
     // Umlenkungen
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int x;
@@ -917,60 +917,60 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         bool drehend;
         bool aktiv;
         int id;
-        mapFile.lese( (char *)&id, 4 );
-        mapFile.lese( (char *)&x, 4 );
-        mapFile.lese( (char *)&y, 4 );
-        mapFile.lese( (char *)&breite, 4 );
-        mapFile.lese( (char *)&height, 4 );
-        mapFile.lese( (char *)&richtung, 1 );
-        mapFile.lese( (char *)&maxAbklingzeit, 4 );
-        mapFile.lese( (char *)&drehend, 1 );
-        mapFile.lese( (char *)&aktiv, 1 );
+        mapFile.lese( (char*)&id, 4 );
+        mapFile.lese( (char*)&x, 4 );
+        mapFile.lese( (char*)&y, 4 );
+        mapFile.lese( (char*)&breite, 4 );
+        mapFile.lese( (char*)&height, 4 );
+        mapFile.lese( (char*)&richtung, 1 );
+        mapFile.lese( (char*)&maxAbklingzeit, 4 );
+        mapFile.lese( (char*)&drehend, 1 );
+        mapFile.lese( (char*)&aktiv, 1 );
         zSpiel->addUmlenkung( new Umlenkung( zSpiel->zResources(), id, x, y, breite, height, (Richtung)richtung, maxAbklingzeit, drehend, aktiv ) );
     }
     // Trigger
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int id;
-        mapFile.lese( (char *)&id, 4 );
+        mapFile.lese( (char*)&id, 4 );
         char len;
-        mapFile.lese( (char *)&len, 1 );
-        char *name = new char[ (__int64)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (__int64)len + 1 ];
         mapFile.lese( name, len );
         name[ (int)len ] = 0;
         int ereignisAnzahl;
         int bedingungAnzahl;
         int aktionAnzahl;
-        mapFile.lese( (char *)&ereignisAnzahl, 4 );
-        mapFile.lese( (char *)&bedingungAnzahl, 4 );
-        mapFile.lese( (char *)&aktionAnzahl, 4 );
-        EreignisTyp *ereignisse = new EreignisTyp[ ereignisAnzahl ];
+        mapFile.lese( (char*)&ereignisAnzahl, 4 );
+        mapFile.lese( (char*)&bedingungAnzahl, 4 );
+        mapFile.lese( (char*)&aktionAnzahl, 4 );
+        EreignisTyp* ereignisse = new EreignisTyp[ ereignisAnzahl ];
         for( int j = 0; j < ereignisAnzahl; j++ )
-            mapFile.lese( (char *)&ereignisse[ j ], 4 );
-        RCArray< Bedingung > *bedingungen = new RCArray< Bedingung >();
+            mapFile.lese( (char*)&ereignisse[ j ], 4 );
+        RCArray< Bedingung >* bedingungen = new RCArray< Bedingung >();
         for( int j = 0; j < bedingungAnzahl; j++ )
             bedingungen->add( new Bedingung( readAktion( mapFile ) ) );
-        RCArray< Aktion > *aktionen = new RCArray< Aktion >();
+        RCArray< Aktion >* aktionen = new RCArray< Aktion >();
         for( int j = 0; j < aktionAnzahl; j++ )
             aktionen->add( readAktion( mapFile ) );
         zSpiel->addTrigger( new Trigger( id, name, ereignisAnzahl, ereignisse, bedingungen, aktionen ) );
         delete[] name;
     }
     // Variablen
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         char len;
-        mapFile.lese( (char *)&len, 1 );
-        char *name = new char[ (__int64)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (__int64)len + 1 ];
         mapFile.lese( name, len );
         name[ (int)len ] = 0;
         char typ;
         mapFile.lese( &typ, 1 );
         char def;
         mapFile.lese( &def, 1 );
-        Variable *var = 0;
+        Variable* var = 0;
         if( !def )
             var = new Variable( NICHTS );
         else
@@ -983,22 +983,22 @@ void MapReader::ladeKarte( Spiel *zSpiel )
             case INTEGER:
             {
                 int val;
-                mapFile.lese( (char *)&val, 4 );
+                mapFile.lese( (char*)&val, 4 );
                 var = new Integer( val );
                 break;
             }
             case BOOLEAN:
             {
                 bool val;
-                mapFile.lese( (char *)&val, 1 );
+                mapFile.lese( (char*)&val, 1 );
                 var = new Boolean( val );
                 break;
             }
             case STRING:
             {
                 char len;
-                mapFile.lese( (char *)&len, 1 );
-                char *value = new char[ (__int64)len + 1 ];
+                mapFile.lese( (char*)&len, 1 );
+                char* value = new char[ (__int64)len + 1 ];
                 mapFile.lese( value, len );
                 value[ (int)len ] = 0;
                 var = new String( value );
@@ -1008,8 +1008,8 @@ void MapReader::ladeKarte( Spiel *zSpiel )
             case RICHTUNG:
             {
                 char len;
-                mapFile.lese( (char *)&len, 1 );
-                char *value = new char[ (__int64)len + 1 ];
+                mapFile.lese( (char*)&len, 1 );
+                char* value = new char[ (__int64)len + 1 ];
                 mapFile.lese( value, len );
                 value[ (int)len ] = 0;
                 var = new String( getRichtungFromString( Text( value ) ) );
@@ -1019,7 +1019,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
             case FLOAT:
             {
                 float val;
-                mapFile.lese( (char *)&val, 4 );
+                mapFile.lese( (char*)&val, 4 );
                 var = new Float( val );
                 break;
             }
@@ -1033,77 +1033,77 @@ void MapReader::ladeKarte( Spiel *zSpiel )
             case SPIELER:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getSpieler( id );
                 break;
             }
             case TIMER:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getTimer( id );
                 break;
             }
             case TEAM:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getTeam( id );
                 break;
             }
             case BARIERE:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getBariere( id );
                 break;
             }
             case SCHALTER:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getSchalter( id );
                 break;
             }
             case BASE:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getBase( id );
                 break;
             }
             case GEGENSTAND:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = new GegenstandTypVar( (GegenstandTyp)id );
                 break;
             }
             case SCHIENE:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getSchiene( id );
                 break;
             }
             case TUNNEL:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getTunnel( id );
                 break;
             }
             case UMLENKUNG:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getUmlenkung( id );
                 break;
             }
             case TRIGGER:
             {
                 int id;
-                mapFile.lese( (char *)&id, 4 );
+                mapFile.lese( (char*)&id, 4 );
                 var = zSpiel->getTrigger( id );
                 break;
             }

StickmanWorldOnline/Resource.cpp

@@ -6,9 +6,9 @@ ColorMode::ColorMode()
     : ReferenceCounter()
 {}
 
-Bild *ColorMode::colorImage( Bild *zImg, int color )
+Bild* ColorMode::colorImage( Bild* zImg, int color )
 {
-    Bild *result = new Bild();
+    Bild* result = new Bild();
     result->neuBild( zImg->getBreite(), zImg->getHeight(), 0 );
     result->drawBild( 0, 0, zImg->getBreite(), zImg->getHeight(), *zImg );
     return result;
@@ -20,10 +20,10 @@ AlphaColorMode::AlphaColorMode( unsigned char alpha )
     this->alpha = alpha;
 }
 
-Bild *AlphaColorMode::colorImage( Bild *zImg, int color )
+Bild* AlphaColorMode::colorImage( Bild* zImg, int color )
 {
-    Bild *result = ColorMode::colorImage( zImg, color );
-    result->alphaRegion( 0, 0, result->getBreite(), result->getHeight(), ( (int)alpha << 24 ) | ( color & 0xFFFFFF ) );
+    Bild* result = ColorMode::colorImage( zImg, color );
+    result->alphaRegion( 0, 0, result->getBreite(), result->getHeight(), ((int)alpha << 24) | (color & 0xFFFFFF) );
     return result;
 }
 
@@ -33,15 +33,15 @@ MaskColorMode::MaskColorMode( int colorToReplace )
     this->colorToReplace = colorToReplace;
 }
 
-Bild *MaskColorMode::colorImage( Bild *zImg, int color )
+Bild* MaskColorMode::colorImage( Bild* zImg, int color )
 {
-    Bild *result = ColorMode::colorImage( zImg, color );
-    int *buffer = result->getBuffer();
+    Bild* result = ColorMode::colorImage( zImg, color );
+    int* buffer = result->getBuffer();
     int size = result->getBreite() * result->getHeight();
     for( int i = 0; i < size; i++ )
     {
-        if( ( buffer[ i ] & 0xFFFFFF ) == colorToReplace )
-            buffer[ i ] = ( buffer[ i ] & 0xFF000000 ) | ( color & 0xFFFFFF );
+        if( (buffer[ i ] & 0xFFFFFF) == colorToReplace )
+            buffer[ i ] = (buffer[ i ] & 0xFF000000) | (color & 0xFFFFFF);
     }
     return result;
 }
@@ -54,18 +54,18 @@ Resource::Resource( ResourceId id, int color )
     this->color = color;
 }
 
-Resource *Resource::createColoredResource( int color, ColorMode *mode ) const
+Resource* Resource::createColoredResource( int color, ColorMode* mode ) const
 {
-    Resource *r = new Resource( id, color );
-    for( auto i = images.getIterator(); i; i++ )
+    Resource* r = new Resource( id, color );
+    for( auto i : images )
         r->images.add( mode->colorImage( i, color ) );
     mode->release();
     return r;
 }
 
-Iterator< Bild * > Resource::getImages() const
+Iterator< Bild* > Resource::getImages() const
 {
-    return images.getIterator();
+    return images.begin();
 }
 
 ResourceId Resource::getId() const
@@ -78,12 +78,12 @@ int Resource::getColor() const
     return color;
 }
 
-Bild *Resource::zImage( int id ) const
+Bild* Resource::zImage( int id ) const
 {
     return images.z( id );
 }
 
-Bild *Resource::getImage( int id ) const
+Bild* Resource::getImage( int id ) const
 {
     return images.get( id );
 }
@@ -104,27 +104,27 @@ ResourceRegistry::ResourceRegistry( Text spielPfad, Text mapPfad )
 ResourceRegistry::~ResourceRegistry()
 {}
 
-void ResourceRegistry::setUIFactory( UIInit &uiFactory )
+void ResourceRegistry::setUIFactory( UIInit& uiFactory )
 {
     this->uiFactory = uiFactory;
 }
 
-UIInit &ResourceRegistry::getUIFactory()
+UIInit& ResourceRegistry::getUIFactory()
 {
     return uiFactory;
 }
 
-Resource *ResourceRegistry::getResource( ResourceId id, int color, ColorMode *mode, Text path )
+Resource* ResourceRegistry::getResource( ResourceId id, int color, ColorMode* mode, Text path )
 {
-    Resource *r = zResource( id, color, mode, path );
-    return r ? dynamic_cast<Resource *>( r->getThis() ) : 0;
+    Resource* r = zResource( id, color, mode, path );
+    return r ? dynamic_cast<Resource*>(r->getThis()) : 0;
 }
 
-Resource *ResourceRegistry::zResource( ResourceId id, int color, ColorMode *mode, Text path )
+Resource* ResourceRegistry::zResource( ResourceId id, int color, ColorMode* mode, Text path )
 {
     path.ersetzen( "map:", mapPfad );
     path.ersetzen( "spiel:", spielPfad );
-    for( auto r = resources.getIterator(); r; r++ )
+    for( auto r : resources )
     {
         if( r->getId() == id && r->getColor() == color )
         {
@@ -135,11 +135,11 @@ Resource *ResourceRegistry::zResource( ResourceId id, int color, ColorMode *mode
     }
     if( !mode )
         return 0;
-    for( auto r = resources.getIterator(); r; r++ )
+    for( auto r : resources )
     {
         if( r->getId() == id )
         {
-            Resource *nr = r->createColoredResource( color, mode );
+            Resource* nr = r->createColoredResource( color, mode );
             resources.add( nr );
             return nr;
         }
@@ -148,10 +148,10 @@ Resource *ResourceRegistry::zResource( ResourceId id, int color, ColorMode *mode
     {
         LTDBDatei dat;
         dat.setDatei( path.getTeilText( 0, path.positionVon( ".ltdb/", path.anzahlVon( ".ltdb/" ) - 1 ) + 5 ) );
-        Bild *b = dat.laden( 0, path.getTeilText( path.positionVon( ".ltdb/", path.anzahlVon( ".ltdb/" ) - 1 ) + 6 ) );
+        Bild* b = dat.laden( 0, path.getTeilText( path.positionVon( ".ltdb/", path.anzahlVon( ".ltdb/" ) - 1 ) + 6 ) );
         if( b )
         {
-            Resource *r = new Resource( id, color );
+            Resource* r = new Resource( id, color );
             resources.add( r );
             r->images.add( mode->colorImage( b, color ) );
             b->release();
@@ -162,18 +162,18 @@ Resource *ResourceRegistry::zResource( ResourceId id, int color, ColorMode *mode
         return 0;
     }
     LTDBDatei dat;
-    dat.setDatei( dynamic_cast<Text *>( path.getThis() ) );
+    dat.setDatei( dynamic_cast<Text*>(path.getThis()) );
     dat.leseDaten( 0 );
     if( !dat.getBildAnzahl() )
     {
         mode->release();
         return 0;
     }
-    Resource *r = new Resource( id, color );
+    Resource* r = new Resource( id, color );
     resources.add( r );
     for( int i = 0; i < dat.getBildAnzahl(); i++ )
     {
-        Bild *b = dat.laden( 0, dat.zBildListe()->get( i ) );
+        Bild* b = dat.laden( 0, dat.zBildListe()->get( i ) );
         r->images.add( mode->colorImage( b, color ) );
         b->release();
     }

StickmanWorldOnline/Spiel.cpp

@@ -167,15 +167,15 @@ void Spiel::tick()
     {
         nextAutoVerschiebung += 30 + randG.rand() * 30;
         int anz = 0;
-        for( auto b = barieren.getIterator(); b; b++ )
+        for( auto b : barieren )
         {
             if( b->hatStyle( Bariere::Style::AutoVerschiebung ) )
                 anz++;
         }
         if( anz )
         {
-            int rand = (int)( randG.rand() * anz );
-            for( auto b = barieren.getIterator(); b; b++ )
+            int rand = (int)(randG.rand() * anz);
+            for( auto b : barieren )
             {
                 if( b->hatStyle( Bariere::Style::AutoVerschiebung ) )
                 {
@@ -193,15 +193,15 @@ void Spiel::tick()
     {
         nextAutoSchaltung += 30 + randG.rand() * 30;
         int anz = 0;
-        for( auto b = barieren.getIterator(); b; b++ )
+        for( auto b : barieren )
         {
             if( b->hatStyle( Bariere::Style::AutoSchaltung ) )
                 anz++;
         }
         if( anz )
         {
-            int rand = (int)( randG.rand() * anz );
-            for( auto b = barieren.getIterator(); b; b++ )
+            int rand = (int)(randG.rand() * anz);
+            for( auto b : barieren )
             {
                 if( b->hatStyle( Bariere::Style::AutoSchaltung ) )
                 {
@@ -230,7 +230,7 @@ void Spiel::tick()
         }
     }
     Richtung rs[] = { OBEN, RECHTS, UNTEN, LINKS };
-    for( auto s = spieler.getIterator(); s; s++ )
+    for( auto s : spieler )
     {
         for( Richtung r : rs )
         {
@@ -239,28 +239,28 @@ void Spiel::tick()
                 s->move( r, -zeit );
             else
             {
-                for( auto b = barieren.getIterator(); b; b++ )
+                for( auto b : barieren )
                 { // spieler - bariere intersection
-                    if( b->hatStyle( Bariere::Style::Aktiv ) && ( b->zTeam() != s->zTeam() ) && b->intersectsWith( s ) )
+                    if( b->hatStyle( Bariere::Style::Aktiv ) && (b->zTeam() != s->zTeam()) && b->intersectsWith( s ) )
                         s->move( r, -zeit );
                 }
             }
         }
     }
-    for( auto s = spieler.getIterator(); s; s++ )
+    for( auto s : spieler )
         s->tick( zeit, this );
     // barieren bewegung
-    for( auto b = barieren.getIterator(); b; b++ )
+    for( auto b : barieren )
         b->tick( zeit, this );
     // geschoss bewegung
     for( int i = 0; i < shots.getEintragAnzahl(); i++ )
     {
-        Geschoss *g = shots.z( i );
+        Geschoss* g = shots.z( i );
         g->tick( zeit );
         bool removed = 0;
         // geschoss - bariere intersection
         bool intersectsWithBariere = 0;
-        for( auto b = barieren.getIterator(); b; b++ )
+        for( auto b : barieren )
         {
             if( b->hatStyle( Bariere::Style::Aktiv ) && b->intersectsWith( g ) )
             {
@@ -272,7 +272,7 @@ void Spiel::tick()
         {
             if( zuletztBariereGetroffenesGeschoss )
                 zuletztBariereGetroffenesGeschoss->release();
-            zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss *>( g->getThis() );
+            zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss*>(g->getThis());
             g->tick( -zeit );
             switch( g->getTyp() )
             {
@@ -297,7 +297,7 @@ void Spiel::tick()
                     g->invertDirection();
                 break;
             case GESCHOSS_MINE:
-                for( auto s = spieler.getIterator(); s; s++ )
+                for( auto s : spieler )
                 {
                     if( s->abstandZu( g ) < 50 )
                     {
@@ -316,23 +316,23 @@ void Spiel::tick()
         }
         if( !removed )
         { // geschoss - tunnel intersection
-            for( auto t = tunnel.getIterator(); t; t++ )
+            for( auto t : tunnel )
             {
                 if( t->istAktiv() && t->intersectsWith( g ) )
                 {
                     g->setX( g->getX() + (float)t->getZielX() - t->getX() );
                     g->setY( g->getY() + (float)t->getZielY() - t->getY() );
                     g->addTunnel( this );
-                    Ereignis *e = new Ereignis( TUNNEL_BENUTZT );
-                    e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss *>( g->getThis() ) );
-                    e->addParameter( "Betroffer Tunnel", dynamic_cast<Tunnel *>( t->getThis() ) );
+                    Ereignis* e = new Ereignis( TUNNEL_BENUTZT );
+                    e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss*>(g->getThis()) );
+                    e->addParameter( "Betroffer Tunnel", dynamic_cast<Tunnel*>(t->getThis()) );
                     throwEvent( e );
                 }
             }
             // geschoss - schalter intersection
             if( g->getTyp() == GESCHOSS_PFEIL )
             {
-                for( auto s = schalter.getIterator(); s; s++ )
+                for( auto s : schalter )
                 {
                     if( s->isAktive() && s->intersectsWith( g ) )
                     {
@@ -350,16 +350,16 @@ void Spiel::tick()
                 // geschoss - umlenkung intersection
                 if( g->getTyp() != GESCHOSS_PFEIL )
                 {
-                    for( auto u = umlenkungen.getIterator(); u; u++ )
+                    for( auto u : umlenkungen )
                     {
                         if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
                         {
                             g->setRichtung( u->getRichtung() );
                             g->addUmlenkung( this );
                             u->addBenutzt( this );
-                            Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
-                            e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss *>( g->getThis() ) );
-                            e->addParameter( "Betroffe Umlenkung", dynamic_cast<Umlenkung *>( u->getThis() ) );
+                            Ereignis* e = new Ereignis( UMLENKUNG_LENKT_UM );
+                            e->addParameter( "Betroffes Geschoss", dynamic_cast<Geschoss*>(g->getThis()) );
+                            e->addParameter( "Betroffe Umlenkung", dynamic_cast<Umlenkung*>(u->getThis()) );
                             throwEvent( e );
                         }
                     }
@@ -371,7 +371,7 @@ void Spiel::tick()
                     {
                         if( i == j )
                             continue;
-                        Geschoss *g2 = shots.z( j );
+                        Geschoss* g2 = shots.z( j );
                         if( g2->intersectsWith( g ) )
                         {
                             addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 20, g->getY() + g->getHeight() / 2 - 20, 40, 40, resources->getResource( R_EXPLOSION, 0 ) ) );
@@ -393,7 +393,7 @@ void Spiel::tick()
                 if( !removed )
                 {
                     // geschoss - spieler intersection
-                    for( auto s = spieler.getIterator(); s; s++ )
+                    for( auto s : spieler )
                     {
                         if( s->istAmLeben() && g->intersectsWith( s ) )
                         {
@@ -412,14 +412,14 @@ void Spiel::tick()
                             }
                             case GESCHOSS_DRACHENAUGE:
                                 addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 25, g->getY() + g->getHeight() / 2 - 25, 50, 50, resources->getResource( R_EXPLOSION, 0 ) ) );
-                                s->addEffekt( new DrachenAugeEffect( resources, g->zBesitzer(), s._ ) );
+                                s->addEffekt( new DrachenAugeEffect( resources, g->zBesitzer(), s ) );
                                 break;
                             case GESCHOSS_FEUERBALL:
                                 feuer.add( new FeuerballTreffer( resources, ++nextId, (int)g->getX() - (int)g->getWidth() / 2, (int)g->getY() - (int)g->getHeight() / 2, g->getBesitzer(), 10 ) );
                                 break;
                             case GESCHOSS_MINE:
                                 addAnimation( new SingleAnimation( g->getX() + g->getWidth() / 2 - 50, g->getY() + g->getHeight() / 2 - 50, 100, 100, resources->getResource( R_EXPLOSION, 0 ) ) );
-                                for( auto s2 = spieler.getIterator(); s2; s2++ )
+                                for( auto s2 : spieler )
                                 {
                                     if( s2->abstandZu( g ) < 50 )
                                     {
@@ -450,7 +450,7 @@ void Spiel::tick()
     // Feuer Ticks
     for( int i = 0; i < feuer.getEintragAnzahl(); i++ )
     {
-        FeuerballTreffer *f = feuer.z( i );
+        FeuerballTreffer* f = feuer.z( i );
         f->tick( zeit );
         if( f->isOver() )
         {
@@ -460,7 +460,7 @@ void Spiel::tick()
         }
         if( f->makeDamage() )
         {
-            for( auto s = spieler.getIterator(); s; s++ )
+            for( auto s : spieler )
             {
                 if( s->abstandZu( f ) < f->getWidth() / 2 )
                     s->addEffekt( new BrandEffekt( resources, f->zVerursacher(), s ) );
@@ -468,23 +468,23 @@ void Spiel::tick()
         }
     }
     // Drop Ticks
-    for( auto d = drops.getIterator(); d; d++ )
+    for( auto d : drops )
         d->tick( zeit, this );
     // Timer Ticks
-    for( auto t = timer.getIterator(); t; t++ )
+    for( auto t : timer )
         t->tick( zeit, this );
     // Umlenkung Ticks
-    for( auto u = umlenkungen.getIterator(); u; u++ )
+    for( auto u : umlenkungen )
         u->tick( zeit );
     // Base Ticks
-    for( auto b = basen.getIterator(); b; b++ )
+    for( auto b : basen )
         b->tick( zeit, this );
     // aktive trigger Ticks
     for( int i = 0; i < triggerRuns.getEintragAnzahl(); i++ )
     {
         if( !triggerRuns.z( i )->runNext( zeit ) )
         {
-            Ereignis *e = new Ereignis( AUSLOESER_RUNNED );
+            Ereignis* e = new Ereignis( AUSLOESER_RUNNED );
             e->addParameter( "Betroffener Auslöser", triggerRuns.z( i )->getTrigger() );
             throwEvent( e );
             triggerRuns.remove( i );
@@ -493,9 +493,9 @@ void Spiel::tick()
     }
 }
 
-Spieler *Spiel::zEigenerSpieler() const
+Spieler* Spiel::zEigenerSpieler() const
 {
-    for( auto s = spieler.getIterator(); s; s++ )
+    for( auto s : spieler )
     {
         if( s->getId() == spielerNummer )
             return s;
@@ -503,9 +503,9 @@ Spieler *Spiel::zEigenerSpieler() const
     return 0;
 }
 
-Team *Spiel::zEigenesTeam() const
+Team* Spiel::zEigenesTeam() const
 {
-    Spieler *s = zEigenerSpieler();
+    Spieler* s = zEigenerSpieler();
     return s ? s->zTeam() : 0;
 }
 
@@ -521,13 +521,13 @@ void Spiel::unlock()
 }
 
 // call 3
-void Spiel::setUIFactory( UIInit &uiFactory )
+void Spiel::setUIFactory( UIInit& uiFactory )
 {
     this->uiFactory = uiFactory;
     chat = new SpielChat( uiFactory );
 }
 
-void Spiel::nachricht( int län, char *bytes )
+void Spiel::nachricht( int län, char* bytes )
 {
     lock();
     stkn->add( new STKNachricht( län, bytes ) );
@@ -535,7 +535,7 @@ void Spiel::nachricht( int l
 }
 
 // call 2
-void Spiel::setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient )
+void Spiel::setKlients( KSGClient::InformationServerClient* infoKlient, KSGClient::SpielServerClient* spielKlient )
 {
     if( this->infoKlient )
         this->infoKlient->release();
@@ -555,7 +555,7 @@ void Spiel::setKarteId( int karteId )
 void Spiel::ladeDaten()
 {
     Sleep( 1000 );
-    Text *gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
+    Text* gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
     Text mapPf = Text( "data/tmp/Karten/" ) + karteId + "/spiel/files";
     // loading resources
     if( resources )
@@ -624,35 +624,35 @@ void Spiel::ladeDaten()
     resources->zResource( R_GUI_SPIELER, 0, new ColorMode(), "spiel:/bilder/gui.ltdb/spieler.png" );
     spielKlient->setLadenProzent( 20 );
 
-    MapReader *reader = new MapReader( karteId, Text( "data/tmp/Karten/" ) + karteId + "/spiel/data/" );
+    MapReader* reader = new MapReader( karteId, Text( "data/tmp/Karten/" ) + karteId + "/spiel/data/" );
     // apply team color filters
-    Array<int> *colors = reader->getTeamFarben();
-    AlphaColorMode *alphaMode = new AlphaColorMode( 0x77 );
-    for( auto c = colors->getIterator(); c; c++ )
+    Array<int>* colors = reader->getTeamFarben();
+    AlphaColorMode* alphaMode = new AlphaColorMode( 0x77 );
+    for( auto c : *colors )
     {
-        resources->zResource( R_BARIERE, c._, dynamic_cast<AlphaColorMode *>( alphaMode->getThis() ) );
-        resources->zResource( R_BASE, c._, dynamic_cast<AlphaColorMode *>( alphaMode->getThis() ) );
+        resources->zResource( R_BARIERE, c, dynamic_cast<AlphaColorMode*>(alphaMode->getThis()) );
+        resources->zResource( R_BASE, c, dynamic_cast<AlphaColorMode*>(alphaMode->getThis()) );
     }
     colors->release();
     alphaMode->release();
     spielKlient->setLadenProzent( 35 );
     // apply player color filters
     colors = reader->getSpielerFarben();
-    MaskColorMode *maskMode = new MaskColorMode( 0xFFFFFF );
-    for( auto c = colors->getIterator(); c; c++ )
+    MaskColorMode* maskMode = new MaskColorMode( 0xFFFFFF );
+    for( auto c : *colors )
     {
-        resources->zResource( R_ROLLE_OBEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_ROLLE_LINKS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_ROLLE_RECHTS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_ROLLE_UNTEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_STURM_OBEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_STURM_LINKS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_STURM_RECHTS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_STURM_UNTEN, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_SPIELER_STIRBT, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_SPIELER, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_SPIELER_RECHTS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
-        resources->zResource( R_SPIELER_LINKS, c._, dynamic_cast<MaskColorMode *>( maskMode->getThis() ) );
+        resources->zResource( R_ROLLE_OBEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_ROLLE_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_ROLLE_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_ROLLE_UNTEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_STURM_OBEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_STURM_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_STURM_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_STURM_UNTEN, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_SPIELER_STIRBT, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_SPIELER, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_SPIELER_RECHTS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
+        resources->zResource( R_SPIELER_LINKS, c, dynamic_cast<MaskColorMode*>(maskMode->getThis()) );
     }
     colors->release();
     spielKlient->setLadenProzent( 50 );
@@ -667,7 +667,7 @@ void Spiel::ladeDaten()
     gamePath->release();
 }
 
-void Spiel::doPublicMausEreignis( MausEreignis &me )
+void Spiel::doPublicMausEreignis( MausEreignis& me )
 {
     if( me.verarbeitet || !begonnen )
         return;
@@ -680,7 +680,7 @@ void Spiel::doPublicMausEreignis( MausEreignis &me )
         chat->doPublicMausEreignis( me );
 }
 
-void Spiel::doTastaturEreignis( TastaturEreignis &te )
+void Spiel::doTastaturEreignis( TastaturEreignis& te )
 {
     if( te.verarbeitet || !begonnen )
         return;
@@ -715,25 +715,25 @@ void Spiel::stknVerarbeitung()
     lock();
     while( stkn->getEintragAnzahl() )
     {
-        STKNachricht *n = stkn->z( 0 );
-        char *msg = n->getNachricht();
+        STKNachricht* n = stkn->z( 0 );
+        char* msg = n->getNachricht();
         switch( *msg )
         {
         case 1: // initialisation
         {
-            spielerAnzahl = (int)*( msg + 1 );
+            spielerAnzahl = (int)*(msg + 1);
             for( int i = 0; i < spielerAnzahl; i++ )
             {
-                int sId = *(int *)( msg + 2 + (__int64)i * 8 );
-                int aId = *(int *)( msg + 6 + (__int64)i * 8 );
-                for( auto s = spieler.getIterator(); s; s++ )
+                int sId = *(int*)(msg + 2 + (__int64)i * 8);
+                int aId = *(int*)(msg + 6 + (__int64)i * 8);
+                for( auto s : spieler )
                 {
                     if( s->getId() == sId )
                     {
                         s->setAccount( aId );
                         if( aId != 0 )
                         {
-                            Text *t = infoKlient->getSpielerName( aId );
+                            Text* t = infoKlient->getSpielerName( aId );
                             s->setName( t->getText() );
                             t->release();
                         }
@@ -741,17 +741,17 @@ void Spiel::stknVerarbeitung()
                     }
                 }
             }
-            __int64 seed = *(__int64 *)( msg + 2 + (__int64)spielerAnzahl * 8 );
+            __int64 seed = *(__int64*)(msg + 2 + (__int64)spielerAnzahl * 8);
             randG.setSeed( seed );
             n->setVerarbeitet();
             break;
         }
         case 2: // spielernummer
-            spielerNummer = *(int *)( msg + 1 );
-            for( auto s = spieler.getIterator(); s; s++ )
+            spielerNummer = *(int*)(msg + 1);
+            for( auto s : spieler )
             {
                 if( s->getId() == spielerNummer )
-                    spielerGUI->setSpieler( dynamic_cast<Spieler *>( s->getThis() ) );
+                    spielerGUI->setSpieler( dynamic_cast<Spieler*>(s->getThis()) );
             }
             n->setVerarbeitet();
             break;
@@ -763,18 +763,18 @@ void Spiel::stknVerarbeitung()
             break;
         case 4: // tasten stand
         {
-            char taste = *(char *)( msg + 1 );
-            char aktiv = *(char *)( msg + 2 );
-            int sId = *(int *)( msg + 3 );
-            for( auto s = spieler.getIterator(); s; s++ )
+            char taste = *(char*)(msg + 1);
+            char aktiv = *(char*)(msg + 2);
+            int sId = *(int*)(msg + 3);
+            for( auto s : spieler )
             {
                 if( s->getId() == sId )
                 {
                     if( s->setTastenStand( taste, aktiv ) )
                     {
-                        Ereignis *e = new Ereignis( aktiv ? SPIELER_KEY_PRESSED : SPIELER_KEY_RELEASED );
+                        Ereignis* e = new Ereignis( aktiv ? SPIELER_KEY_PRESSED : SPIELER_KEY_RELEASED );
                         e->addParameter( "Betroffene Taste", new Integer( taste, 1 ) );
-                        e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler *>( s->getThis() ) );
+                        e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler*>(s->getThis()) );
                         throwEvent( e );
                     }
                     break;
@@ -795,7 +795,7 @@ void Spiel::stknVerarbeitung()
             break;
         case 7: // chat nachricht
         {
-            char *buf = new char[ (__int64)n->getLength() ];
+            char* buf = new char[ (__int64)n->getLength() ];
             memcpy( buf, msg + 1, n->getLength() - 1 );
             buf[ n->getLength() - 1 ] = 0;
             if( chat )
@@ -832,12 +832,12 @@ bool Spiel::tick( double zeit )
     return 1;
 }
 
-void Spiel::render( Bild &zRObj )
+void Spiel::render( Bild& zRObj )
 {
     if( spielerGUI )
         spielerGUI->render( zRObj );
-    Spieler *i = 0;
-    for( auto s = spieler.getIterator(); s; s++ )
+    Spieler* i = 0;
+    for( auto s : spieler )
     {
         if( s->getId() == spielerNummer )
             i = s;
@@ -845,40 +845,40 @@ void Spiel::render( Bild &zRObj )
     if( zRObj.setDrawOptions( 300, 0, zRObj.getBreite() - 300, zRObj.getHeight() ) )
     {
         if( !begonnen )
-            zRObj.addScrollOffset( mapSize.x - ( zRObj.getBreite() - 300 ) / 2, mapSize.y - zRObj.getHeight() / 2 );
+            zRObj.addScrollOffset( mapSize.x - (zRObj.getBreite() - 300) / 2, mapSize.y - zRObj.getHeight() / 2 );
         else if( i )
-            zRObj.addScrollOffset( (int)i->getX() - ( zRObj.getBreite() - 300 ) / 2, (int)i->getY() - zRObj.getHeight() / 2 );
-        for( auto f = feuer.getIterator(); f; f++ )
+            zRObj.addScrollOffset( (int)i->getX() - (zRObj.getBreite() - 300) / 2, (int)i->getY() - zRObj.getHeight() / 2 );
+        for( auto f : feuer )
             f->render( zRObj );
-        for( auto s = schalter.getIterator(); s; s++ )
+        for( auto s : schalter )
             s->render( zRObj );
-        for( auto t = tunnel.getIterator(); t; t++ )
+        for( auto t : tunnel )
             t->render( zRObj );
-        for( auto b = basen.getIterator(); b; b++ )
+        for( auto b : basen )
             b->render( zRObj );
-        for( auto u = umlenkungen.getIterator(); u; u++ )
+        for( auto u : umlenkungen )
             u->render( zRObj );
-        for( auto s = schienen.getIterator(); s; s++ )
+        for( auto s : schienen )
             s->render( zRObj );
-        for( auto i = items.getIterator(); i; i++ )
+        for( auto i : items )
             i->render( zRObj );
-        for( auto b = barieren.getIterator(); b; b++ )
+        for( auto b : barieren )
             b->render( zRObj );
-        for( auto s = spieler.getIterator(); s; s++ )
+        for( auto s : spieler )
         {
             if( s->istSichtbar( zEigenesTeam() ) )
                 s->render( zRObj );
         }
-        for( auto s = shots.getIterator(); s; s++ )
+        for( auto s : shots )
             s->render( zRObj );
-        for( auto a = animations.getIterator(); a; a++ )
+        for( auto a : animations )
             a->render( zRObj );
-        for( auto t = timer.getIterator(); t; t++ )
+        for( auto t : timer )
             t->render( zRObj );
         zRObj.releaseDrawOptions();
     }
     int y = 5;
-    for( auto b = bestenlisten.getIterator(); b; b++ )
+    for( auto b : bestenlisten )
     {
         int x = zRObj.getBreite() - b->getBreite() - 5;
         b->render( x, y, zRObj );
@@ -903,10 +903,10 @@ void Spiel::setPausiert( bool pausiert )
     this->pause = pausiert;
 }
 
-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++ )
+    for( auto v : variablen )
     {
         if( v->getName().istGleich( name ) )
         {
@@ -920,10 +920,10 @@ 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++ )
+    for( auto v : variablen )
     {
         if( v->getName().istGleich( name ) )
         {
@@ -936,90 +936,90 @@ 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 )
 {
     nextId = nextId > bariere->getId() ? nextId : bariere->getId() + 1;
     barieren.add( bariere );
 }
 
-void Spiel::addBase( Base *base )
+void Spiel::addBase( Base* base )
 {
     nextId = nextId > base->getId() ? nextId : base->getId() + 1;
     basen.add( base );
 }
 
-void Spiel::addDrop( Drop *drop )
+void Spiel::addDrop( Drop* drop )
 {
     nextId = nextId > drop->getId() ? nextId : drop->getId() + 1;
     drops.add( drop );
 }
 
-void Spiel::addGegenstand( Gegenstand *gegenstand )
+void Spiel::addGegenstand( Gegenstand* gegenstand )
 {
     nextId = nextId > gegenstand->getId() ? nextId : gegenstand->getId() + 1;
     items.add( gegenstand );
     zuletztGedropterGegenstand = gegenstand->getTyp();
-    Ereignis *e = new Ereignis( GEGENSTAND_DROPED );
-    e->addParameter( "Betroffener Gegenstand", dynamic_cast<Gegenstand *>( gegenstand->getThis() ) );
+    Ereignis* e = new Ereignis( GEGENSTAND_DROPED );
+    e->addParameter( "Betroffener Gegenstand", dynamic_cast<Gegenstand*>(gegenstand->getThis()) );
     throwEvent( e );
 }
 
-void Spiel::addGeschoss( Geschoss *geschoss )
+void Spiel::addGeschoss( Geschoss* geschoss )
 {
     nextId = nextId > geschoss->getId() ? nextId : geschoss->getId() + 1;
     if( zuletztAbgefeuertesGeschoss )
         zuletztAbgefeuertesGeschoss->release();
-    zuletztAbgefeuertesGeschoss = dynamic_cast<Geschoss *>( geschoss->getThis() );
+    zuletztAbgefeuertesGeschoss = dynamic_cast<Geschoss*>(geschoss->getThis());
     shots.add( geschoss );
 }
 
-void Spiel::addSchalter( Schalter *schalter )
+void Spiel::addSchalter( Schalter* schalter )
 {
     nextId = nextId > schalter->getId() ? nextId : schalter->getId() + 1;
     this->schalter.add( schalter );
 }
 
-void Spiel::addSchiene( Schiene *schiene )
+void Spiel::addSchiene( Schiene* schiene )
 {
     nextId = nextId > schiene->getId() ? nextId : schiene->getId() + 1;
     schienen.add( schiene );
 }
 
-void Spiel::addTimer( Timer *timer )
+void Spiel::addTimer( Timer* timer )
 {
     nextId = nextId > timer->getId() ? nextId : timer->getId() + 1;
     this->timer.add( timer );
 }
 
-void Spiel::addTunnel( Tunnel *tunnel )
+void Spiel::addTunnel( Tunnel* tunnel )
 {
     nextId = nextId > tunnel->getId() ? nextId : tunnel->getId() + 1;
     this->tunnel.add( tunnel );
 }
 
-void Spiel::addUmlenkung( Umlenkung *umlenkung )
+void Spiel::addUmlenkung( Umlenkung* umlenkung )
 {
     nextId = nextId > umlenkung->getId() ? nextId : umlenkung->getId() + 1;
     umlenkungen.add( umlenkung );
 }
 
-void Spiel::addTrigger( Trigger *trigger )
+void Spiel::addTrigger( Trigger* trigger )
 {
     nextId = nextId > trigger->getId() ? nextId : trigger->getId() + 1;
     this->trigger.add( trigger );
 }
 
-void Spiel::addTriggerRun( TriggerRun *tRun )
+void Spiel::addTriggerRun( TriggerRun* tRun )
 {
     if( tRun )
     {
@@ -1030,7 +1030,7 @@ void Spiel::addTriggerRun( TriggerRun *tRun )
     }
 }
 
-void Spiel::spielerActivate( Spieler *zSpieler )
+void Spiel::spielerActivate( Spieler* zSpieler )
 {
     // spieler - item intersection
     for( int i = 0; i < items.getEintragAnzahl(); i++ )
@@ -1066,129 +1066,129 @@ void Spiel::spielerActivate( Spieler *zSpieler )
     }
 }
 
-Team *Spiel::getTeam( int id ) const
+Team* Spiel::getTeam( int id ) const
 {
-    for( auto t = teams.getIterator(); t; t++ )
+    for( auto t : teams )
     {
         if( t->getTeamNummer() == id )
-            return dynamic_cast<Team *>( t->getThis() );
+            return dynamic_cast<Team*>(t->getThis());
     }
     return 0;
 }
 
-Spieler *Spiel::getSpieler( int id ) const
+Spieler* Spiel::getSpieler( int id ) const
 {
-    for( auto s = spieler.getIterator(); s; s++ )
+    for( auto s : spieler )
     {
         if( s->getId() == id )
-            return dynamic_cast<Spieler *>( s->getThis() );
+            return dynamic_cast<Spieler*>(s->getThis());
     }
     return 0;
 }
 
-Iterator<Spieler *> Spiel::getSpieler() const
+Iterator<Spieler*> Spiel::getSpieler() const
 {
-    return spieler.getIterator();
+    return spieler.begin();
 }
 
-Iterator<Bariere *> Spiel::getBarieren() const
+Iterator<Bariere*> Spiel::getBarieren() const
 {
-    return barieren.getIterator();
+    return barieren.begin();
 }
 
-Bariere *Spiel::getBariere( int id ) const
+Bariere* Spiel::getBariere( int id ) const
 {
-    for( auto b = barieren.getIterator(); b; b++ )
+    for( auto b : barieren )
     {
         if( b->getId() == id )
-            return dynamic_cast<Bariere *>( b->getThis() );
+            return dynamic_cast<Bariere*>(b->getThis());
     }
     return 0;
 }
 
-Base *Spiel::getBase( int id ) const
+Base* Spiel::getBase( int id ) const
 {
-    for( auto b = basen.getIterator(); b; b++ )
+    for( auto b : basen )
     {
         if( b->getId() == id )
-            return dynamic_cast<Base *>( b->getThis() );
+            return dynamic_cast<Base*>(b->getThis());
     }
     return 0;
 }
 
-Drop *Spiel::getDrop( int id ) const
+Drop* Spiel::getDrop( int id ) const
 {
-    for( auto d = drops.getIterator(); d; d++ )
+    for( auto d : drops )
     {
         if( d->getId() == id )
-            return dynamic_cast<Drop *>( d->getThis() );
+            return dynamic_cast<Drop*>(d->getThis());
     }
     return 0;
 }
 
-Schalter *Spiel::getSchalter( int id ) const
+Schalter* Spiel::getSchalter( int id ) const
 {
-    for( auto s = schalter.getIterator(); s; s++ )
+    for( auto s : schalter )
     {
         if( s->getId() == id )
-            return dynamic_cast<Schalter *>( s->getThis() );
+            return dynamic_cast<Schalter*>(s->getThis());
     }
     return 0;
 }
 
-Schiene *Spiel::getSchiene( int id ) const
+Schiene* Spiel::getSchiene( int id ) const
 {
-    for( auto s = schienen.getIterator(); s; s++ )
+    for( auto s : schienen )
     {
         if( s->getId() == id )
-            return dynamic_cast<Schiene *>( s->getThis() );
+            return dynamic_cast<Schiene*>(s->getThis());
     }
     return 0;
 }
 
-Timer *Spiel::getTimer( int id ) const
+Timer* Spiel::getTimer( int id ) const
 {
-    for( auto t = timer.getIterator(); t; t++ )
+    for( auto t : timer )
     {
         if( t->getId() == id )
-            return dynamic_cast<Timer *>( t->getThis() );
+            return dynamic_cast<Timer*>(t->getThis());
     }
     return 0;
 }
 
-Tunnel *Spiel::getTunnel( int id ) const
+Tunnel* Spiel::getTunnel( int id ) const
 {
-    for( auto t = tunnel.getIterator(); t; t++ )
+    for( auto t : tunnel )
     {
         if( t->getId() == id )
-            return dynamic_cast<Tunnel *>( t->getThis() );
+            return dynamic_cast<Tunnel*>(t->getThis());
     }
     return 0;
 }
 
-Umlenkung *Spiel::getUmlenkung( int id ) const
+Umlenkung* Spiel::getUmlenkung( int id ) const
 {
-    for( auto u = umlenkungen.getIterator(); u; u++ )
+    for( auto u : umlenkungen )
     {
         if( u->getId() == id )
-            return dynamic_cast<Umlenkung *>( u->getThis() );
+            return dynamic_cast<Umlenkung*>(u->getThis());
     }
     return 0;
 }
 
-Trigger *Spiel::getTrigger( int id ) const
+Trigger* Spiel::getTrigger( int id ) const
 {
-    for( auto t = trigger.getIterator(); t; t++ )
+    for( auto t : trigger )
     {
         if( t->getId() == id )
-            return dynamic_cast<Trigger *>( t->getThis() );
+            return dynamic_cast<Trigger*>(t->getThis());
     }
     return 0;
 }
 
-Variable *Spiel::getVariable( const char *name ) const
+Variable* Spiel::getVariable( const char* name ) const
 {
-    for( auto v = variablen.getIterator(); v; v++ )
+    for( auto v : variablen )
     {
         if( v->getName().istGleich( name ) )
             return v->getVariable();
@@ -1196,9 +1196,9 @@ Variable *Spiel::getVariable( const char *name ) const
     return 0;
 }
 
-Variable *Spiel::zVariable( const char *name ) const
+Variable* Spiel::zVariable( const char* name ) const
 {
-    for( auto v = variablen.getIterator(); v; v++ )
+    for( auto v : variablen )
     {
         if( v->getName().istGleich( name ) )
             return v->zVariable();
@@ -1213,20 +1213,20 @@ bool Spiel::istPausiert() const
 
 void Spiel::activateShalter( int id )
 {
-    for( auto s = schalter.getIterator(); s; s++ )
+    for( auto s : schalter )
     {
         if( s->getId() == id )
             s->press( this );
     }
 }
 
-void Spiel::throwEvent( Ereignis *e )
+void Spiel::throwEvent( Ereignis* e )
 {
-    for( auto t = trigger.getIterator(); t; t++ )
+    for( auto t : trigger )
     {
         if( t->hatEreignis( e->getTyp() ) )
         {
-            TriggerRun *tr = t->runTrigger( dynamic_cast<Ereignis *>( e->getThis() ), this );
+            TriggerRun* tr = t->runTrigger( dynamic_cast<Ereignis*>(e->getThis()), this );
             if( tr )
                 triggerRuns.add( tr );
         }
@@ -1236,7 +1236,7 @@ void Spiel::throwEvent( Ereignis *e )
 
 bool Spiel::needEvent( EreignisTyp typ ) const
 {
-    for( auto t = trigger.getIterator(); t; t++ )
+    for( auto t : trigger )
     {
         if( t->hatEreignis( typ ) )
             return 1;
@@ -1259,108 +1259,108 @@ int Spiel::getTickCount() const
     return gameTicks;
 }
 
-void Spiel::setEnde( Team *zGewinner )
+void Spiel::setEnde( Team* zGewinner )
 {
     zWinner = zGewinner;
-    Spieler *i = 0;
-    for( auto s = spieler.getIterator(); s; s++ )
+    Spieler* i = 0;
+    for( auto s : spieler )
     {
         if( s->getId() == spielerNummer )
             i = s;
     }
     end = new Ende( uiFactory );
-    end->setGewonnen( ( zGewinner && i ) ? ( i->zTeam() == zGewinner ) : -1 );
+    end->setGewonnen( (zGewinner && i) ? (i->zTeam() == zGewinner) : -1 );
 }
 
-Trigger *Spiel::getRandomTrigger()
+Trigger* Spiel::getRandomTrigger()
 {
     if( !trigger.getEintragAnzahl() )
         return 0;
-    return trigger.get( (int)( randG.rand() * trigger.getEintragAnzahl() ) );
+    return trigger.get( (int)(randG.rand() * trigger.getEintragAnzahl()) );
 }
 
-Trigger *Spiel::getLastRunnedTrigger() const
+Trigger* Spiel::getLastRunnedTrigger() const
 {
-    return lastRunnedTrigger ? dynamic_cast<Trigger *>( lastRunnedTrigger->getThis() ) : 0;
+    return lastRunnedTrigger ? dynamic_cast<Trigger*>(lastRunnedTrigger->getThis()) : 0;
 }
 
-Bariere *Spiel::getRandomBariere()
+Bariere* Spiel::getRandomBariere()
 {
-    return barieren.get( (int)( randG.rand() * barieren.getEintragAnzahl() ) );
+    return barieren.get( (int)(randG.rand() * barieren.getEintragAnzahl()) );
 }
 
-void Spiel::setZuletztEingeschalteteBariere( Bariere *b )
+void Spiel::setZuletztEingeschalteteBariere( Bariere* b )
 {
     if( zuletztEingeschalteteBariere )
         zuletztEingeschalteteBariere->release();
     zuletztEingeschalteteBariere = b;
 }
 
-Bariere *Spiel::getZuletztEingeschalteteBariere() const
+Bariere* Spiel::getZuletztEingeschalteteBariere() const
 {
-    return zuletztEingeschalteteBariere ? dynamic_cast<Bariere *>( zuletztEingeschalteteBariere->getThis() ) : 0;
+    return zuletztEingeschalteteBariere ? dynamic_cast<Bariere*>(zuletztEingeschalteteBariere->getThis()) : 0;
 }
 
-void Spiel::setZuletztAusgeschalteteBariere( Bariere *b )
+void Spiel::setZuletztAusgeschalteteBariere( Bariere* b )
 {
     if( zuletztAusgeschalteteBariere )
         zuletztAusgeschalteteBariere->release();
     zuletztAusgeschalteteBariere = b;
 }
 
-Bariere *Spiel::getZuletztAusgeschalteteBariere() const
+Bariere* Spiel::getZuletztAusgeschalteteBariere() const
 {
-    return zuletztAusgeschalteteBariere ? dynamic_cast<Bariere *>( zuletztAusgeschalteteBariere->getThis() ) : 0;
+    return zuletztAusgeschalteteBariere ? dynamic_cast<Bariere*>(zuletztAusgeschalteteBariere->getThis()) : 0;
 }
 
-void Spiel::setZuletztBewegteBariere( Bariere *b )
+void Spiel::setZuletztBewegteBariere( Bariere* b )
 {
     if( zuletztBewegteBariere )
         zuletztBewegteBariere->release();
     zuletztBewegteBariere = b;
 }
 
-Bariere *Spiel::getZuletztBewegteBariere() const
+Bariere* Spiel::getZuletztBewegteBariere() const
 {
-    return zuletztBewegteBariere ? dynamic_cast<Bariere *>( zuletztBewegteBariere->getThis() ) : 0;
+    return zuletztBewegteBariere ? dynamic_cast<Bariere*>(zuletztBewegteBariere->getThis()) : 0;
 }
 
-Base *Spiel::getRandomBase()
+Base* Spiel::getRandomBase()
 {
     if( !basen.getEintragAnzahl() )
         return 0;
-    return basen.get( (int)( randG.rand() * basen.getEintragAnzahl() ) );
+    return basen.get( (int)(randG.rand() * basen.getEintragAnzahl()) );
 }
 
-void Spiel::setLastTeamChangedBase( Base *b )
+void Spiel::setLastTeamChangedBase( Base* b )
 {
     if( lastTeamChangedBase )
         lastTeamChangedBase->release();
     lastTeamChangedBase = b;
 }
 
-Base *Spiel::getLastTeamChangedBase() const
+Base* Spiel::getLastTeamChangedBase() const
 {
-    return lastTeamChangedBase ? dynamic_cast<Base *>( lastTeamChangedBase->getThis() ) : 0;
+    return lastTeamChangedBase ? dynamic_cast<Base*>(lastTeamChangedBase->getThis()) : 0;
 }
 
-Drop *Spiel::getRandomDrop()
+Drop* Spiel::getRandomDrop()
 {
     if( !drops.getEintragAnzahl() )
         return 0;
-    return drops.get( (int)( randG.rand() * drops.getEintragAnzahl() ) );
+    return drops.get( (int)(randG.rand() * drops.getEintragAnzahl()) );
 }
 
-void Spiel::setLastDrop( Drop *d )
+void Spiel::setLastDrop( Drop* d )
 {
     if( lastDropedDrop )
         lastDropedDrop->release();
     lastDropedDrop = d;
 }
 
-Drop *Spiel::getLastDrop() const
+Drop* Spiel::getLastDrop() const
 {
-    return lastDropedDrop ? dynamic_cast<Drop *>( lastDropedDrop->getThis() ) : 0;
+    return lastDropedDrop ? dynamic_cast<Drop*>(lastDropedDrop->getThis()) : 0;
 }
 
 void Spiel::setItemZuletztAufgehoben( GegenstandTyp g )
@@ -1388,356 +1388,356 @@ GegenstandTyp Spiel::getItemZuletztGedropt() const
     return zuletztGedropterGegenstand;
 }
 
-Geschoss *Spiel::getRandomGeschoss()
+Geschoss* Spiel::getRandomGeschoss()
 {
     if( !shots.getEintragAnzahl() )
         return 0;
-    return shots.get( (int)( randG.rand() * shots.getEintragAnzahl() ) );
+    return shots.get( (int)(randG.rand() * shots.getEintragAnzahl()) );
 }
 
-Geschoss *Spiel::getGeschossZuletztAbgefeuert() const
+Geschoss* Spiel::getGeschossZuletztAbgefeuert() const
 {
-    return zuletztAbgefeuertesGeschoss ? dynamic_cast<Geschoss *>( zuletztAbgefeuertesGeschoss->getThis() ) : 0;
+    return zuletztAbgefeuertesGeschoss ? dynamic_cast<Geschoss*>(zuletztAbgefeuertesGeschoss->getThis()) : 0;
 }
 
-void Spiel::setGeschossZuletztUmgelenkt( Geschoss *g )
+void Spiel::setGeschossZuletztUmgelenkt( Geschoss* g )
 {
     if( zuletztUmgelenktesGeschoss )
         zuletztUmgelenktesGeschoss->release();
     zuletztUmgelenktesGeschoss = g;
 }
 
-Geschoss *Spiel::getGeschossZuletztUmgelenkt() const
+Geschoss* Spiel::getGeschossZuletztUmgelenkt() const
 {
-    return zuletztUmgelenktesGeschoss ? dynamic_cast<Geschoss *>( zuletztUmgelenktesGeschoss->getThis() ) : 0;
+    return zuletztUmgelenktesGeschoss ? dynamic_cast<Geschoss*>(zuletztUmgelenktesGeschoss->getThis()) : 0;
 }
 
-Geschoss *Spiel::getGeschossZuletztBariereGetroffen() const
+Geschoss* Spiel::getGeschossZuletztBariereGetroffen() const
 {
-    return zuletztBariereGetroffenesGeschoss ? dynamic_cast<Geschoss *>( zuletztBariereGetroffenesGeschoss->getThis() ) : 0;
+    return zuletztBariereGetroffenesGeschoss ? dynamic_cast<Geschoss*>(zuletztBariereGetroffenesGeschoss->getThis()) : 0;
 }
 
-void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss *g )
+void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss* g )
 {
     if( zuletztTunnelBenutztesGeschoss )
         zuletztTunnelBenutztesGeschoss->release();
     zuletztTunnelBenutztesGeschoss = g;
 }
 
-Geschoss *Spiel::getGeschossZuletztTunnelBenutzt() const
+Geschoss* Spiel::getGeschossZuletztTunnelBenutzt() const
 {
-    return zuletztTunnelBenutztesGeschoss ? dynamic_cast<Geschoss *>( zuletztTunnelBenutztesGeschoss->getThis() ) : 0;
+    return zuletztTunnelBenutztesGeschoss ? dynamic_cast<Geschoss*>(zuletztTunnelBenutztesGeschoss->getThis()) : 0;
 }
 
-void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss *g )
+void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss* g )
 {
     if( zuletztGeschossGetroffenesGeschoss )
         zuletztGeschossGetroffenesGeschoss->release();
     zuletztGeschossGetroffenesGeschoss = g;
 }
 
-Geschoss *Spiel::getGeschossZuletztGeschossGetroffen() const
+Geschoss* Spiel::getGeschossZuletztGeschossGetroffen() const
 {
-    return zuletztGeschossGetroffenesGeschoss ? dynamic_cast<Geschoss *>( zuletztGeschossGetroffenesGeschoss->getThis() ) : 0;
+    return zuletztGeschossGetroffenesGeschoss ? dynamic_cast<Geschoss*>(zuletztGeschossGetroffenesGeschoss->getThis()) : 0;
 }
 
-Schalter *Spiel::getRandomSchalter()
+Schalter* Spiel::getRandomSchalter()
 {
     if( !schalter.getEintragAnzahl() )
         return 0;
-    return schalter.get( (int)( randG.rand() * schalter.getEintragAnzahl() ) );
+    return schalter.get( (int)(randG.rand() * schalter.getEintragAnzahl()) );
 }
 
-void Spiel::setSchalterZuletztAktiviert( Schalter *s )
+void Spiel::setSchalterZuletztAktiviert( Schalter* s )
 {
     if( zuletztAktivierterSchalter )
         zuletztAktivierterSchalter->release();
     zuletztAktivierterSchalter = s;
 }
 
-Schalter *Spiel::getSchalterZuletztAktiviert() const
+Schalter* Spiel::getSchalterZuletztAktiviert() const
 {
-    return zuletztAktivierterSchalter ? dynamic_cast<Schalter *>( zuletztAktivierterSchalter->getThis() ) : 0;
+    return zuletztAktivierterSchalter ? dynamic_cast<Schalter*>(zuletztAktivierterSchalter->getThis()) : 0;
 }
 
-Spieler *Spiel::getRandomSpieler()
+Spieler* Spiel::getRandomSpieler()
 {
     if( !spieler.getEintragAnzahl() )
         return 0;
-    return spieler.get( (int)( randG.rand() * spieler.getEintragAnzahl() ) );
+    return spieler.get( (int)(randG.rand() * spieler.getEintragAnzahl()) );
 }
 
-Spieler *Spiel::getRandomSpieler( Team *zTeam )
+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++ )
+    int index = (int)(randG.rand() * zTeam->getSpielerAnzahl());
+    for( auto s : spieler )
     {
         if( s->zTeam() == zTeam )
         {
             if( index-- <= 0 )
-                return dynamic_cast<Spieler *>( s->getThis() );
+                return dynamic_cast<Spieler*>(s->getThis());
         }
     }
     return 0;
 }
 
-void Spiel::setSpielerZuletztSchadenGemacht( Spieler *s )
+void Spiel::setSpielerZuletztSchadenGemacht( Spieler* s )
 {
     if( zuletztSchadenGemachterSpieler )
         zuletztSchadenGemachterSpieler->release();
     zuletztSchadenGemachterSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztSchadenGemacht() const
+Spieler* Spiel::getSpielerZuletztSchadenGemacht() const
 {
-    return zuletztSchadenGemachterSpieler ? dynamic_cast<Spieler *>( zuletztSchadenGemachterSpieler->getThis() ) : 0;
+    return zuletztSchadenGemachterSpieler ? dynamic_cast<Spieler*>(zuletztSchadenGemachterSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztSchadenGenommen( Spieler *s )
+void Spiel::setSpielerZuletztSchadenGenommen( Spieler* s )
 {
     if( zuletztSchadenGenommenerSpieler )
         zuletztSchadenGenommenerSpieler->release();
     zuletztSchadenGenommenerSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztSchadenGenommen() const
+Spieler* Spiel::getSpielerZuletztSchadenGenommen() const
 {
-    return zuletztSchadenGenommenerSpieler ? dynamic_cast<Spieler *>( zuletztSchadenGenommenerSpieler->getThis() ) : 0;
+    return zuletztSchadenGenommenerSpieler ? dynamic_cast<Spieler*>(zuletztSchadenGenommenerSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztGeheilt( Spieler *s )
+void Spiel::setSpielerZuletztGeheilt( Spieler* s )
 {
     if( zuletztGeheilterSpieler )
         zuletztGeheilterSpieler->release();
     zuletztGeheilterSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztGeheilt() const
+Spieler* Spiel::getSpielerZuletztGeheilt() const
 {
-    return zuletztGeheilterSpieler ? dynamic_cast<Spieler *>( zuletztGeheilterSpieler->getThis() ) : 0;
+    return zuletztGeheilterSpieler ? dynamic_cast<Spieler*>(zuletztGeheilterSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztLevelUp( Spieler *s )
+void Spiel::setSpielerZuletztLevelUp( Spieler* s )
 {
     if( zuletztLevelUpSpieler )
         zuletztLevelUpSpieler->release();
     zuletztLevelUpSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztLevelUp() const
+Spieler* Spiel::getSpielerZuletztLevelUp() const
 {
-    return zuletztLevelUpSpieler ? dynamic_cast<Spieler *>( zuletztLevelUpSpieler->getThis() ) : 0;
+    return zuletztLevelUpSpieler ? dynamic_cast<Spieler*>(zuletztLevelUpSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztErfahrungBekommen( Spieler *s )
+void Spiel::setSpielerZuletztErfahrungBekommen( Spieler* s )
 {
     if( zuletztErfahrungBekommenerSpieler )
         zuletztErfahrungBekommenerSpieler->release();
     zuletztErfahrungBekommenerSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztErfahrungBekommen() const
+Spieler* Spiel::getSpielerZuletztErfahrungBekommen() const
 {
-    return zuletztErfahrungBekommenerSpieler ? dynamic_cast<Spieler *>( zuletztErfahrungBekommenerSpieler->getThis() ) : 0;
+    return zuletztErfahrungBekommenerSpieler ? dynamic_cast<Spieler*>(zuletztErfahrungBekommenerSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler *s )
+void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler* s )
 {
     if( zuletztGegenstandAktivierterSpieler )
         zuletztGegenstandAktivierterSpieler->release();
     zuletztGegenstandAktivierterSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztGegenstandAktiviert() const
+Spieler* Spiel::getSpielerZuletztGegenstandAktiviert() const
 {
-    return zuletztGegenstandAktivierterSpieler ? dynamic_cast<Spieler *>( zuletztGegenstandAktivierterSpieler->getThis() ) : 0;
+    return zuletztGegenstandAktivierterSpieler ? dynamic_cast<Spieler*>(zuletztGegenstandAktivierterSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler *s )
+void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler* s )
 {
     if( zuletztGegenstandAufgehobenerSpieler )
         zuletztGegenstandAufgehobenerSpieler->release();
     zuletztGegenstandAufgehobenerSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztGegenstandAufgehoben() const
+Spieler* Spiel::getSpielerZuletztGegenstandAufgehoben() const
 {
-    return zuletztGegenstandAufgehobenerSpieler ? dynamic_cast<Spieler *>( zuletztGegenstandAufgehobenerSpieler->getThis() ) : 0;
+    return zuletztGegenstandAufgehobenerSpieler ? dynamic_cast<Spieler*>(zuletztGegenstandAufgehobenerSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztSchalterAktiviert( Spieler *s )
+void Spiel::setSpielerZuletztSchalterAktiviert( Spieler* s )
 {
     if( zuletztSchalterAktivierterSpieler )
         zuletztSchalterAktivierterSpieler->release();
     zuletztSchalterAktivierterSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztSchalterAktiviert() const
+Spieler* Spiel::getSpielerZuletztSchalterAktiviert() const
 {
-    return zuletztSchalterAktivierterSpieler ? dynamic_cast<Spieler *>( zuletztSchalterAktivierterSpieler->getThis() ) : 0;
+    return zuletztSchalterAktivierterSpieler ? dynamic_cast<Spieler*>(zuletztSchalterAktivierterSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztTunnelBenutzt( Spieler *s )
+void Spiel::setSpielerZuletztTunnelBenutzt( Spieler* s )
 {
     if( zuletztTunnelBenutzterSpieler )
         zuletztTunnelBenutzterSpieler->release();
     zuletztTunnelBenutzterSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztTunnelBenutzt() const
+Spieler* Spiel::getSpielerZuletztTunnelBenutzt() const
 {
-    return zuletztTunnelBenutzterSpieler ? dynamic_cast<Spieler *>( zuletztTunnelBenutzterSpieler->getThis() ) : 0;
+    return zuletztTunnelBenutzterSpieler ? dynamic_cast<Spieler*>(zuletztTunnelBenutzterSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztGestorben( Spieler *s )
+void Spiel::setSpielerZuletztGestorben( Spieler* s )
 {
     if( zuletztGestorbenerSpieler )
         zuletztGestorbenerSpieler->release();
     zuletztGestorbenerSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztGestorben() const
+Spieler* Spiel::getSpielerZuletztGestorben() const
 {
-    return zuletztGestorbenerSpieler ? dynamic_cast<Spieler *>( zuletztGestorbenerSpieler->getThis() ) : 0;
+    return zuletztGestorbenerSpieler ? dynamic_cast<Spieler*>(zuletztGestorbenerSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztWiederbelebt( Spieler *s )
+void Spiel::setSpielerZuletztWiederbelebt( Spieler* s )
 {
     if( zuletztWiederbelebterSpieler )
         zuletztWiederbelebterSpieler->release();
     zuletztWiederbelebterSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztWiederbelebt() const
+Spieler* Spiel::getSpielerZuletztWiederbelebt() const
 {
-    return zuletztWiederbelebterSpieler ? dynamic_cast<Spieler *>( zuletztWiederbelebterSpieler->getThis() ) : 0;
+    return zuletztWiederbelebterSpieler ? dynamic_cast<Spieler*>(zuletztWiederbelebterSpieler->getThis()) : 0;
 }
 
-void Spiel::setSpielerZuletztGeschossen( Spieler *s )
+void Spiel::setSpielerZuletztGeschossen( Spieler* s )
 {
     if( zuletztGeschossenerSpieler )
         zuletztGeschossenerSpieler->release();
     zuletztGeschossenerSpieler = s;
 }
 
-Spieler *Spiel::getSpielerZuletztGeschossen() const
+Spieler* Spiel::getSpielerZuletztGeschossen() const
 {
-    return zuletztGeschossenerSpieler ? dynamic_cast<Spieler *>( zuletztGeschossenerSpieler->getThis() ) : 0;
+    return zuletztGeschossenerSpieler ? dynamic_cast<Spieler*>(zuletztGeschossenerSpieler->getThis()) : 0;
 }
 
-Team *Spiel::getRandomTeam()
+Team* Spiel::getRandomTeam()
 {
     if( !teams.getEintragAnzahl() )
         return 0;
-    return teams.get( (int)( randG.rand() * teams.getEintragAnzahl() ) );
+    return teams.get( (int)(randG.rand() * teams.getEintragAnzahl()) );
 }
 
-Timer *Spiel::getRandomTimer()
+Timer* Spiel::getRandomTimer()
 {
     if( !timer.getEintragAnzahl() )
         return 0;
-    return timer.get( (int)( randG.rand() * timer.getEintragAnzahl() ) );
+    return timer.get( (int)(randG.rand() * timer.getEintragAnzahl()) );
 }
 
-void Spiel::setTimerZuletztAbgelaufen( Timer *t )
+void Spiel::setTimerZuletztAbgelaufen( Timer* t )
 {
     if( zuletztAbgelaufenerTimer )
         zuletztAbgelaufenerTimer->release();
     zuletztAbgelaufenerTimer = t;
 }
 
-Timer *Spiel::getTimerZuletztAbgelaufen() const
+Timer* Spiel::getTimerZuletztAbgelaufen() const
 {
-    return zuletztAbgelaufenerTimer ? dynamic_cast<Timer *>( zuletztAbgelaufenerTimer->getThis() ) : 0;
+    return zuletztAbgelaufenerTimer ? dynamic_cast<Timer*>(zuletztAbgelaufenerTimer->getThis()) : 0;
 }
 
-void Spiel::setTimerZuletztGestartet( Timer *t )
+void Spiel::setTimerZuletztGestartet( Timer* t )
 {
     if( zuletztGestarteterTimer )
         zuletztGestarteterTimer->release();
     zuletztGestarteterTimer = t;
 }
 
-Timer *Spiel::getTimerZuletztGestartet() const
+Timer* Spiel::getTimerZuletztGestartet() const
 {
-    return zuletztGestarteterTimer ? dynamic_cast<Timer *>( zuletztGestarteterTimer->getThis() ) : 0;
+    return zuletztGestarteterTimer ? dynamic_cast<Timer*>(zuletztGestarteterTimer->getThis()) : 0;
 }
 
-void Spiel::setTimerZuletztPausiert( Timer *t )
+void Spiel::setTimerZuletztPausiert( Timer* t )
 {
     if( zuletztPausierterTimer )
         zuletztPausierterTimer->release();
     zuletztPausierterTimer = t;
 }
 
-Timer *Spiel::getTimerZuletztPausiert() const
+Timer* Spiel::getTimerZuletztPausiert() const
 {
-    return zuletztPausierterTimer ? dynamic_cast<Timer *>( zuletztPausierterTimer->getThis() ) : 0;
+    return zuletztPausierterTimer ? dynamic_cast<Timer*>(zuletztPausierterTimer->getThis()) : 0;
 }
 
-void Spiel::setTimerZuletztFortgesetzt( Timer *t )
+void Spiel::setTimerZuletztFortgesetzt( Timer* t )
 {
     if( zuletztFortgesetzterTimer )
         zuletztFortgesetzterTimer->release();
     zuletztFortgesetzterTimer = t;
 }
 
-Timer *Spiel::getTimerZuletztFortgesetzt() const
+Timer* Spiel::getTimerZuletztFortgesetzt() const
 {
-    return zuletztFortgesetzterTimer ? dynamic_cast<Timer *>( zuletztFortgesetzterTimer->getThis() ) : 0;
+    return zuletztFortgesetzterTimer ? dynamic_cast<Timer*>(zuletztFortgesetzterTimer->getThis()) : 0;
 }
 
-Tunnel *Spiel::getRandomTunnel()
+Tunnel* Spiel::getRandomTunnel()
 {
     if( !tunnel.getEintragAnzahl() )
         return 0;
-    return tunnel.get( (int)( randG.rand() * tunnel.getEintragAnzahl() ) );
+    return tunnel.get( (int)(randG.rand() * tunnel.getEintragAnzahl()) );
 }
 
-void Spiel::setTunnelZuletztBenutzt( Tunnel *t )
+void Spiel::setTunnelZuletztBenutzt( Tunnel* t )
 {
     if( zuletztBenutzterTunnel )
         zuletztBenutzterTunnel->release();
     zuletztBenutzterTunnel = t;
 }
 
-Tunnel *Spiel::getTunnelZuletztBenutzt() const
+Tunnel* Spiel::getTunnelZuletztBenutzt() const
 {
-    return zuletztBenutzterTunnel ? dynamic_cast<Tunnel *>( zuletztBenutzterTunnel->getThis() ) : 0;
+    return zuletztBenutzterTunnel ? dynamic_cast<Tunnel*>(zuletztBenutzterTunnel->getThis()) : 0;
 }
 
-Umlenkung *Spiel::getRandomUmlenkung()
+Umlenkung* Spiel::getRandomUmlenkung()
 {
     if( !umlenkungen.getEintragAnzahl() )
         return 0;
-    return umlenkungen.get( (int)( randG.rand() * umlenkungen.getEintragAnzahl() ) );
+    return umlenkungen.get( (int)(randG.rand() * umlenkungen.getEintragAnzahl()) );
 }
 
-void Spiel::setUmlenkungZuletztBenutzt( Umlenkung *t )
+void Spiel::setUmlenkungZuletztBenutzt( Umlenkung* t )
 {
     if( zuletztBenutzteUmlenkung )
         zuletztBenutzteUmlenkung->release();
     zuletztBenutzteUmlenkung = t;
 }
 
-Umlenkung *Spiel::getUmlenkungZuletztBenutzt() const
+Umlenkung* Spiel::getUmlenkungZuletztBenutzt() const
 {
-    return zuletztBenutzteUmlenkung ? dynamic_cast<Umlenkung *>( zuletztBenutzteUmlenkung->getThis() ) : 0;
+    return zuletztBenutzteUmlenkung ? dynamic_cast<Umlenkung*>(zuletztBenutzteUmlenkung->getThis()) : 0;
 }
 
-ResourceRegistry *Spiel::zResources() const
+ResourceRegistry* Spiel::zResources() const
 {
     return resources;
 }
 
-void Spiel::addAnimation( SingleAnimation *animation )
+void Spiel::addAnimation( SingleAnimation* animation )
 {
     animations.add( animation );
 }
 
-void Spiel::addBestenliste( Bestenliste *b )
+void Spiel::addBestenliste( Bestenliste* b )
 {
     bestenlisten.add( b );
 }

StickmanWorldOnline/Spieler.cpp

@@ -107,7 +107,7 @@ bool Inventar::canAddItem( GegenstandTyp typ ) const
     }
     for( int i = 0; i < INVENTORY_SLOTS; i++ )
     {
-        if( slots[ i ] == KEIN_GEGENSTAND || ( slots[ i ] == typ && consumable( typ ) ) )
+        if( slots[ i ] == KEIN_GEGENSTAND || (slots[ i ] == typ && consumable( typ )) )
             return 1;
     }
     return 0;
@@ -170,7 +170,7 @@ float Inventar::getAbklingzeit( int index ) const
 }
 
 
-Spieler::Spieler( ResourceRegistry *zResources, int id, Team *team, int spawnX, int spawnY, int farbe )
+Spieler::Spieler( ResourceRegistry* zResources, int id, Team* team, int spawnX, int spawnY, int farbe )
     : GameObject( SPIELER, spawnX, spawnY, 40, 50 ),
     tastenStand()
 {
@@ -222,9 +222,9 @@ Spieler::Spieler( ResourceRegistry *zResources, int id, Team *team, int spawnX,
     schadenNext = 0.075;
     showSchaden = 0;
     texturScale = 1;
-    resources = dynamic_cast<ResourceRegistry *>( zResources->getThis() );
+    resources = dynamic_cast<ResourceRegistry*>(zResources->getThis());
     current = zResources->getResource( R_SPIELER, farbe );
-    textur = dynamic_cast<Bild *>( current->getImages()->getThis() );
+    textur = dynamic_cast<Bild*>(current->getImages()->getThis());
     heilungR = zResources->getResource( R_HEILUNG, 0 );
     schadenR = zResources->getResource( R_SCHADEN, 0 );
 }
@@ -298,10 +298,10 @@ bool Spieler::setTastenStand( unsigned char taste, bool pressed )
         }
         else
         {
-            if( ( ausrichtung == OBEN && taste == 'w' ) ||
-                ( ausrichtung == LINKS && taste == 'a' ) ||
-                ( ausrichtung == UNTEN && taste == 's' ) ||
-                ( ausrichtung == RECHTS && taste == 'd' ) )
+            if( (ausrichtung == OBEN && taste == 'w') ||
+                (ausrichtung == LINKS && taste == 'a') ||
+                (ausrichtung == UNTEN && taste == 's') ||
+                (ausrichtung == RECHTS && taste == 'd') )
             {
                 if( tastenStand[ 'w' ] )
                     ausrichtung = OBEN;
@@ -329,7 +329,7 @@ bool Spieler::setTastenStand( unsigned char taste, bool pressed )
     return ret;
 }
 
-void Spieler::setTeam( Team *team )
+void Spieler::setTeam( Team* team )
 {
     if( this->team )
         this->team->removeSpieler();
@@ -343,9 +343,9 @@ void Spieler::setAccount( int id )
     this->accountId = id;
 }
 
-void Spieler::addEffekt( Effect *e )
+void Spieler::addEffekt( Effect* e )
 {
-    Resource *r = e->getCurrentResource();
+    Resource* r = e->getCurrentResource();
     if( r )
     {
         currentImage = 0;
@@ -359,12 +359,12 @@ void Spieler::setLaufTempo( float pps )
     laufTempo = pps;
 }
 
-void Spieler::addErfahrung( float anz, Spiel *zSpiel )
+void Spieler::addErfahrung( float anz, Spiel* zSpiel )
 {
     erfahrung += anz;
-    zSpiel->setSpielerZuletztErfahrungBekommen( dynamic_cast<Spieler *>( getThis() ) );
-    Ereignis *e = new Ereignis( SPIELER_BEKOMMT_ERFAHRUNG );
-    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztErfahrungBekommen( dynamic_cast<Spieler*>(getThis()) );
+    Ereignis* e = new Ereignis( SPIELER_BEKOMMT_ERFAHRUNG );
+    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
     e->addParameter( "Wert", new Float( anz ) );
     zSpiel->throwEvent( e );
     while( erfahrung > maxErfahrung )
@@ -373,11 +373,11 @@ void Spieler::addErfahrung( float anz, Spiel *zSpiel )
         levelDown( zSpiel );
 }
 
-void Spieler::levelUp( Spiel *zSpiel )
+void Spieler::levelUp( Spiel* zSpiel )
 {
     level++;
     erfahrung -= (float)maxErfahrung;
-    maxErfahrung += ( maxErfahrung / level ) + 2;
+    maxErfahrung += (maxErfahrung / level) + 2;
     maxLeben += 20;
     heilung( 20, zSpiel );
     if( level <= 10 )
@@ -397,13 +397,13 @@ void Spieler::levelUp( Spiel *zSpiel )
     }
     if( level <= 100 )
         lebensRegeneration += 0.25f;
-    zSpiel->setSpielerZuletztLevelUp( dynamic_cast<Spieler *>( getThis() ) );
-    Ereignis *e = new Ereignis( SPIELER_LEVEL_UP );
-    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztLevelUp( dynamic_cast<Spieler*>(getThis()) );
+    Ereignis* e = new Ereignis( SPIELER_LEVEL_UP );
+    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
     zSpiel->throwEvent( e );
 }
 
-void Spieler::levelDown( Spiel *zSpiel )
+void Spieler::levelDown( Spiel* zSpiel )
 {
     if( level <= 100 )
         lebensRegeneration -= 0.25f;
@@ -423,21 +423,21 @@ void Spieler::levelDown( Spiel *zSpiel )
         geschossTempo -= 2;
     }
     maxLeben -= 20;
-    maxErfahrung -= ( maxErfahrung / level ) + 2;
+    maxErfahrung -= (maxErfahrung / level) + 2;
     erfahrung += (float)maxErfahrung;
     level--;
 }
 
-void Spieler::addTunnelBenutzung( Spiel *zSpiel )
+void Spieler::addTunnelBenutzung( Spiel* zSpiel )
 {
     tunnelBenutzt++;
-    zSpiel->setSpielerZuletztTunnelBenutzt( dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztTunnelBenutzt( dynamic_cast<Spieler*>(getThis()) );
 }
 
-void Spieler::addSchalterBenutzung( Spiel *zSpiel )
+void Spieler::addSchalterBenutzung( Spiel* zSpiel )
 {
     schalterAktiviert++;
-    zSpiel->setSpielerZuletztSchalterAktiviert( dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztSchalterAktiviert( dynamic_cast<Spieler*>(getThis()) );
 }
 
 // aktualisiert auch die team statistik
@@ -447,7 +447,7 @@ void Spieler::addKill()
     kills++;
 }
 
-void Spieler::addTreffer( Spiel *zSpiel )
+void Spieler::addTreffer( Spiel* zSpiel )
 {
     addErfahrung( 2, zSpiel );
     treffer++;
@@ -473,22 +473,22 @@ void Spieler::move( Richtung r, double zeit )
             if( tastenStand[ 'd' ] && r == RECHTS )
                 x += laufTempo * (float)zeit;
         }
-        for( auto e = effekte.getIterator(); e; e++ )
+        for( auto e : effekte )
             e->move( r, zeit );
     }
 }
 
-void Spieler::wiederbelebung( Spiel *zSpiel )
+void Spieler::wiederbelebung( Spiel* zSpiel )
 {
     amLeben = 1;
     leben = (float)maxLeben;
-    zSpiel->setSpielerZuletztWiederbelebt( dynamic_cast<Spieler *>( getThis() ) );
-    Ereignis *e = new Ereignis( SPIELER_WIEDERBELEBT );
-    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztWiederbelebt( dynamic_cast<Spieler*>(getThis()) );
+    Ereignis* e = new Ereignis( SPIELER_WIEDERBELEBT );
+    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
     zSpiel->throwEvent( e );
 }
 
-void Spieler::tick( double zeit, Spiel *zSpiel )
+void Spieler::tick( double zeit, Spiel* zSpiel )
 {
     if( istAmLeben() )
     {
@@ -509,10 +509,10 @@ void Spieler::tick( double zeit, Spiel *zSpiel )
         if( tastenStand[ 'e' ] )
             zSpiel->spielerActivate( this );
         heilung( lebensRegeneration * (float)zeit, zSpiel, 0 );
-        Resource *r = dynamic_cast<Resource *>( current->getThis() );
-        for( auto e = effekte.getIterator(); e; e++ )
+        Resource* r = dynamic_cast<Resource*>(current->getThis());
+        for( auto e : effekte )
         {
-            Resource *t = e->getCurrentResource();
+            Resource* t = e->getCurrentResource();
             if( t )
             {
                 r->release();
@@ -572,7 +572,7 @@ void Spieler::tick( double zeit, Spiel *zSpiel )
     inv.tick( zeit );
 }
 
-void Spieler::render( Bild &rObj )
+void Spieler::render( Bild& rObj )
 {
     if( istAmLeben() )
     {
@@ -585,16 +585,16 @@ void Spieler::render( Bild &rObj )
                 rObj.alphaBildSkall( (int)x, (int)y, (int)w, (int)h, *schadenR->zImage( schadenImage ) );
             rObj.releaseDrawOptions();
         }
-        for( auto e = effekte.getIterator(); e; e++ )
+        for( auto e : effekte )
             e->renderSpieler( rObj );
     }
 }
 
-void Spieler::useItem( Spiel *zSpiel )
+void Spieler::useItem( Spiel* zSpiel )
 {
     if( istAmLeben() && inv.selectedItem() != KEIN_GEGENSTAND && istGegenstandErlaubt( inv.selectedItem() ) )
     {
-        zSpiel->setSpielerZuletztGegenstandAktiviert( dynamic_cast<Spieler *>( getThis() ) );
+        zSpiel->setSpielerZuletztGegenstandAktiviert( dynamic_cast<Spieler*>(getThis()) );
         itemsVerwendet++;
         GegenstandTyp typ = inv.useItem();
         zSpiel->setItemZuletztAktiviert( typ );
@@ -602,8 +602,8 @@ void Spieler::useItem( Spiel *zSpiel )
         {
         case PFEIL:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler *>( getThis() ) ) );
+            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler*>(getThis()) );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler*>(getThis()) ) );
             break;
         case LEBEN:
             addEffekt( new LebenEffect( zSpiel->zResources(), this ) );
@@ -619,8 +619,8 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case KUGEL:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler *>( getThis() ) ) );
+            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler*>(getThis()) );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler*>(getThis()) ) );
             break;
         case ROLLE:
             addEffekt( new RolleEffect( zSpiel->zResources(), this, getAusrichtung() ) );
@@ -630,44 +630,44 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case DRACHENAUGE:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler *>( getThis() ) ) );
+            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler*>(getThis()) );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler*>(getThis()) ) );
             break;
         case FEUERBALL:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler *>( getThis() ) ) );
+            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler*>(getThis()) );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler*>(getThis()) ) );
             break;
         case ENTERHAKEN:
             addEffekt( new EnterhakenEffect( zSpiel->zResources(), this, getAusrichtung() ) );
             break;
         case MINE:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler *>( getThis() ) ) );
+            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler*>(getThis()) );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, dynamic_cast<Spieler*>(getThis()) ) );
             break;
         default:
             break;
         }
-        Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
-        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+        Ereignis* e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
+        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
         e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
         zSpiel->throwEvent( e );
     }
 }
 
-bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
+bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel* zSpiel )
 {
     if( storable( typ ) )
     {
         if( inv.canAddItem( typ ) )
         {
             zSpiel->setItemZuletztAufgehoben( typ );
-            zSpiel->setSpielerZuletztGegenstandAufgehoben( dynamic_cast<Spieler *>( getThis() ) );
+            zSpiel->setSpielerZuletztGegenstandAufgehoben( dynamic_cast<Spieler*>(getThis()) );
             itemsAufgehoben += anz;
             inv.addItem( typ, anz );
-            Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
-            e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+            Ereignis* e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
+            e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
             e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
             e->addParameter( "Anzahl", new Integer( anz ) );
             zSpiel->throwEvent( e );
@@ -679,17 +679,17 @@ bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
     else
     {
         zSpiel->setItemZuletztAufgehoben( typ );
-        zSpiel->setSpielerZuletztGegenstandAufgehoben( dynamic_cast<Spieler *>( getThis() ) );
+        zSpiel->setSpielerZuletztGegenstandAufgehoben( dynamic_cast<Spieler*>(getThis()) );
         itemsAufgehoben += anz;
-        Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
-        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+        Ereignis* e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
+        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
         e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
         e->addParameter( "Anzahl", new Integer( anz ) );
         zSpiel->throwEvent( e );
         for( int i = 0; i < anz; i++ )
         {
-            Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
-            e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+            Ereignis* e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
+            e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
             e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
             zSpiel->throwEvent( e );
             itemsVerwendet++;
@@ -719,19 +719,19 @@ bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
 }
 
 // heilt auch um den lebensraub prozentsatz
-void Spieler::addGemachterSchaden( float schaden, Spiel *zSpiel )
+void Spieler::addGemachterSchaden( float schaden, Spiel* zSpiel )
 {
-    zSpiel->setSpielerZuletztSchadenGemacht( dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztSchadenGemacht( dynamic_cast<Spieler*>(getThis()) );
     schadenGemacht += schaden;
     heilung( schaden / 100 * lebensraub, zSpiel );
-    Ereignis *e = new Ereignis( SPIELER_MACHT_SCHADEN );
-    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+    Ereignis* e = new Ereignis( SPIELER_MACHT_SCHADEN );
+    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
     e->addParameter( "Wert", new Float( schaden ) );
     zSpiel->throwEvent( e );
 }
 
 // zieht die rüstung ab
-void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel )
+void Spieler::nimmSchaden( float schaden, Spieler* zVerursacher, Richtung r, Spiel* zSpiel )
 {
     if( !isVerwundbar( r ) || !istAmLeben() )
         return;
@@ -741,11 +741,11 @@ void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spi
     schaden = leben < schaden ? leben : schaden;
     schadenGenommen += schaden;
     leben -= schaden;
-    zSpiel->setSpielerZuletztSchadenGenommen( dynamic_cast<Spieler *>( getThis() ) );
+    zSpiel->setSpielerZuletztSchadenGenommen( dynamic_cast<Spieler*>(getThis()) );
     if( zVerursacher )
         zVerursacher->addGemachterSchaden( schaden, zSpiel );
-    Ereignis *e = new Ereignis( SPIELER_NIMMT_SCHADEN );
-    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+    Ereignis* e = new Ereignis( SPIELER_NIMMT_SCHADEN );
+    e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
     e->addParameter( "Wert", new Float( schaden ) );
     zSpiel->throwEvent( e );
     showSchaden = 1;
@@ -759,31 +759,31 @@ void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spi
         schadenImage = 0;
         showSchaden = 0;
         showHeilung = 0;
-        wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
+        wiederbelebungsZeit = (float)((float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit());
         wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
         team->addTod();
         amLeben = 0;
         tode++;
-        zSpiel->setSpielerZuletztGestorben( dynamic_cast<Spieler *>( getThis() ) );
+        zSpiel->setSpielerZuletztGestorben( dynamic_cast<Spieler*>(getThis()) );
         if( zVerursacher )
             zVerursacher->addKill();
         zSpiel->addAnimation( new SingleAnimation( getX(), getY(), getWidth(), getHeight(), resources->getResource( R_SPIELER_STIRBT, color ) ) );
-        Ereignis *e = new Ereignis( SPIELER_STIRBT );
-        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+        Ereignis* e = new Ereignis( SPIELER_STIRBT );
+        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
         zSpiel->throwEvent( e );
     }
 }
 
-void Spieler::heilung( float heal, Spiel *zSpiel, bool show )
+void Spieler::heilung( float heal, Spiel* zSpiel, bool show )
 {
     if( istAmLeben() )
     {
         heal = heal + leben > maxLeben ? maxLeben - leben : heal;
         lebenGeheilt += heal;
         leben += heal;
-        zSpiel->setSpielerZuletztGeheilt( dynamic_cast<Spieler *>( getThis() ) );
-        Ereignis *e = new Ereignis( SPIELER_WIRD_GEHEILT );
-        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler *>( getThis() ) );
+        zSpiel->setSpielerZuletztGeheilt( dynamic_cast<Spieler*>(getThis()) );
+        Ereignis* e = new Ereignis( SPIELER_WIRD_GEHEILT );
+        e->addParameter( "Betroffener Spieler", dynamic_cast<Spieler*>(getThis()) );
         e->addParameter( "Wert", new Float( heal ) );
         zSpiel->throwEvent( e );
         if( show )
@@ -816,12 +816,12 @@ void Spieler::setLebensRegeneration( float reg )
     lebensRegeneration = reg;
 }
 
-void Spieler::setName( const char *name )
+void Spieler::setName( const char* name )
 {
     this->name = name;
 }
 
-void Spieler::setLevel( int level, Spiel *zSpiel )
+void Spieler::setLevel( int level, Spiel* zSpiel )
 {
     if( level < 0 || level > 100 )
         return;
@@ -858,7 +858,7 @@ void Spieler::setMaxLeben( int leben )
         this->leben = (float)maxLeben;
 }
 
-void Spieler::setErfahrung( float erf, Spiel *zSpiel )
+void Spieler::setErfahrung( float erf, Spiel* zSpiel )
 {
     erfahrung = erf;
     while( erfahrung < 0 )
@@ -902,14 +902,14 @@ float Spieler::getSchadenBonus() const
     return schadensBonus;
 }
 
-Team *Spieler::zTeam() const
+Team* Spieler::zTeam() const
 {
     return team;
 }
 
-Team *Spieler::getTeam() const
+Team* Spieler::getTeam() const
 {
-    return team ? dynamic_cast<Team *>( team->getThis() ) : 0;
+    return team ? dynamic_cast<Team*>(team->getThis()) : 0;
 }
 
 int Spieler::getFarbe() const
@@ -924,7 +924,7 @@ int Spieler::getAccountId() const
 
 int Spieler::getPunkte() const
 {
-    return kills - tode + ( treffer - getroffen ) / 2;
+    return kills - tode + (treffer - getroffen) / 2;
 }
 
 bool Spieler::istAmLeben() const
@@ -940,7 +940,7 @@ float Spieler::getLaufTempo() const
 bool Spieler::isVerwundbar( Richtung r ) const
 {
     bool verwundbar = 1;
-    for( auto e = effekte.getIterator(); e; e++ )
+    for( auto e : effekte )
     {
         verwundbar &= e->istSpielerVerwundbar( r );
         if( !verwundbar )
@@ -952,7 +952,7 @@ bool Spieler::isVerwundbar( Richtung r ) const
 bool Spieler::istBeweglich( Richtung r ) const
 {
     bool beweglich = 1;
-    for( auto e = effekte.getIterator(); e; e++ )
+    for( auto e : effekte )
     {
         beweglich &= e->istSpielerBeweglich( r );
         if( !beweglich )
@@ -961,10 +961,10 @@ bool Spieler::istBeweglich( Richtung r ) const
     return 1;
 }
 
-bool Spieler::istSichtbar( Team *zTeam ) const
+bool Spieler::istSichtbar( Team* zTeam ) const
 {
     bool sichtbar = 1;
-    for( auto e = effekte.getIterator(); e; e++ )
+    for( auto e : effekte )
     {
         sichtbar &= e->istSpielerSichtbar( zTeam );
         if( !sichtbar )
@@ -976,7 +976,7 @@ bool Spieler::istSichtbar( Team *zTeam ) const
 bool Spieler::istGegenstandErlaubt( GegenstandTyp typ ) const
 {
     bool erlaubt = !brauchtRichtung( typ ) || ausrichtung != MITTE;
-    for( auto e = effekte.getIterator(); e; e++ )
+    for( auto e : effekte )
     {
         erlaubt &= e->istGegenstandErlaubt( typ );
         if( !erlaubt )
@@ -1100,19 +1100,19 @@ GegenstandTyp Spieler::getInventorySlot( int index ) const
     return inv.getItemTyp( index );
 }
 
-const char *Spieler::getName() const
+const char* Spieler::getName() const
 {
     return name;
 }
 
-const Inventar &Spieler::getInventory() const
+const Inventar& Spieler::getInventory() const
 {
     return inv;
 }
 
-Iterator<Effect *> Spieler::getEffects() const
+Iterator<Effect*> Spieler::getEffects() const
 {
-    return effekte.getIterator();
+    return effekte.begin();
 }
 
 

StickmanWorldOnline/StickmanWorldOnline.vcxproj

@@ -133,32 +133,32 @@
     <VCProjectVersion>15.0</VCProjectVersion>
     <ProjectGuid>{1bd07113-b8c1-4634-bcab-4aa7196b3fe1}</ProjectGuid>
     <RootNamespace>StickmanWorldOnline</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>

StickmanWorldOnline/Trigger.cpp

@@ -2,7 +2,7 @@
 #include "Gegenstand.h"
 
 
-VarPointer::VarPointer( const char *name, Variable *var )
+VarPointer::VarPointer( const char* name, Variable* var )
     : ReferenceCounter()
 {
     this->name = name;
@@ -20,24 +20,24 @@ Text VarPointer::getName() const
     return name;
 }
 
-void VarPointer::setVariable( Variable *var )
+void VarPointer::setVariable( Variable* var )
 {
     if( this->var )
         this->var->release();
     this->var = var;
 }
 
-Variable *VarPointer::getVariable() const
+Variable* VarPointer::getVariable() const
 {
-    return var ? dynamic_cast<Variable *>( var->getThis() ) : 0;
+    return var ? dynamic_cast<Variable*>(var->getThis()) : 0;
 }
 
-Variable *VarPointer::zVariable() const
+Variable* VarPointer::zVariable() const
 {
     return var;
 }
 
-VarPointer::operator Variable *( ) const
+VarPointer::operator Variable* () const
 {
     return var;
 }
@@ -50,9 +50,9 @@ LocalMemory::LocalMemory()
 LocalMemory::~LocalMemory()
 {}
 
-void LocalMemory::setVar( const char *name, Variable *var )
+void LocalMemory::setVar( const char* name, Variable* var )
 {
-    for( auto v = vars.getIterator(); v; v++ )
+    for( auto v : vars )
     {
         if( v->getName().istGleich( name ) )
         {
@@ -63,9 +63,9 @@ void LocalMemory::setVar( const char *name, Variable *var )
     vars.add( new VarPointer( name, var ) );
 }
 
-Variable *LocalMemory::getVariable( const char *name )
+Variable* LocalMemory::getVariable( const char* name )
 {
-    for( auto v = vars.getIterator(); v; v++ )
+    for( auto v : vars )
     {
         if( v->getName().istGleich( name ) )
             return v->getVariable();
@@ -73,9 +73,9 @@ Variable *LocalMemory::getVariable( const char *name )
     return 0;
 }
 
-Variable *LocalMemory::zVariable( const char *name )
+Variable* LocalMemory::zVariable( const char* name )
 {
-    for( auto v = vars.getIterator(); v; v++ )
+    for( auto v : vars )
     {
         if( v->getName().istGleich( name ) )
             return v->zVariable();
@@ -127,7 +127,7 @@ int ProgramCounter::currentPosition() const
 }
 
 
-Bedingung::Bedingung( Aktion *expression )
+Bedingung::Bedingung( Aktion* expression )
     : ReferenceCounter()
 {
     this->expression = expression;
@@ -139,14 +139,14 @@ Bedingung::~Bedingung()
         expression->release();
 }
 
-void Bedingung::setExpression( Aktion *expr )
+void Bedingung::setExpression( Aktion* expr )
 {
     if( expression )
         expression->release();
     expression = expr;
 }
 
-bool Bedingung::check( Spiel *zSpiel, Ereignis *zEreignis )
+bool Bedingung::check( Spiel* zSpiel, Ereignis* zEreignis )
 {
     if( !expression )
         return 1;
@@ -155,17 +155,17 @@ bool Bedingung::check( Spiel *zSpiel, Ereignis *zEreignis )
     LocalMemory m;
     while( !expression->runNext( zSpiel, zEreignis, &m, &c, wait ) )
         wait = 0;
-    Variable *var = m.zVariable( "__return__" );
+    Variable* var = m.zVariable( "__return__" );
     return isTrue( var );
 }
 
-Aktion *Bedingung::zExpression() const
+Aktion* Bedingung::zExpression() const
 {
     return expression;
 }
 
 
-Trigger::Trigger( int id, const char *name, int ereignisAnzahl, EreignisTyp *ereignisse, RCArray< Bedingung > *bedingungen, RCArray< Aktion > *aktionen )
+Trigger::Trigger( int id, const char* name, int ereignisAnzahl, EreignisTyp* ereignisse, RCArray< Bedingung >* bedingungen, RCArray< Aktion >* aktionen )
     : Variable( TRIGGER )
 {
     this->id = id;
@@ -205,25 +205,25 @@ int Trigger::getAktionAnzahl() const
     return aktionen->getEintragAnzahl();
 }
 
-Aktion *Trigger::zAktion( int index ) const
+Aktion* Trigger::zAktion( int index ) const
 {
     return aktionen->z( index );
 }
 
-Aktion *Trigger::getAktion( int index ) const
+Aktion* Trigger::getAktion( int index ) const
 {
     return aktionen->get( index );
 }
 
 // return: 0, falls die bedingungen nicht erfüllt sind
-TriggerRun *Trigger::runTrigger( Ereignis *e, Spiel *zSpiel )
+TriggerRun* Trigger::runTrigger( Ereignis* e, Spiel* zSpiel )
 {
     if( !aktiv )
     {
         e->release();
         return 0;
     }
-    for( auto b = bedingungen->getIterator(); b; b++ )
+    for( auto b : *bedingungen )
     {
         if( !b->check( zSpiel, e ) )
         {
@@ -232,7 +232,7 @@ TriggerRun *Trigger::runTrigger( Ereignis *e, Spiel *zSpiel )
         }
     }
     runCount++;
-    return new TriggerRun( dynamic_cast<Trigger *>( getThis() ), e, zSpiel );
+    return new TriggerRun( dynamic_cast<Trigger*>(getThis()), e, zSpiel );
 }
 
 int Trigger::getId() const
@@ -245,7 +245,7 @@ int Trigger::getRuns() const
     return runCount;
 }
 
-const char *Trigger::getName() const
+const char* Trigger::getName() const
 {
     return name.getText();
 }
@@ -256,7 +256,7 @@ bool Trigger::istAktiv() const
 }
 
 
-TriggerRun::TriggerRun( Trigger *trig, Ereignis *e, Spiel *zSpiel )
+TriggerRun::TriggerRun( Trigger* trig, Ereignis* e, Spiel* zSpiel )
     : ReferenceCounter()
 {
     trigger = trig;
@@ -281,7 +281,7 @@ bool TriggerRun::runNext( double t )
         int current = counter.currentPosition();
         if( current >= trigger->getAktionAnzahl() )
             return 0;
-        Aktion *ak = trigger->zAktion( current );
+        Aktion* ak = trigger->zAktion( current );
         if( !ak || ak->runNext( zSpiel, ereignis, &localMem, &counter, waitCount ) )
             counter.count();
         if( counter.currentPosition() >= trigger->getAktionAnzahl() )
@@ -290,7 +290,7 @@ bool TriggerRun::runNext( double t )
     return 1;
 }
 
-Trigger *TriggerRun::getTrigger() const
+Trigger* TriggerRun::getTrigger() const
 {
-    return  dynamic_cast<Trigger *>( trigger->getThis() );
+    return  dynamic_cast<Trigger*>(trigger->getThis());
 }