change array iteration

Asteroids/Editor.cpp

@@ -15,7 +15,7 @@ Editor::~Editor()
 {}
 
 // nicht constant
-void Editor::setPfad( char *pfad )
+void Editor::setPfad( char* pfad )
 {
     this->pfad = pfad;
     this->pfad += "/editor";
@@ -26,7 +26,7 @@ void Editor::open()
 
 }
 
-bool Editor::nachricht( SKlient *k )
+bool Editor::nachricht( SKlient* k )
 {
     err = "";
     char n = 0;
@@ -63,12 +63,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/player";
         Datei d;
         d.setDatei( tmpPf );
-        RCArray< Text > *files = d.getDateiListe();
+        RCArray< Text >* files = d.getDateiListe();
         if( files )
         {
             k->sendeEncrypted( "\1", 1 );
             int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char *)&anz, 4 );
+            k->sendeEncrypted( (char*)&anz, 4 );
             for( int i = 0; i < anz; i++ )
             {
                 Text pf = tmpPf;
@@ -77,28 +77,28 @@ bool Editor::nachricht( SKlient *k )
                 Datei player;
                 player.setDatei( pf );
                 player.open( Datei::Style::lesen );
-                SpielerStr p( dynamic_cast<Datei *>( player.getThis() ) );
+                SpielerStr p( dynamic_cast<Datei*>(player.getThis()) );
                 player.close();
-                k->sendeEncrypted( (char *)&p.id, 4 );
-                k->sendeEncrypted( (char *)&p.pos.x, 4 );
-                k->sendeEncrypted( (char *)&p.pos.y, 4 );
-                k->sendeEncrypted( (char *)&p.rot, 8 );
-                k->sendeEncrypted( (char *)&p.beschleunigung, 8 );
-                k->sendeEncrypted( (char *)&p.maxStability, 4 );
-                k->sendeEncrypted( (char *)&p.maxEnergie, 4 );
-                k->sendeEncrypted( (char *)&p.reparatur, 8 );
-                k->sendeEncrypted( (char *)&p.akkuLeistung, 8 );
-                k->sendeEncrypted( (char *)&p.laserIntensity, 4 );
-                k->sendeEncrypted( (char *)&p.laserEffizienz, 4 );
-                k->sendeEncrypted( (char *)&p.laserTempo, 4 );
-                k->sendeEncrypted( (char *)&p.wendigkeit, 8 );
-                k->sendeEncrypted( (char *)&p.antriebEffizienz, 8 );
-                k->sendeEncrypted( (char *)&p.energieSchild, 8 );
-                k->sendeEncrypted( (char *)&p.energieSchildEffizienz, 8 );
-                k->sendeEncrypted( (char *)&p.netzwerk, 4 );
-                k->sendeEncrypted( (char *)&p.skillPunkte, 4 );
-                k->sendeEncrypted( (char *)&p.m2d, 4 );
-                k->sendeEncrypted( (char *)&p.bild, 4 );
+                k->sendeEncrypted( (char*)&p.id, 4 );
+                k->sendeEncrypted( (char*)&p.pos.x, 4 );
+                k->sendeEncrypted( (char*)&p.pos.y, 4 );
+                k->sendeEncrypted( (char*)&p.rot, 8 );
+                k->sendeEncrypted( (char*)&p.beschleunigung, 8 );
+                k->sendeEncrypted( (char*)&p.maxStability, 4 );
+                k->sendeEncrypted( (char*)&p.maxEnergie, 4 );
+                k->sendeEncrypted( (char*)&p.reparatur, 8 );
+                k->sendeEncrypted( (char*)&p.akkuLeistung, 8 );
+                k->sendeEncrypted( (char*)&p.laserIntensity, 4 );
+                k->sendeEncrypted( (char*)&p.laserEffizienz, 4 );
+                k->sendeEncrypted( (char*)&p.laserTempo, 4 );
+                k->sendeEncrypted( (char*)&p.wendigkeit, 8 );
+                k->sendeEncrypted( (char*)&p.antriebEffizienz, 8 );
+                k->sendeEncrypted( (char*)&p.energieSchild, 8 );
+                k->sendeEncrypted( (char*)&p.energieSchildEffizienz, 8 );
+                k->sendeEncrypted( (char*)&p.netzwerk, 4 );
+                k->sendeEncrypted( (char*)&p.skillPunkte, 4 );
+                k->sendeEncrypted( (char*)&p.m2d, 4 );
+                k->sendeEncrypted( (char*)&p.bild, 4 );
             }
         }
         else
@@ -115,12 +115,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/team";
         Datei d;
         d.setDatei( tmpPf );
-        RCArray< Text > *files = d.getDateiListe();
+        RCArray< Text >* files = d.getDateiListe();
         if( files )
         {
             k->sendeEncrypted( "\1", 1 );
             int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char *)&anz, 4 );
+            k->sendeEncrypted( (char*)&anz, 4 );
             for( int i = 0; i < anz; i++ )
             {
                 Text pf = tmpPf;
@@ -129,23 +129,23 @@ bool Editor::nachricht( SKlient *k )
                 Datei team;
                 team.setDatei( pf );
                 team.open( Datei::Style::lesen );
-                TeamStr t( dynamic_cast<Datei *>( team.getThis() ) );
+                TeamStr t( dynamic_cast<Datei*>(team.getThis()) );
                 team.close();
-                k->sendeEncrypted( (char *)&t.id, 4 );
-                k->sendeEncrypted( (char *)&t.maxPunkte, 4 );
-                k->sendeEncrypted( (char *)&t.beschleunigung, 8 );
-                k->sendeEncrypted( (char *)&t.maxStability, 4 );
-                k->sendeEncrypted( (char *)&t.maxEnergie, 4 );
-                k->sendeEncrypted( (char *)&t.reparatur, 8 );
-                k->sendeEncrypted( (char *)&t.akkuLeistung, 8 );
-                k->sendeEncrypted( (char *)&t.laserIntensity, 4 );
-                k->sendeEncrypted( (char *)&t.laserEffizienz, 4 );
-                k->sendeEncrypted( (char *)&t.laserTempo, 4 );
-                k->sendeEncrypted( (char *)&t.wendigkeit, 8 );
-                k->sendeEncrypted( (char *)&t.antriebEffizienz, 8 );
-                k->sendeEncrypted( (char *)&t.energieSchild, 8 );
-                k->sendeEncrypted( (char *)&t.energieSchildEffizienz, 8 );
-                k->sendeEncrypted( (char *)&t.punkte, 4 );
+                k->sendeEncrypted( (char*)&t.id, 4 );
+                k->sendeEncrypted( (char*)&t.maxPunkte, 4 );
+                k->sendeEncrypted( (char*)&t.beschleunigung, 8 );
+                k->sendeEncrypted( (char*)&t.maxStability, 4 );
+                k->sendeEncrypted( (char*)&t.maxEnergie, 4 );
+                k->sendeEncrypted( (char*)&t.reparatur, 8 );
+                k->sendeEncrypted( (char*)&t.akkuLeistung, 8 );
+                k->sendeEncrypted( (char*)&t.laserIntensity, 4 );
+                k->sendeEncrypted( (char*)&t.laserEffizienz, 4 );
+                k->sendeEncrypted( (char*)&t.laserTempo, 4 );
+                k->sendeEncrypted( (char*)&t.wendigkeit, 8 );
+                k->sendeEncrypted( (char*)&t.antriebEffizienz, 8 );
+                k->sendeEncrypted( (char*)&t.energieSchild, 8 );
+                k->sendeEncrypted( (char*)&t.energieSchildEffizienz, 8 );
+                k->sendeEncrypted( (char*)&t.punkte, 4 );
             }
         }
         else
@@ -162,12 +162,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/objekt";
         Datei d;
         d.setDatei( tmpPf );
-        RCArray< Text > *files = d.getDateiListe();
+        RCArray< Text >* files = d.getDateiListe();
         if( files )
         {
             k->sendeEncrypted( "\1", 1 );
             int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char *)&anz, 4 );
+            k->sendeEncrypted( (char*)&anz, 4 );
             for( int i = 0; i < anz; i++ )
             {
                 Text pf = tmpPf;
@@ -176,22 +176,22 @@ bool Editor::nachricht( SKlient *k )
                 Datei object;
                 object.setDatei( pf );
                 object.open( Datei::Style::lesen );
-                ObjektStr o( dynamic_cast<Datei *>( object.getThis() ) );
+                ObjektStr o( dynamic_cast<Datei*>(object.getThis()) );
                 object.close();
-                k->sendeEncrypted( (char *)&o.pos.x, 4 );
-                k->sendeEncrypted( (char *)&o.pos.y, 4 );
-                k->sendeEncrypted( (char *)&o.rot, 4 );
-                k->sendeEncrypted( (char *)&o.scale, 4 );
-                k->sendeEncrypted( (char *)&o.id, 4 );
-                k->sendeEncrypted( (char *)&o.m2d, 4 );
-                k->sendeEncrypted( (char *)&o.bild, 4 );
-                k->sendeEncrypted( (char *)&o.style, 4 );
-                k->sendeEncrypted( (char *)&o.maxStability, 4 );
-                k->sendeEncrypted( (char *)&o.maxEnergie, 4 );
-                k->sendeEncrypted( (char *)&o.energieRadius, 4 );
-                k->sendeEncrypted( (char *)&o.reparatur, 8 );
-                k->sendeEncrypted( (char *)&o.akkuLeistung, 8 );
-                k->sendeEncrypted( (char *)&o.team, 1 );
+                k->sendeEncrypted( (char*)&o.pos.x, 4 );
+                k->sendeEncrypted( (char*)&o.pos.y, 4 );
+                k->sendeEncrypted( (char*)&o.rot, 4 );
+                k->sendeEncrypted( (char*)&o.scale, 4 );
+                k->sendeEncrypted( (char*)&o.id, 4 );
+                k->sendeEncrypted( (char*)&o.m2d, 4 );
+                k->sendeEncrypted( (char*)&o.bild, 4 );
+                k->sendeEncrypted( (char*)&o.style, 4 );
+                k->sendeEncrypted( (char*)&o.maxStability, 4 );
+                k->sendeEncrypted( (char*)&o.maxEnergie, 4 );
+                k->sendeEncrypted( (char*)&o.energieRadius, 4 );
+                k->sendeEncrypted( (char*)&o.reparatur, 8 );
+                k->sendeEncrypted( (char*)&o.akkuLeistung, 8 );
+                k->sendeEncrypted( (char*)&o.team, 1 );
             }
         }
         else
@@ -206,26 +206,26 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         SpielerStr p( 0 );
-        k->getNachrichtEncrypted( (char *)&p.id, 4 );
-        k->getNachrichtEncrypted( (char *)&p.pos.x, 4 );
-        k->getNachrichtEncrypted( (char *)&p.pos.y, 4 );
-        k->getNachrichtEncrypted( (char *)&p.rot, 8 );
-        k->getNachrichtEncrypted( (char *)&p.beschleunigung, 8 );
-        k->getNachrichtEncrypted( (char *)&p.maxStability, 4 );
-        k->getNachrichtEncrypted( (char *)&p.maxEnergie, 4 );
-        k->getNachrichtEncrypted( (char *)&p.reparatur, 8 );
-        k->getNachrichtEncrypted( (char *)&p.akkuLeistung, 8 );
-        k->getNachrichtEncrypted( (char *)&p.laserIntensity, 4 );
-        k->getNachrichtEncrypted( (char *)&p.laserEffizienz, 4 );
-        k->getNachrichtEncrypted( (char *)&p.laserTempo, 4 );
-        k->getNachrichtEncrypted( (char *)&p.wendigkeit, 8 );
-        k->getNachrichtEncrypted( (char *)&p.antriebEffizienz, 8 );
-        k->getNachrichtEncrypted( (char *)&p.energieSchild, 8 );
-        k->getNachrichtEncrypted( (char *)&p.energieSchildEffizienz, 8 );
-        k->getNachrichtEncrypted( (char *)&p.netzwerk, 4 );
-        k->getNachrichtEncrypted( (char *)&p.skillPunkte, 4 );
-        k->getNachrichtEncrypted( (char *)&p.m2d, 4 );
-        k->getNachrichtEncrypted( (char *)&p.bild, 4 );
+        k->getNachrichtEncrypted( (char*)&p.id, 4 );
+        k->getNachrichtEncrypted( (char*)&p.pos.x, 4 );
+        k->getNachrichtEncrypted( (char*)&p.pos.y, 4 );
+        k->getNachrichtEncrypted( (char*)&p.rot, 8 );
+        k->getNachrichtEncrypted( (char*)&p.beschleunigung, 8 );
+        k->getNachrichtEncrypted( (char*)&p.maxStability, 4 );
+        k->getNachrichtEncrypted( (char*)&p.maxEnergie, 4 );
+        k->getNachrichtEncrypted( (char*)&p.reparatur, 8 );
+        k->getNachrichtEncrypted( (char*)&p.akkuLeistung, 8 );
+        k->getNachrichtEncrypted( (char*)&p.laserIntensity, 4 );
+        k->getNachrichtEncrypted( (char*)&p.laserEffizienz, 4 );
+        k->getNachrichtEncrypted( (char*)&p.laserTempo, 4 );
+        k->getNachrichtEncrypted( (char*)&p.wendigkeit, 8 );
+        k->getNachrichtEncrypted( (char*)&p.antriebEffizienz, 8 );
+        k->getNachrichtEncrypted( (char*)&p.energieSchild, 8 );
+        k->getNachrichtEncrypted( (char*)&p.energieSchildEffizienz, 8 );
+        k->getNachrichtEncrypted( (char*)&p.netzwerk, 4 );
+        k->getNachrichtEncrypted( (char*)&p.skillPunkte, 4 );
+        k->getNachrichtEncrypted( (char*)&p.m2d, 4 );
+        k->getNachrichtEncrypted( (char*)&p.bild, 4 );
         Text pf = pfad.getText();
         pf += "/player/";
         pf += p.id;
@@ -234,7 +234,7 @@ bool Editor::nachricht( SKlient *k )
         player.setDatei( pf );
         if( player.open( Datei::Style::schreiben ) )
         {
-            p.save( dynamic_cast<Datei *>( player.getThis() ) );
+            p.save( dynamic_cast<Datei*>(player.getThis()) );
             player.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -247,21 +247,21 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         TeamStr t( 0 );
-        k->getNachrichtEncrypted( (char *)&t.id, 4 );
-        k->getNachrichtEncrypted( (char *)&t.maxPunkte, 4 );
-        k->getNachrichtEncrypted( (char *)&t.beschleunigung, 8 );
-        k->getNachrichtEncrypted( (char *)&t.maxStability, 4 );
-        k->getNachrichtEncrypted( (char *)&t.maxEnergie, 4 );
-        k->getNachrichtEncrypted( (char *)&t.reparatur, 8 );
-        k->getNachrichtEncrypted( (char *)&t.akkuLeistung, 8 );
-        k->getNachrichtEncrypted( (char *)&t.laserIntensity, 4 );
-        k->getNachrichtEncrypted( (char *)&t.laserEffizienz, 4 );
-        k->getNachrichtEncrypted( (char *)&t.laserTempo, 4 );
-        k->getNachrichtEncrypted( (char *)&t.wendigkeit, 8 );
-        k->getNachrichtEncrypted( (char *)&t.antriebEffizienz, 8 );
-        k->getNachrichtEncrypted( (char *)&t.energieSchild, 8 );
-        k->getNachrichtEncrypted( (char *)&t.energieSchildEffizienz, 8 );
-        k->getNachrichtEncrypted( (char *)&t.punkte, 4 );
+        k->getNachrichtEncrypted( (char*)&t.id, 4 );
+        k->getNachrichtEncrypted( (char*)&t.maxPunkte, 4 );
+        k->getNachrichtEncrypted( (char*)&t.beschleunigung, 8 );
+        k->getNachrichtEncrypted( (char*)&t.maxStability, 4 );
+        k->getNachrichtEncrypted( (char*)&t.maxEnergie, 4 );
+        k->getNachrichtEncrypted( (char*)&t.reparatur, 8 );
+        k->getNachrichtEncrypted( (char*)&t.akkuLeistung, 8 );
+        k->getNachrichtEncrypted( (char*)&t.laserIntensity, 4 );
+        k->getNachrichtEncrypted( (char*)&t.laserEffizienz, 4 );
+        k->getNachrichtEncrypted( (char*)&t.laserTempo, 4 );
+        k->getNachrichtEncrypted( (char*)&t.wendigkeit, 8 );
+        k->getNachrichtEncrypted( (char*)&t.antriebEffizienz, 8 );
+        k->getNachrichtEncrypted( (char*)&t.energieSchild, 8 );
+        k->getNachrichtEncrypted( (char*)&t.energieSchildEffizienz, 8 );
+        k->getNachrichtEncrypted( (char*)&t.punkte, 4 );
         Text pf = pfad.getText();
         pf += "/player/";
         pf += t.id;
@@ -270,7 +270,7 @@ bool Editor::nachricht( SKlient *k )
         team.setDatei( pf );
         if( team.open( Datei::Style::schreiben ) )
         {
-            t.save( dynamic_cast<Datei *>( team.getThis() ) );
+            t.save( dynamic_cast<Datei*>(team.getThis()) );
             team.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -283,20 +283,20 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         ObjektStr o( 0 );
-        k->getNachrichtEncrypted( (char *)&o.pos.x, 4 );
-        k->getNachrichtEncrypted( (char *)&o.pos.y, 4 );
-        k->getNachrichtEncrypted( (char *)&o.rot, 4 );
-        k->getNachrichtEncrypted( (char *)&o.scale, 4 );
-        k->getNachrichtEncrypted( (char *)&o.id, 4 );
-        k->getNachrichtEncrypted( (char *)&o.m2d, 4 );
-        k->getNachrichtEncrypted( (char *)&o.bild, 4 );
-        k->getNachrichtEncrypted( (char *)&o.style, 4 );
-        k->getNachrichtEncrypted( (char *)&o.maxStability, 4 );
-        k->getNachrichtEncrypted( (char *)&o.maxEnergie, 4 );
-        k->getNachrichtEncrypted( (char *)&o.energieRadius, 4 );
-        k->getNachrichtEncrypted( (char *)&o.reparatur, 8 );
-        k->getNachrichtEncrypted( (char *)&o.akkuLeistung, 8 );
-        k->getNachrichtEncrypted( (char *)&o.team, 1 );
+        k->getNachrichtEncrypted( (char*)&o.pos.x, 4 );
+        k->getNachrichtEncrypted( (char*)&o.pos.y, 4 );
+        k->getNachrichtEncrypted( (char*)&o.rot, 4 );
+        k->getNachrichtEncrypted( (char*)&o.scale, 4 );
+        k->getNachrichtEncrypted( (char*)&o.id, 4 );
+        k->getNachrichtEncrypted( (char*)&o.m2d, 4 );
+        k->getNachrichtEncrypted( (char*)&o.bild, 4 );
+        k->getNachrichtEncrypted( (char*)&o.style, 4 );
+        k->getNachrichtEncrypted( (char*)&o.maxStability, 4 );
+        k->getNachrichtEncrypted( (char*)&o.maxEnergie, 4 );
+        k->getNachrichtEncrypted( (char*)&o.energieRadius, 4 );
+        k->getNachrichtEncrypted( (char*)&o.reparatur, 8 );
+        k->getNachrichtEncrypted( (char*)&o.akkuLeistung, 8 );
+        k->getNachrichtEncrypted( (char*)&o.team, 1 );
         Text pf = pfad.getText();
         pf += "/objekt/";
         pf += o.id;
@@ -305,7 +305,7 @@ bool Editor::nachricht( SKlient *k )
         objekt.setDatei( pf );
         if( objekt.erstellen() && objekt.open( Datei::Style::schreiben ) )
         {
-            o.save( dynamic_cast<Datei *>( objekt.getThis() ) );
+            o.save( dynamic_cast<Datei*>(objekt.getThis()) );
             objekt.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -318,7 +318,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text pf = pfad.getText();
         pf += "/objekt/";
         pf += id;
@@ -338,12 +338,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/resource";
         Datei d;
         d.setDatei( tmpPf );
-        RCArray< Text > *files = d.getDateiListe();
+        RCArray< Text >* files = d.getDateiListe();
         if( files )
         {
             k->sendeEncrypted( "\1", 1 );
             int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char *)&anz, 4 );
+            k->sendeEncrypted( (char*)&anz, 4 );
             for( int i = 0; i < anz; i++ )
             {
                 Text pf = tmpPf;
@@ -353,10 +353,10 @@ bool Editor::nachricht( SKlient *k )
                 resource.setDatei( pf );
                 resource.open( Datei::Style::lesen );
                 int id = *files->z( i );
-                k->sendeEncrypted( (char *)&id, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
                 char len = 0;
                 resource.lese( &len, 1 );
-                char *path = new char[ len + 1 ];
+                char* path = new char[ len + 1 ];
                 path[ (int)len ] = 0;
                 resource.lese( path, len );
                 k->sendeEncrypted( &len, 1 );
@@ -383,10 +383,10 @@ bool Editor::nachricht( SKlient *k )
         {
             k->sendeEncrypted( "\1", 1 );
             int size = 0;
-            d.lese( (char *)&size, 4 );
-            k->sendeEncrypted( (char *)&size, 4 );
-            d.lese( (char *)&size, 4 );
-            k->sendeEncrypted( (char *)&size, 4 );
+            d.lese( (char*)&size, 4 );
+            k->sendeEncrypted( (char*)&size, 4 );
+            d.lese( (char*)&size, 4 );
+            k->sendeEncrypted( (char*)&size, 4 );
             d.close();
         }
         else
@@ -402,14 +402,14 @@ bool Editor::nachricht( SKlient *k )
         k->sendeEncrypted( "\1", 1 );
         Datei d;
         d.setDatei( Text( pfad.getText() ) + "/resource" );
-        RCArray<Text> *list = d.getDateiListe();
+        RCArray<Text>* list = d.getDateiListe();
         int nId = 0;
         bool found = 0;
         do
         {
             nId++;
             found = 0;
-            for( auto t = list->getIterator(); t; t++ )
+            for( auto t : *list )
             {
                 if( t->istGleich( Text( nId ) + ".r" ) )
                 {
@@ -420,18 +420,18 @@ bool Editor::nachricht( SKlient *k )
         } while( found );
         list->release();
         unsigned char len = 0;
-        k->getNachrichtEncrypted( (char *)&len, 1 );
-        char *path = new char[ len + 1 ];
+        k->getNachrichtEncrypted( (char*)&len, 1 );
+        char* path = new char[ len + 1 ];
         path[ len ] = 0;
         k->getNachrichtEncrypted( path, len );
         d.setDatei( Text( pfad.getText() ) + "/resource/" + nId + ".r" );
         if( d.open( Datei::Style::schreiben ) )
         {
-            d.schreibe( (char *)&len, 1 );
+            d.schreibe( (char*)&len, 1 );
             d.schreibe( path, len );
             d.close();
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&nId, 4 );
+            k->sendeEncrypted( (char*)&nId, 4 );
             return 1;
         }
         err = "Fehler beim schreiben der Datei.";
@@ -446,7 +446,7 @@ bool Editor::nachricht( SKlient *k )
 }
 
 // constant
-char *Editor::getLetzterFehler() const
+char* Editor::getLetzterFehler() const
 {
     return err;
 }
@@ -465,17 +465,17 @@ bool Editor::createSitzung()
         pf = pfad.getText();
         pf += "/resource/";
         int rAnz = 0;
-        d.lese( (char *)&rAnz, 4 );
+        d.lese( (char*)&rAnz, 4 );
         for( int i = 0; i < rAnz; i++ )
         {
             int id = 0;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".r";
             char len = 0;
             d.lese( &len, 1 );
-            char *path = new char[ len + 1 ];
+            char* path = new char[ len + 1 ];
             path[ (int)len ] = 0;
             d.lese( path, len );
             Datei r;
@@ -507,11 +507,11 @@ bool Editor::createSitzung()
             err += "\n";
         }
         __int64 size = 0;
-        d.lese( (char *)&size, 8 );
-        s.schreibe( (char *)&size, 8 );
+        d.lese( (char*)&size, 8 );
+        s.schreibe( (char*)&size, 8 );
         s.close();
         int objAnz = 0;
-        d.lese( (char *)&objAnz, 4 );
+        d.lese( (char*)&objAnz, 4 );
         for( int i = 0; i < objAnz; i++ )
         {
             ObjektStr objStr( &d );
@@ -533,7 +533,7 @@ bool Editor::createSitzung()
             objStr.save( &obj );
             obj.close();
         }
-        SpielerTeamStruktur *sts = new SpielerTeamStruktur();
+        SpielerTeamStruktur* sts = new SpielerTeamStruktur();
         Text tmp = pfad.getText();
         pf.remove( pf.getLength() - 12, pf.getLength() );
         tmp.remove( 0, tmp.positionVon( '/', tmp.anzahlVon( '/' ) ) );
@@ -541,7 +541,7 @@ bool Editor::createSitzung()
         tmp = pfad.getText();
         tmp.remove( tmp.getLength() - 6, tmp.getLength() );
         tmp += "map/server/";
-        KartenLeser *stsReader = new KartenLeser( kartenId, 0, tmp );
+        KartenLeser* stsReader = new KartenLeser( kartenId, 0, tmp );
         stsReader->ladeSpielerTeamStruktur( sts );
         stsReader->release();
         for( int i = 0; i < sts->spielerAnzahl; i++ )
@@ -619,12 +619,12 @@ bool Editor::saveSitzung()
         pf += "/resource";
         Datei res;
         res.setDatei( pf );
-        RCArray<Text> *resList = res.getDateiListe();
+        RCArray<Text>* resList = res.getDateiListe();
         if( resList )
         {
             int anz = resList->getEintragAnzahl();
-            d.schreibe( (char *)&anz, 4 );
-            for( auto resPf = resList->getIterator(); resPf && resPf._; resPf++ )
+            d.schreibe( (char*)&anz, 4 );
+            for( auto resPf : *resList )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -634,10 +634,10 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*resPf;
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char b = 0;
                     r.lese( &b, 1 );
-                    char *buffer = new char[ b + 1 ];
+                    char* buffer = new char[ b + 1 ];
                     buffer[ (int)b ] = 0;
                     r.lese( buffer, b );
                     d.schreibe( &b, 1 );
@@ -667,8 +667,8 @@ bool Editor::saveSitzung()
         if( s.open( Datei::Style::lesen ) )
         {
             __int64 size = 0;
-            s.lese( (char *)&size, 8 );
-            d.schreibe( (char *)&size, 8 );
+            s.lese( (char*)&size, 8 );
+            d.schreibe( (char*)&size, 8 );
             s.close();
         }
         else
@@ -685,12 +685,12 @@ bool Editor::saveSitzung()
         pf += "/objekt";
         Datei obj;
         obj.setDatei( pf );
-        RCArray<Text> *objList = obj.getDateiListe();
+        RCArray<Text>* objList = obj.getDateiListe();
         if( objList )
         {
             int anz = objList->getEintragAnzahl();
-            d.schreibe( (char *)&anz, 4 );
-            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
+            d.schreibe( (char*)&anz, 4 );
+            for( auto objPf : *objList )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -723,7 +723,7 @@ bool Editor::saveSitzung()
         pf += "/player";
         Datei pl;
         pl.setDatei( pf );
-        RCArray<Text> *plList = pl.getDateiListe();
+        RCArray<Text>* plList = pl.getDateiListe();
         if( !plList )
         {
             err = "Fehler beim Lesen von ";
@@ -734,7 +734,7 @@ bool Editor::saveSitzung()
             d.remove();
             return 0;
         }
-        for( auto plPf = plList->getIterator(); plPf && plPf._; plPf++ )
+        for( auto plPf : *plList )
         {
             Text tmp = pf.getText();
             tmp += "/";
@@ -764,7 +764,7 @@ bool Editor::saveSitzung()
         pf += "/team";
         Datei tm;
         tm.setDatei( pf );
-        RCArray<Text> *tmList = tm.getDateiListe();
+        RCArray<Text>* tmList = tm.getDateiListe();
         if( !tmList )
         {
             err = "Fehler beim Lesen von ";
@@ -775,7 +775,7 @@ bool Editor::saveSitzung()
             d.remove();
             return 0;
         }
-        for( auto tmPf = tmList->getIterator(); tmPf && tmPf._; tmPf++ )
+        for( auto tmPf : *tmList )
         {
             Text tmp = pf.getText();
             tmp += "/";
@@ -826,10 +826,10 @@ bool Editor::saveSitzung()
     if( d2.open( Datei::Style::schreiben ) && d.open( Datei::Style::lesen ) )
     {
         __int64 size = d.getSize();
-        char *buffer = new char[ 2048 ];
+        char* buffer = new char[ 2048 ];
         while( size > 0 )
         {
-            int len = (int)( size > 2048 ? 2048 : size );
+            int len = (int)(size > 2048 ? 2048 : size);
             d.lese( buffer, len );
             d2.schreibe( buffer, len );
             size -= len;

Asteroids/Karte.cpp

@@ -25,17 +25,17 @@ Karte::~Karte()
 }
 
 // nicht constant
-void Karte::ladeDaten( Datei *zDatei, SSDatenbankV *zDb, SpielerTeamStruktur *zSts, char *tmpPfad, int kId )
+void Karte::ladeDaten( Datei* zDatei, SSDatenbankV* zDb, SpielerTeamStruktur* zSts, char* tmpPfad, int kId )
 {
     sts = zSts->getThis();
     int ressourceAnz = 0;
-    zDatei->lese( (char *)&ressourceAnz, 4 );
+    zDatei->lese( (char*)&ressourceAnz, 4 );
     for( int i = 0; i < ressourceAnz; i++ )
         ressources->add( new RessourceStr( zDatei, zDb, tmpPfad, kId ) );
-    zDatei->lese( (char *)&size.x, 4 );
-    zDatei->lese( (char *)&size.y, 4 );
+    zDatei->lese( (char*)&size.x, 4 );
+    zDatei->lese( (char*)&size.y, 4 );
     int objektAnzahl = 0;
-    zDatei->lese( (char *)&objektAnzahl, 4 );
+    zDatei->lese( (char*)&objektAnzahl, 4 );
     for( int i = 0; i < objektAnzahl; i++ )
         objekte->add( new ObjektStr( zDatei ) );
     for( int i = 0; i < zSts->spielerAnzahl; i++ )
@@ -50,19 +50,19 @@ Vec2< int > Karte::getSize() const
     return size;
 }
 
-Spieler *Karte::createSpieler( int sNum ) const
+Spieler* Karte::createSpieler( int sNum ) const
 {
     if( !sts || sNum < 0 || sNum >= sts->spielerAnzahl )
         return 0;
-    for( auto s = spieler->getIterator(); s; s++ )
+    for( auto s : *spieler )
     {
         if( s->id == sNum + 1 )
         {
-            Spieler *ret = new Spieler( s );
-            for( auto i = ressources->getIterator(); i && i._; i++ )
+            Spieler* ret = new Spieler( s );
+            for( auto i : *ressources )
             {
                 if( i->getId() == s->m2d )
-                    ret->setModelData( dynamic_cast<Model2DData *>( i->zReccourceM2()->getThis() ) );
+                    ret->setModelData( dynamic_cast<Model2DData*>(i->zReccourceM2()->getThis()) );
             }
             ret->setSpielerFarbe( sts->spielerFarbe->hat( sNum ) ? sts->spielerFarbe->get( sNum ) : 0 );
             return ret;
@@ -71,30 +71,30 @@ Spieler *Karte::createSpieler( int sNum ) const
     return 0;
 }
 
-Team *Karte::createTeam( int tNum ) const
+Team* Karte::createTeam( int tNum ) const
 {
     if( !sts || tNum < 0 || tNum >= sts->teamAnzahl )
         return 0;
-    Team *ret = 0;
-    for( auto t = teams->getIterator(); t; t++ )
+    Team* ret = 0;
+    for( auto t : *teams )
         if( t->id == tNum + 1 )
             ret = new Team( sts->teamFarbe->get( tNum ), sts->teamName->z( tNum )->getText(), t );
     return ret;
 }
 
-SpielObjekt *Karte::createObjekt( int oNum ) const
+SpielObjekt* Karte::createObjekt( int oNum ) const
 {
     if( oNum <= 0 )
         return 0;
-    for( auto o = objekte->getIterator(); o; o++ )
+    for( auto o : *objekte )
     {
         if( o->id == oNum )
         {
-            SpielObjekt *ret = new SpielObjekt( o );
-            for( auto i = ressources->getIterator(); i && i._; i++ )
+            SpielObjekt* ret = new SpielObjekt( o );
+            for( auto i : *ressources )
             {
                 if( i->getId() == o->m2d )
-                    ret->setModel( dynamic_cast<Model2DData *>( i->zReccourceM2()->getThis() ) );
+                    ret->setModel( dynamic_cast<Model2DData*>(i->zReccourceM2()->getThis()) );
             }
             return ret;
         }
@@ -102,9 +102,9 @@ SpielObjekt *Karte::createObjekt( int oNum ) const
     return 0;
 }
 
-Iterator< ObjektStr * > Karte::getObjekte() const
+Iterator< ObjektStr* > Karte::getObjekte() const
 {
-    return objekte->getIterator();
+    return objekte->begin();
 }
 
 int Karte::getMaxTeamAnzahl() const

Asteroids/Spiel.cpp

@@ -60,7 +60,7 @@ Spiel::~Spiel()
     teams->release();
     stat->release();
     spieler->release();
-    for( auto o = objekte->getIterator(); o; o++ )
+    for( auto o : *objekte )
         o->setTeam( 0 );
     objekte->release();
     welt->release();
@@ -81,7 +81,7 @@ int Spiel::getTeamVonSpieler( int sNum )
 {
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp && tmp->getSpielerNummer() == sNum )
             return tmp->zTeam() ? tmp->zTeam()->id : 0;
     }
@@ -89,12 +89,12 @@ int Spiel::getTeamVonSpieler( int sNum )
 }
 
 // nicht constant
-void Spiel::setPSQLK( SSDatenbankV *psqldb )
+void Spiel::setPSQLK( SSDatenbankV* psqldb )
 {
     if( this->psqldb )
         this->psqldb->release();
     this->psqldb = psqldb;
-    stat->setPSQLDB( dynamic_cast<SSDatenbankV *>( psqldb->getThis() ) );
+    stat->setPSQLDB( dynamic_cast<SSDatenbankV*>(psqldb->getThis()) );
 }
 
 void Spiel::setSpielId( int id )
@@ -109,29 +109,29 @@ void Spiel::setKarteId( int karteId )
     stat->setKarteId( karteId );
 }
 
-void Spiel::setTempPfad( char *pfad )
+void Spiel::setTempPfad( char* pfad )
 {
     mapPfad = pfad;
     mapPfad += "/";
 }
 
-void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
+void Spiel::setAccounts( int anzahl, Array< int >* zAccounts )
 {
-    this->zAccounts = dynamic_cast<Array<int> *>( zAccounts->getThis() );
+    this->zAccounts = dynamic_cast<Array<int> *>(zAccounts->getThis());
     spielerAnzahl = anzahl;
 }
 
-void Spiel::setKlients( int anzahl, RCArray< SSKlientV > *zKlients )
+void Spiel::setKlients( int anzahl, RCArray< SSKlientV >* zKlients )
 {
-    this->zKlients = dynamic_cast<RCArray<SSKlientV> *>( zKlients->getThis() );
+    this->zKlients = dynamic_cast<RCArray<SSKlientV> *>(zKlients->getThis());
 }
 
-void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
+void Spiel::setSpielerNummern( int anzahl, Array< int >* spielerNummern )
 {
     if( !sts )
     {
         sts = new SpielerTeamStruktur();
-        KartenLeser *reader = new KartenLeser( karteId, dynamic_cast<SSDatenbankV *>( psqldb->getThis() ), mapPfad );
+        KartenLeser* reader = new KartenLeser( karteId, dynamic_cast<SSDatenbankV*>(psqldb->getThis()), mapPfad );
         reader->ladeSpielerTeamStruktur( sts );
         if( karte )
             karte->release();
@@ -139,12 +139,12 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
         reader->release();
         for( int i = 0; i < sts->teamAnzahl; i++ )
             teams->set( karte->createTeam( i ), i );
-        stat->setTeamNamen( dynamic_cast<RCArray<Text> *>( sts->teamName->getThis() ) );
+        stat->setTeamNamen( dynamic_cast<RCArray<Text> *>(sts->teamName->getThis()) );
         for( auto o = karte->getObjekte(); o; o++ )
         {
-            SpielObjekt *obj = karte->createObjekt( o->id );
+            SpielObjekt* obj = karte->createObjekt( o->id );
             obj->setTeam( teams->get( o->team - 1 ) );
-            welt->addObject( dynamic_cast<SpielObjekt *>( obj->getThis() ) );
+            welt->addObject( dynamic_cast<SpielObjekt*>(obj->getThis()) );
             objekte->add( obj );
         }
         welt->setSize( karte->getSize().x, karte->getSize().y );
@@ -152,7 +152,7 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
     }
     for( int i = 0; i < anzahl; i++ )
     {
-        Spieler *tmp = karte->createSpieler( spielerNummern->get( i ) );
+        Spieler* tmp = karte->createSpieler( spielerNummern->get( i ) );
         if( tmp )
         {
             int team = 0;
@@ -160,7 +160,7 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
             int bis = 0;
             for( int j = 0; j < sts->teamAnzahl; j++ )
             {
-                bis = von + ( sts->teamSize->hat( j ) ? sts->teamSize->get( j ) : 0 );
+                bis = von + (sts->teamSize->hat( j ) ? sts->teamSize->get( j ) : 0);
                 if( spielerNummern->get( i ) >= von && spielerNummern->get( i ) < bis )
                 {
                     team = j;
@@ -171,7 +171,7 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
             tmp->setTeam( teams->get( team ) );
             teams->z( team )->spieler->add( tmp );
         }
-        welt->addObject( dynamic_cast<Spieler *>( tmp->getThis() ) );
+        welt->addObject( dynamic_cast<Spieler*>(tmp->getThis()) );
         spieler->set( tmp, i );
     }
     for( int i = 0; i < anzahl; i++ )
@@ -179,8 +179,8 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
     for( int i = 0; i < anzahl; i++ )
         spieler->z( i )->setKlient( new Klient( zKlients->get( i ) ) );
     stat->setSpieler( spielerAnzahl, spieler );
-    zAccounts = ( Array<int>* )zAccounts->release();
-    zKlients = ( RCArray<SSKlientV>* )zKlients->release();
+    zAccounts = (Array<int>*)zAccounts->release();
+    zKlients = (RCArray<SSKlientV>*)zKlients->release();
     teamAnzahl = 0;
     for( int i = 0; i < sts->teamAnzahl; i++ )
         if( teams->z( i )->spieler->getEintragAnzahl() )
@@ -196,16 +196,16 @@ void Spiel::klientOffline( int accountId )
     }
 }
 
-void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
+void Spiel::klientOnline( int accountId, SSKlientV* zKlient )
 {
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         if( spieler->z( i )->getAccountId() == accountId )
         {
             EnterCriticalSection( &cs );
-            Spieler *s = spieler->z( i );
+            Spieler* s = spieler->z( i );
             s->online( zKlient );
-            Klient *tmp = spieler->z( i )->zKlient();
+            Klient* tmp = spieler->z( i )->zKlient();
             tmp->sendeSpielerNummer( s->getSpielerNummer(), 0 );
             //--------------------------
             LeaveCriticalSection( &cs );
@@ -213,7 +213,7 @@ void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
     }
 }
 
-void Spiel::nachricht( int accountId, int len, char *bytes )
+void Spiel::nachricht( int accountId, int len, char* bytes )
 {
     if( !isRunning || ende )
         return;
@@ -223,7 +223,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         LeaveCriticalSection( &cs );
         return;
     }
-    char *msgBeg = bytes;
+    char* msgBeg = bytes;
     int msgLen = len;
     int msgAccount = accountId;
     bool saveMSG = 1;
@@ -240,12 +240,12 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
     case 7:
         for( int i = 0; i < spielerAnzahl; i++ )
         {
-            Spieler *tmp = spieler->z( i );
+            Spieler* tmp = spieler->z( i );
             if( tmp && tmp->getAccountId() == accountId )
             {
                 if( !tmp->istAmLeben() )
                     break;
-                if( !tmp->setTastataturStatus( (TastaturStatus)( (int)( *bytes ) / 2 ), ( (int)( *bytes ) % 2 ) == 0 ) )
+                if( !tmp->setTastataturStatus( (TastaturStatus)((int)(*bytes) / 2), ((int)(*bytes) % 2) == 0 ) )
                 {
                     saveMSG = 0;
                     break;
@@ -254,9 +254,9 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                 {
                     for( int j = 0; j < spielerAnzahl; j++ )
                     {
-                        Spieler *s = spieler->z( j );
+                        Spieler* s = spieler->z( j );
                         if( s && s->zKlient() )
-                            s->zKlient()->sendeTastaturStatus( tmp->getSpielerNummer(), (TastaturStatus)( (int)( *bytes ) / 2 ), ( (int)( *bytes ) % 2 ) == 0, spielZeit );
+                            s->zKlient()->sendeTastaturStatus( tmp->getSpielerNummer(), (TastaturStatus)((int)(*bytes) / 2), ((int)(*bytes) % 2) == 0, spielZeit );
                     }
                 }
                 break;
@@ -267,12 +267,12 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         if( 1 )
         {
             bytes++;
-            Text *txt = psqldb->getAccountRufName( accountId );
+            Text* txt = psqldb->getAccountRufName( accountId );
             txt->append( ": " );
             txt->append( bytes, len );
             for( int i = 0; i < spielerAnzahl; i++ )
             {
-                Spieler *tmp = spieler->z( i );
+                Spieler* tmp = spieler->z( i );
                 if( tmp && tmp->zKlient() )
                     tmp->zKlient()->sendeChatNachricht( txt->getText(), spielZeit );
             }
@@ -287,7 +287,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         len--;
         for( int i = 0; i < spielerAnzahl; i++ )
         {
-            Spieler *tmp = spieler->z( i );
+            Spieler* tmp = spieler->z( i );
             if( tmp && tmp->getAccountId() == accountId )
             {
                 if( !tmp->istAmLeben() )
@@ -299,7 +299,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                 }
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
-                    Spieler *s = spieler->z( j );
+                    Spieler* s = spieler->z( j );
                     if( s && s->zKlient() )
                         s->zKlient()->sendeSkillNachricht( tmp->getSpielerNummer(), art, spielZeit );
                 }
@@ -315,7 +315,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         len--;
         for( int i = 0; i < spielerAnzahl; i++ )
         {
-            Spieler *tmp = spieler->z( i );
+            Spieler* tmp = spieler->z( i );
             if( tmp && tmp->getAccountId() == accountId )
             {
                 if( !tmp->istAmLeben() )
@@ -323,7 +323,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                 tmp->useSkill( id );
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
-                    Spieler *s = spieler->z( j );
+                    Spieler* s = spieler->z( j );
                     if( s && s->zKlient() )
                         s->zKlient()->sendeUseSkillNachricht( tmp->getSpielerNummer(), id, spielZeit );
                 }
@@ -346,16 +346,16 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         int spielerNum = 0;
         for( int i = 0; i < spielerAnzahl; i++ )
         {
-            Spieler *tmp = spieler->z( i );
+            Spieler* tmp = spieler->z( i );
             if( tmp && tmp->getAccountId() == msgAccount )
             {
                 spielerNum = tmp->getSpielerNummer();
                 break;
             }
         }
-        log->schreibe( (char *)&spielerNum, 4 );
+        log->schreibe( (char*)&spielerNum, 4 );
         short l = (short)msgLen;
-        log->schreibe( (char *)&l, 2 );
+        log->schreibe( (char*)&l, 2 );
         log->schreibe( msgBeg, l );
     }
     LeaveCriticalSection( &cs );
@@ -368,7 +368,7 @@ void Spiel::tick( double zeit )
     // Spieler Updaten
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp )
         {
             if( tmp->doNeedWiederbelebung() )
@@ -376,7 +376,7 @@ void Spiel::tick( double zeit )
                 tmp->wiederbeleben();
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
-                    Spieler *s = spieler->z( j );
+                    Spieler* s = spieler->z( j );
                     if( s )
                         s->zKlient()->sendeWiederbelebung( tmp->getSpielerNummer(), spielZeit );
                 }
@@ -387,14 +387,14 @@ void Spiel::tick( double zeit )
     int anz = shots->getEintragAnzahl();
     for( int i = 0; i < anz; i++ )
     {
-        Laser *tmp = shots->z( i );
+        Laser* tmp = shots->z( i );
         if( tmp )
         {
             if( tmp->getIntensity() <= 0 )
             { // Schuss existiert nicht mehr
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
-                    Spieler *s = spieler->z( j );
+                    Spieler* s = spieler->z( j );
                     if( s )
                         s->zKlient()->sendeTreffer( tmp->getId(), -1, spielZeit, 0, 0 );
                 }
@@ -408,17 +408,17 @@ void Spiel::tick( double zeit )
                 int team = getTeamVonSpieler( tmp->getSpieler() );
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
-                    Spieler *attacked = spieler->z( j );
+                    Spieler* attacked = spieler->z( j );
                     if( attacked && attacked->zTeam() && attacked->zTeam()->id != team && attacked->istTreffer( tmp->getPosition() ) )
                     { // Treffer
-                        Spieler *attacker = 0;
+                        Spieler* attacker = 0;
                         for( int k = 0; k < spielerAnzahl; k++ )
                         {
-                            Spieler *tmpS = spieler->z( k );
+                            Spieler* tmpS = spieler->z( k );
                             if( tmpS && tmpS->getSpielerNummer() == tmp->getSpieler() )
                                 attacker = tmpS;
                         }
-                        double intens = tmp->getIntensity() * ( ( tmp->getSpeed() - attacked->getSpeed() ).getLength() / 200 );
+                        double intens = tmp->getIntensity() * ((tmp->getSpeed() - attacked->getSpeed()).getLength() / 200);
                         bool kill = attacked->nimmSchaden( intens, attacker ? attacker->getLevel() : 1 );
                         if( tmp->getSpeed().getLengthSq() > 0 )
                             attacked->impuls( tmp->getPosition() - tmp->getSpeed(), tmp->getSpeed() * 0.3f );
@@ -429,7 +429,7 @@ void Spiel::tick( double zeit )
                             attacker->addKill( attacked->getLevel() );
                         for( int k = 0; k < spielerAnzahl; k++ )
                         {
-                            Spieler *sp = spieler->z( k );
+                            Spieler* sp = spieler->z( k );
                             if( sp )
                                 sp->zKlient()->sendeTreffer( tmp->getId(), attacked->getSpielerNummer(), spielZeit, erf, skillP );
                             if( kill && sp )
@@ -452,17 +452,17 @@ void Spiel::tick( double zeit )
                 int objektAnzahl = objekte->getEintragAnzahl();
                 for( int j = 0; j < objektAnzahl; j++ )
                 {
-                    SpielObjekt *attacked = objekte->z( j );
-                    if( attacked && ( !attacked->zTeam() || attacked->zTeam()->id != team ) && attacked->doesCollideWithLaser() && attacked->istTreffer( tmp->getPosition() ) )
+                    SpielObjekt* attacked = objekte->z( j );
+                    if( attacked && (!attacked->zTeam() || attacked->zTeam()->id != team) && attacked->doesCollideWithLaser() && attacked->istTreffer( tmp->getPosition() ) )
                     { // Treffer
-                        Spieler *attacker = 0;
+                        Spieler* attacker = 0;
                         for( int k = 0; k < spielerAnzahl; k++ )
                         {
-                            Spieler *tmpS = spieler->z( k );
+                            Spieler* tmpS = spieler->z( k );
                             if( tmpS && tmpS->getSpielerNummer() == tmp->getSpieler() )
                                 attacker = tmpS;
                         }
-                        double intens = tmp->getIntensity() * ( ( tmp->getSpeed() - attacked->getSpeed() ).getLength() / 200 );
+                        double intens = tmp->getIntensity() * ((tmp->getSpeed() - attacked->getSpeed()).getLength() / 200);
                         bool kill = attacked->nimmSchaden( intens, attacker ? attacker->getLevel() : 1 );
                         if( tmp->getSpeed().getLengthSq() > 0 )
                             attacked->impuls( tmp->getPosition() - tmp->getSpeed(), tmp->getSpeed() * 0.3f );
@@ -473,7 +473,7 @@ void Spiel::tick( double zeit )
                             attacker->addKill( attacked->getLevel(), attacked->doesShotAddEp() );
                         for( int k = 0; k < spielerAnzahl; k++ )
                         {
-                            Spieler *sp = spieler->z( k );
+                            Spieler* sp = spieler->z( k );
                             if( sp )
                                 sp->zKlient()->sendeObjektTreffer( tmp->getId(), attacked->getObjektId(), spielZeit, erf, skillP );
                             if( kill && sp )
@@ -496,18 +496,18 @@ void Spiel::tick( double zeit )
                 int aAnz = asteroids->getEintragAnzahl();
                 for( int j = 0; j < aAnz; j++ )
                 {
-                    Asteroid *a = asteroids->z( j );
+                    Asteroid* a = asteroids->z( j );
                     Vertex pos;
                     __int64 seed = randG.getSeed();
-                    double intens = tmp->getIntensity() * ( ( tmp->getSpeed() - a->getSpeed() ).getLength() / 200 );
-                    Asteroid *b = a->istTreffer( tmp, &randG, asteroidId, pos );
+                    double intens = tmp->getIntensity() * ((tmp->getSpeed() - a->getSpeed()).getLength() / 200);
+                    Asteroid* b = a->istTreffer( tmp, &randG, asteroidId, pos );
                     if( b )
                     {
                         float erf = 0;
                         int skillP = 0;
                         for( int k = 0; k < spielerAnzahl; k++ )
                         {
-                            Spieler *s = spieler->z( k );
+                            Spieler* s = spieler->z( k );
                             if( s && s->getSpielerNummer() == tmp->getSpieler() )
                             {
                                 s->addTreffer( (float)intens, 0 );
@@ -517,7 +517,7 @@ void Spiel::tick( double zeit )
                         }
                         for( int k = 0; k < spielerAnzahl; k++ )
                         {
-                            Spieler *s = spieler->z( k );
+                            Spieler* s = spieler->z( k );
                             if( s )
                                 s->zKlient()->sendeAsteroidTreffer( a->getId(), b->getId(), tmp->getId(), pos, seed, spielZeit, erf, skillP );
                         }
@@ -525,17 +525,17 @@ void Spiel::tick( double zeit )
                         shots->remove( i );
                         if( b->getMasse() > intens * 50 )
                         {
-                            asteroids->add( dynamic_cast<Asteroid *>( b->getThis() ) );
+                            asteroids->add( dynamic_cast<Asteroid*>(b->getThis()) );
                             welt->addObject( b );
                         }
                         else
                         {
-                            Pixel *p = new Pixel( b->getPosition(), b->getSpeed(), b->getMasse() / 50, pixelId++ );
-                            welt->addObject( dynamic_cast<Pixel *>( p->getThis() ) );
+                            Pixel* p = new Pixel( b->getPosition(), b->getSpeed(), b->getMasse() / 50, pixelId++ );
+                            welt->addObject( dynamic_cast<Pixel*>(p->getThis()) );
                             pixel->add( p );
                             for( int k = 0; k < spielerAnzahl; k++ )
                             {
-                                Spieler *s = spieler->z( k );
+                                Spieler* s = spieler->z( k );
                                 if( s )
                                     s->zKlient()->sendePixel( b->getId(), p->getId(), spielZeit );
                             }
@@ -543,12 +543,12 @@ void Spiel::tick( double zeit )
                         }
                         if( a->getMasse() < intens * 50 )
                         {
-                            Pixel *p = new Pixel( a->getPosition(), a->getSpeed(), a->getMasse() / 50, pixelId++ );
-                            welt->addObject( dynamic_cast<Pixel *>( p->getThis() ) );
+                            Pixel* p = new Pixel( a->getPosition(), a->getSpeed(), a->getMasse() / 50, pixelId++ );
+                            welt->addObject( dynamic_cast<Pixel*>(p->getThis()) );
                             pixel->add( p );
                             for( int k = 0; k < spielerAnzahl; k++ )
                             {
-                                Spieler *s = spieler->z( k );
+                                Spieler* s = spieler->z( k );
                                 if( s )
                                     s->zKlient()->sendePixel( a->getId(), p->getId(), spielZeit );
                             }
@@ -564,14 +564,14 @@ void Spiel::tick( double zeit )
     // Neue Schüsse hinzufügen
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp )
         {
-            Laser *nL = tmp->getLaser( nextSchussId );
+            Laser* nL = tmp->getLaser( nextSchussId );
             if( nL )
             {
                 nextSchussId++;
-                welt->addObject( dynamic_cast<Laser *>( nL->getThis() ) );
+                welt->addObject( dynamic_cast<Laser*>(nL->getThis()) );
                 shots->add( nL );
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
@@ -592,10 +592,10 @@ void Spiel::tick( double zeit )
             Vertex speed = Vertex( (float)randG.rand() * 100, (float)randG.rand() * 100 );
             float rot = 2 * (float)PI * (float)randG.rand();
             float rotS = (float)randG.rand();
-            int index = (int)( (float)asteroidModels->getEintragAnzahl() * (float)randG.rand() );
-            Asteroid *astr = new Asteroid( asteroidId++, pos, speed, rot, rotS, asteroidModels->get( index ) );
+            int index = (int)((float)asteroidModels->getEintragAnzahl() * (float)randG.rand());
+            Asteroid* astr = new Asteroid( asteroidId++, pos, speed, rot, rotS, asteroidModels->get( index ) );
             asteroids->add( astr );
-            welt->addObject( dynamic_cast<Asteroid *>( astr->getThis() ) );
+            welt->addObject( dynamic_cast<Asteroid*>(astr->getThis()) );
             for( int j = 0; j < spielerAnzahl; j++ )
             {
                 if( spieler->z( j ) && spieler->z( j )->zKlient() )
@@ -607,7 +607,7 @@ void Spiel::tick( double zeit )
     int pixelAnz = pixel->getEintragAnzahl();
     for( int i = 0; i < pixelAnz; i++ )
     {
-        Pixel *p = pixel->z( i );
+        Pixel* p = pixel->z( i );
         if( p->getEp() <= 0 )
         {
             for( int j = 0; j < spielerAnzahl; j++ )
@@ -621,7 +621,7 @@ void Spiel::tick( double zeit )
         }
         else
         {
-            for( auto s = spieler->getIterator(); s; s++ )
+            for( auto s : *spieler )
             {
                 if( s->istTreffer( p->getPosition() ) )
                 {
@@ -643,11 +643,11 @@ void Spiel::tick( double zeit )
 
 void Spiel::run()
 {
-    Text *pfad = psqldb->getSpielPfad( karteId );
+    Text* pfad = psqldb->getSpielPfad( karteId );
     if( pfad )
         pfad->append( "/" );
     pfad->append( "models/asteroids.m2" );
-    M2Datei *aDat = new M2Datei();
+    M2Datei* aDat = new M2Datei();
     aDat->setPfadZ( pfad );
     aDat->leseDaten();
     int anz = aDat->getModelAnzahl();
@@ -666,43 +666,43 @@ void Spiel::run()
     time_t t;
     time( &t );
     srand( (unsigned int)t );
-    log->schreibe( (char *)&spielerAnzahl, 4 );
+    log->schreibe( (char*)&spielerAnzahl, 4 );
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp && tmp->zKlient() )
         {
             tmp->addSkill( new ShieldBoost() );
             tmp->addSkill( new SpeedBoost() );
             tmp->zKlient()->sendeInit( spieler, -1 );
-            log->schreibe( (char *)&i, 4 );
+            log->schreibe( (char*)&i, 4 );
             int sNum = tmp->getSpielerNummer();
-            log->schreibe( (char *)&sNum, 4 );
+            log->schreibe( (char*)&sNum, 4 );
             tmp->zKlient()->sendeSpielerNummer( sNum, -1 );
             int team = tmp->zTeam()->id;
-            log->schreibe( (char *)&team, 4 );
+            log->schreibe( (char*)&team, 4 );
             int farbe = tmp->getSpielerFarbe();
-            log->schreibe( (char *)&farbe, 4 );
+            log->schreibe( (char*)&farbe, 4 );
             farbe = tmp->zTeam()->farbe;
-            log->schreibe( (char *)&farbe, 4 );
-            Text *name = psqldb->getAccountRufName( tmp->getAccountId() );
-            char len = (char)( name ? name->getLength() : 0 );
+            log->schreibe( (char*)&farbe, 4 );
+            Text* name = psqldb->getAccountRufName( tmp->getAccountId() );
+            char len = (char)(name ? name->getLength() : 0);
             log->schreibe( &len, 1 );
             if( len )
                 log->schreibe( name->getText(), len );
             if( name )
                 name->release();
             name = sts->teamName->z( team );
-            len = (char)( name ? name->getLength() : 0 );
+            len = (char)(name ? name->getLength() : 0);
             log->schreibe( &len, 1 );
             if( len )
                 log->schreibe( name->getText(), len );
         }
     }
     __int64 randSeed = randG.getSeed();
-    log->schreibe( (char *)&randSeed, 8 );
+    log->schreibe( (char*)&randSeed, 8 );
     Array< char > spielerStatus;
-    ZeitMesser *zeit = new ZeitMesser();
+    ZeitMesser* zeit = new ZeitMesser();
     zeit->messungStart();
     isRunning = 1;
     ende = 0;
@@ -711,7 +711,7 @@ void Spiel::run()
     spielZeit = -1;
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp && tmp->zKlient() )
             tmp->zKlient()->sendeStart( spielZeit );
     }
@@ -723,7 +723,7 @@ void Spiel::run()
         double z = zeit->getSekunden();
         ausgleich += TICK - z;
         if( ausgleich > 0 )
-            Sleep( (int)( ausgleich * 1000 ) );
+            Sleep( (int)(ausgleich * 1000) );
         rZeit += z;
         while( sZ + TICK < rZeit && !ende )
         {
@@ -753,7 +753,7 @@ void Spiel::run()
                 spieler->z( i )->zKlient()->sendeSpielEnde( 1, 0 );
             }
         }
-        if( spieler->z( i ) && ( !spieler->z( i )->zKlient() || !spieler->z( i )->istOnline() ) )
+        if( spieler->z( i ) && (!spieler->z( i )->zKlient() || !spieler->z( i )->istOnline()) )
             spielerStatus.set( 3, i );
     }
     if( teamAnzahl == 1 )
@@ -762,7 +762,7 @@ void Spiel::run()
         psqldb->setSpielStatusBeendet( spielId, 5 );
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp )
         {
             psqldb->setSpielSpielerStatus( spielId, tmp->getAccountId(), tmp->getPunkte(), spielerStatus.get( i ) );
@@ -771,12 +771,12 @@ void Spiel::run()
         }
     }
     log->close();
-    log = (Datei *)log->release();
+    log = (Datei*)log->release();
     isRunning = 0;
 }
 
 // constant
-StatistikV *Spiel::getStatistik() const
+StatistikV* Spiel::getStatistik() const
 {
-    return dynamic_cast<StatistikV *>( stat->getThis() );
+    return dynamic_cast<StatistikV*>(stat->getThis());
 }

Asteroids/Spieler.cpp

@@ -8,7 +8,7 @@
 
 // Inhalt der Spieler Klasse aus Spieler.h
 // Konstruktor
-Spieler::Spieler( SpielerStr *zStr )
+Spieler::Spieler( SpielerStr* zStr )
     : Model2DObject()
 {
     activeSkills = new RCArray< ActiveSkill >();
@@ -74,148 +74,148 @@ double Spieler::calculateBeschleunigung()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getBeschleunigungFactor();
         bonus += s->getBeschleunigungBonus();
     }
-    return ( beschleunigung + team->beschleunigung ) * factor + bonus;
+    return (beschleunigung + team->beschleunigung) * factor + bonus;
 }
 
 double Spieler::calculateReparatur()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getReparaturFactor();
         bonus += s->getReparaturBonus();
     }
-    return ( reparatur + team->reparatur ) * factor + bonus;
+    return (reparatur + team->reparatur) * factor + bonus;
 }
 
 double Spieler::calculateLaserIntensity()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getLaserIntensityFactor();
         bonus += s->getLaserIntensityBonus();
     }
-    return ( laserIntensity + team->laserIntensity ) * factor + bonus;
+    return (laserIntensity + team->laserIntensity) * factor + bonus;
 }
 
 double Spieler::calculateLaserEffizienz()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getLaserEffizienzFactor();
         bonus += s->getLaserEffizienzBonus();
     }
-    return ( laserEffizienz + team->laserEffizienz ) * factor + bonus;
+    return (laserEffizienz + team->laserEffizienz) * factor + bonus;
 }
 
 double Spieler::calculateAkkuLeistung()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getAkkuLeistungFactor();
         bonus += s->getAkkuLeistungBonus();
     }
-    return ( akkuLeistung + team->akkuLeistung ) * factor + bonus;
+    return (akkuLeistung + team->akkuLeistung) * factor + bonus;
 }
 
 double Spieler::calculateMaxEnergie()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getMaxEnergieFactor();
         bonus += s->getMaxEnergieBonus();
     }
-    return ( maxEnergie + team->maxEnergie ) * factor + bonus;
+    return (maxEnergie + team->maxEnergie) * factor + bonus;
 }
 
 double Spieler::calculateMaxStability()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getMaxStabilityFactor();
         bonus += s->getMaxStabilityBonus();
     }
-    return ( maxStability + team->maxStability ) * factor + bonus;
+    return (maxStability + team->maxStability) * factor + bonus;
 }
 
 double Spieler::calculateLaserTempo()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getLaserTempoFactor();
         bonus += s->getLaserTempoBonus();
     }
-    return ( laserTempo + team->laserTempo ) * factor + bonus;
+    return (laserTempo + team->laserTempo) * factor + bonus;
 }
 
 double Spieler::calculateWendigkeit()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getWendigkeitFactor();
         bonus += s->getWendigkeitBonus();
     }
-    return ( wendigkeit + team->wendigkeit ) * factor + bonus;
+    return (wendigkeit + team->wendigkeit) * factor + bonus;
 }
 
 double Spieler::calculateAntriebEffizienz()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getAntriebEffizienzFactor();
         bonus += s->getAntriebEffizienzBonus();
     }
-    return ( antriebEffizienz + team->antriebEffizienz ) * factor + bonus;
+    return (antriebEffizienz + team->antriebEffizienz) * factor + bonus;
 }
 
 double Spieler::calculateEnergieSchild()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getEnergieSchildFactor();
         bonus += s->getEnergieSchildBonus();
     }
-    return ( energieSchild + team->energieSchild ) * factor + bonus;
+    return (energieSchild + team->energieSchild) * factor + bonus;
 }
 
 double Spieler::calculateEnergieSchildEffizienz()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getEnergieSchildEffizienzFactor();
         bonus += s->getEnergieSchildEffizienzBonus();
     }
-    return ( energieSchildEffizienz + team->energieSchildEffizienz ) * factor + bonus;
+    return (energieSchildEffizienz + team->energieSchildEffizienz) * factor + bonus;
 }
 
 // nicht constant
-void Spieler::addSkill( ActiveSkill *skill )
+void Spieler::addSkill( ActiveSkill* skill )
 {
     activeSkills->add( skill );
 }
@@ -231,62 +231,62 @@ void Spieler::offline()
     klient->offline();
 }
 
-void Spieler::online( SSKlientV *zKlient )
+void Spieler::online( SSKlientV* zKlient )
 {
     klient->online( zKlient );
 }
 
-void Spieler::setModelData( Model2DData *data )
+void Spieler::setModelData( Model2DData* data )
 {
-    for( auto i = data->polygons->getIterator(); i; i++ )
+    for( const Polygon2D& i : *data->polygons )
     {
-        if( i._.name->istGleich( "engine_l" ) )
+        if( i.name->istGleich( "engine_l" ) )
         {
-            stL = *i._.schwerpunkt;
+            stL = *i.schwerpunkt;
             Vertex l, r;
             for( int j = 0; j < 4; j++ )
             {
-                if( i._.tKordinaten->get( j ).y == 1.f )
+                if( i.tKordinaten->get( j ).y == 1.f )
                 {
-                    if( i._.tKordinaten->get( j ).x == 0.f )
-                        l = i._.vertex->get( j );
-                    if( i._.tKordinaten->get( j ).x == 1.f )
-                        r = i._.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 0.f )
+                        l = i.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 1.f )
+                        r = i.vertex->get( j );
                 }
             }
-            kL = ( ( l + ( r - l ) * 0.5 ) - stL );
+            kL = ((l + (r - l) * 0.5) - stL);
         }
-        if( i._.name->istGleich( "engine_r" ) )
+        if( i.name->istGleich( "engine_r" ) )
         {
-            stR = *i._.schwerpunkt;
+            stR = *i.schwerpunkt;
             Vertex l, r;
             for( int j = 0; j < 4; j++ )
             {
-                if( i._.tKordinaten->get( j ).y == 1.f )
+                if( i.tKordinaten->get( j ).y == 1.f )
                 {
-                    if( i._.tKordinaten->get( j ).x == 0.f )
-                        l = i._.vertex->get( j );
-                    if( i._.tKordinaten->get( j ).x == 1.f )
-                        r = i._.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 0.f )
+                        l = i.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 1.f )
+                        r = i.vertex->get( j );
                 }
             }
-            kR = ( ( l + ( r - l ) * 0.5 ) - stR );
+            kR = ((l + (r - l) * 0.5) - stR);
         }
-        if( i._.name->istGleich( "engine_m" ) )
+        if( i.name->istGleich( "engine_m" ) )
         {
-            stM = *i._.schwerpunkt;
+            stM = *i.schwerpunkt;
             Vertex l, r;
             for( int j = 0; j < 4; j++ )
             {
-                if( i._.tKordinaten->get( j ).y == 1.f )
+                if( i.tKordinaten->get( j ).y == 1.f )
                 {
-                    if( i._.tKordinaten->get( j ).x == 0.f )
-                        l = i._.vertex->get( j );
-                    if( i._.tKordinaten->get( j ).x == 1.f )
-                        r = i._.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 0.f )
+                        l = i.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 1.f )
+                        r = i.vertex->get( j );
                 }
             }
-            kM = ( ( l + ( r - l ) * 0.5 ) - stM );
+            kM = ((l + (r - l) * 0.5) - stM);
         }
     }
     kL.normalize();
@@ -300,7 +300,7 @@ void Spieler::setAccountId( int id )
     accountId = id;
 }
 
-void Spieler::setTeam( Team *team )
+void Spieler::setTeam( Team* team )
 {
     if( this->team )
         this->team->release();
@@ -312,7 +312,7 @@ void Spieler::setSpielerFarbe( int farbe )
     this->farbe = farbe;
 }
 
-void Spieler::setKlient( Klient *klient )
+void Spieler::setKlient( Klient* klient )
 {
     if( this->klient )
         this->klient->release();
@@ -327,7 +327,7 @@ bool Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
     return 1;
 }
 
-bool Spieler::tick( const WeltInfo &info, double zeit )
+bool Spieler::tick( const WeltInfo& info, double zeit )
 {
     wInfo = info;
     if( !team )
@@ -342,7 +342,7 @@ bool Spieler::tick( const WeltInfo &info, double zeit )
     }
     if( amLeben )
     {
-        for( auto s = activeSkills->getIterator(); s; s++ )
+        for( auto s : *activeSkills )
             s->tick( zeit );
         schussAbk -= zeit;
         energieAbk -= zeit;
@@ -355,36 +355,36 @@ bool Spieler::tick( const WeltInfo &info, double zeit )
             repAbk = 0;
         if( tastatur[ T_GAS ] )
         {
-            double treibstoff = 0.5 * ( calculateBeschleunigung() / 15 )
-                * zeit * ( 100 / calculateAntriebEffizienz() );
+            double treibstoff = 0.5 * (calculateBeschleunigung() / 15)
+                * zeit * (100 / calculateAntriebEffizienz());
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
-                factor = (float)( energie / treibstoff );
+                factor = (float)(energie / treibstoff);
             if( factor > 0 )
                 impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)zeit * (float)calculateBeschleunigung() * factor );
             energie -= treibstoff * factor;
         }
         if( tastatur[ T_ROT_R ] )
         {
-            double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
-                * zeit * ( 100 / calculateAntriebEffizienz() );
+            double treibstoff = 0.25 * (calculateWendigkeit() / 15)
+                * zeit * (100 / calculateAntriebEffizienz());
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
-                factor = (float)( energie / treibstoff );
+                factor = (float)(energie / treibstoff);
             if( factor > 0 )
                 impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)zeit * (float)calculateWendigkeit() * factor );
             energie -= treibstoff * factor;
         }
         if( tastatur[ T_ROT_L ] )
         {
-            double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
-                * zeit * ( 100 / calculateAntriebEffizienz() );
+            double treibstoff = 0.25 * (calculateWendigkeit() / 15)
+                * zeit * (100 / calculateAntriebEffizienz());
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
-                factor = (float)( energie / treibstoff );
+                factor = (float)(energie / treibstoff);
             if( factor > 0 )
                 impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)zeit * (float)calculateWendigkeit() * factor );
             energie -= treibstoff * factor;
@@ -484,13 +484,13 @@ bool Spieler::setSkill( int art )
     return 1;
 }
 
-Laser *Spieler::getLaser( int sId )
+Laser* Spieler::getLaser( int sId )
 {
     if( !amLeben || !tastatur[ T_FEUER ] || schussAbk || !team )
         return 0;
-    double kosten = ( calculateLaserIntensity() / 2 +
-                      calculateLaserTempo() / 9 ) *
-        ( 1 / ( calculateLaserEffizienz() / 25 ) );
+    double kosten = (calculateLaserIntensity() / 2 +
+                      calculateLaserTempo() / 9) *
+        (1 / (calculateLaserEffizienz() / 25));
     if( kosten < 1 )
         kosten = 1;
     if( kosten > energie )
@@ -499,20 +499,20 @@ Laser *Spieler::getLaser( int sId )
     schussAbk = 1;
     energieAbk = 1.5;
     shots++;
-    Vertex sSpeed = ( Vertex( lowPrecisionCos( rotation ), lowPrecisionSin( rotation ) ) * (float)calculateLaserTempo() );
+    Vertex sSpeed = (Vertex( lowPrecisionCos( rotation ), lowPrecisionSin( rotation ) ) * (float)calculateLaserTempo());
     sSpeed += speed;
     return new Laser( sId, getPosition(), sSpeed, sNum, calculateLaserIntensity() );
 }
 
-bool Spieler::nimmSchaden( double &intensity, int sLevel )
+bool Spieler::nimmSchaden( double& intensity, int sLevel )
 {
     double originalIntens = intensity;
     double schieldVal = intensity - intensity / calculateEnergieSchild();
-    double schieldEVal = schieldVal / ( calculateEnergieSchildEffizienz() / 100 );
+    double schieldEVal = schieldVal / (calculateEnergieSchildEffizienz() / 100);
     if( schieldEVal > energie )
     {
         schieldEVal = energie;
-        schieldVal = schieldEVal * ( calculateEnergieSchildEffizienz() / 100 );
+        schieldVal = schieldEVal * (calculateEnergieSchildEffizienz() / 100);
     }
     intensity -= schieldVal;
     energie -= schieldEVal;
@@ -533,7 +533,7 @@ bool Spieler::nimmSchaden( double &intensity, int sLevel )
     else
     {
         float levelFactor = (float)sLevel / (float)level;
-        addEp( ( (float)originalIntens / 20 ) * levelFactor );
+        addEp( ((float)originalIntens / 20) * levelFactor );
     }
     return stability == 0;
 }
@@ -561,12 +561,12 @@ void Spieler::addTreffer( float intensity, int sLevel, bool erf )
     treffer++;
     float levelFactor = (float)sLevel / (float)level;
     if( erf )
-        addEp( ( intensity / 10 ) * levelFactor );
+        addEp( (intensity / 10) * levelFactor );
 }
 
 void Spieler::wiederbeleben()
 {
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
         s->reset();
     needWiederbelebung = 0;
     setPosition( startPos );
@@ -608,7 +608,7 @@ bool Spieler::istOnline() const
     return klient ? klient->istOnline() : 0;
 }
 
-Klient *Spieler::zKlient() const
+Klient* Spieler::zKlient() const
 {
     return klient;
 }
@@ -694,7 +694,7 @@ int Spieler::getSpielerNummer() const
     return sNum;
 }
 
-Team *Spieler::zTeam() const
+Team* Spieler::zTeam() const
 {
     return team;
 }

Asteroids/Statistik.cpp

@@ -32,7 +32,7 @@ Statistik::~Statistik()
 {
     if( db )
         db->release();
-    for( auto s = spieler->getIterator(); s; s++ )
+    for( auto s : *spieler )
         s->setTeam( 0 );
     spieler->release();
     sOnline->release();
@@ -48,7 +48,7 @@ void Statistik::sendeStatistik( int index )
 { // Sendet Statistik an Spieler index
     if( !sOnline->hat( index ) || !sOnline->get( index ) )
         return;
-    Klient *zk = spieler->z( index )->zKlient();
+    Klient* zk = spieler->z( index )->zKlient();
     if( !zk )
         return;
     int anz = gss->getEintragAnzahl();
@@ -76,14 +76,14 @@ void Statistik::setKarteId( int id )
     karteId = id;
 }
 
-void Statistik::setPSQLDB( SSDatenbankV *db )
+void Statistik::setPSQLDB( SSDatenbankV* db )
 {
     if( this->db )
         this->db->release();
     this->db = db;
 }
 
-void Statistik::setTeamNamen( RCArray< Text > *namen )
+void Statistik::setTeamNamen( RCArray< Text >* namen )
 {
     if( teamNamen )
         teamNamen->release();
@@ -95,7 +95,7 @@ void Statistik::spielEnde( int team )
     gewinnerTeam = team;
 }
 
-void Statistik::setSpieler( int anzahl, RCArray< Spieler > *zSpieler )
+void Statistik::setSpieler( int anzahl, RCArray< Spieler >* zSpieler )
 {
     spielerAnzahl = anzahl;
     for( int i = 0; i < anzahl; i++ )
@@ -120,7 +120,7 @@ void Statistik::klientOffline( int accountId )
     }
 }
 
-void Statistik::statistikAnfrage( int accountId, short len, char *bytes )
+void Statistik::statistikAnfrage( int accountId, short len, char* bytes )
 {
     len--;
     switch( *bytes )
@@ -142,7 +142,7 @@ void Statistik::statistikAnfrage( int accountId, short len, char *bytes )
         break;
     case 1: // Chat Nachricht
         bytes++;
-        char *txt = new char[ len + 1 ];
+        char* txt = new char[ len + 1 ];
         txt[ len ] = 0;
         for( int i = 0; i < len; i++ )
             txt[ i ] = bytes[ i ];
@@ -166,13 +166,13 @@ void Statistik::run()
     {
         if( spieler->z( i ) )
         {
-            Spieler *tmp = spieler->z( i );
-            InitDatei *d = new InitDatei();
+            Spieler* tmp = spieler->z( i );
+            InitDatei* d = new InitDatei();
             Text w;
             w = tmp->getSpielerNummer();
             if( w.getLength() )
                 d->addWert( "SpielerNummer", w.getText() );
-            Text *sn = db->getAccountRufName( tmp->getAccountId() );
+            Text* sn = db->getAccountRufName( tmp->getAccountId() );
             if( sn && sn->getLength() )
                 d->addWert( "SpielerName", sn->getText() );
             if( sn )
@@ -214,7 +214,7 @@ void Statistik::run()
             w = tmp->getZeitTod();
             if( w.getLength() )
                 d->addWert( "ZeitTod", w.getText() );
-            SpielerStatistik *gss = new SpielerStatistik();
+            SpielerStatistik* gss = new SpielerStatistik();
             gss->initValues( d );
             this->gss->add( gss );
         }
@@ -222,7 +222,7 @@ void Statistik::run()
     // Gesamt Team
     for( int i = 0; i < spielerAnzahl; i++ )
     {
-        Spieler *tmp = spieler->z( i );
+        Spieler* tmp = spieler->z( i );
         if( tmp )
         {
             int anz = gts->getEintragAnzahl();
@@ -237,7 +237,7 @@ void Statistik::run()
             }
             if( gefunden )
                 continue;
-            InitDatei *d = new InitDatei();
+            InitDatei* d = new InitDatei();
             Text w;
             w = tmp->zTeam()->id;
             if( w.getLength() )
@@ -256,7 +256,7 @@ void Statistik::run()
             int tode = 0;
             for( int j = 0; j < spielerAnzahl; j++ )
             {
-                Spieler *s = spieler->z( j );
+                Spieler* s = spieler->z( j );
                 if( s && s->zTeam()->id == tmp->zTeam()->id )
                 {
                     schadenBekommen += s->getSchadenBekommen();
@@ -293,10 +293,10 @@ void Statistik::run()
             w = tode;
             if( w.getLength() )
                 d->addWert( "Tode", w.getText() );
-            w = (int)( gewinnerTeam == tmp->zTeam()->id );
+            w = (int)(gewinnerTeam == tmp->zTeam()->id);
             if( w.getLength() )
                 d->addWert( "Gewonnen", w.getText() );
-            TeamStatistik *gts = new TeamStatistik();
+            TeamStatistik* gts = new TeamStatistik();
             gts->initValues( d );
             this->gts->add( gts );
         }
@@ -309,7 +309,7 @@ void Statistik::run()
             sendeStatistik( i );
     }
     // Statistik speichern
-    Text *pfad = new Text( "../spiel log/" );
+    Text* pfad = new Text( "../spiel log/" );
     pfad->append( spielId );
     pfad->append( "/fertig" );
     DateiPfadErstellen( pfad );

Asteroids/Team.cpp

@@ -2,7 +2,7 @@
 
 // Inhalt der Team Klasse aus Team.h
 // Konstruktor
-Team::Team( int f, char *n, TeamStr *zStr )
+Team::Team( int f, char* n, TeamStr* zStr )
     : ReferenceCounter()
 {
     id = zStr->id;
@@ -54,7 +54,7 @@ void Team::reset()
 double Team::getMaxEnergieBonus() const
 {
     double ret = maxEnergieS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamMaxEnergieBonus();
     return ret;
 }
@@ -62,7 +62,7 @@ double Team::getMaxEnergieBonus() const
 double Team::getMaxStabilityBonus() const
 {
     double ret = maxStabilityS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamMaxStabilityBonus();
     return ret;
 }
@@ -70,7 +70,7 @@ double Team::getMaxStabilityBonus() const
 double Team::getReperaturBonus() const
 {
     double ret = reparaturS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamReparaturBonus();
     return ret;
 }
@@ -78,7 +78,7 @@ double Team::getReperaturBonus() const
 double Team::getLaserIntensityBonus() const
 {
     double ret = laserIntensityS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamLaserIntensityBonus();
     return ret;
 }
@@ -86,7 +86,7 @@ double Team::getLaserIntensityBonus() const
 double Team::getLaserEffizienzBonus() const
 {
     double ret = laserEffizienzS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamLaserEffizienzBonus();
     return ret;
 }
@@ -94,7 +94,7 @@ double Team::getLaserEffizienzBonus() const
 double Team::getAkkuLeistungBonus() const
 {
     double ret = akkuLeistungS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamAkkuLeistungBonus();
     return ret;
 }
@@ -102,7 +102,7 @@ double Team::getAkkuLeistungBonus() const
 double Team::getLaserTempoBonus() const
 {
     double ret = laserTempoS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamLaserTempoBonus();
     return ret;
 }
@@ -110,7 +110,7 @@ double Team::getLaserTempoBonus() const
 double Team::getBeschleunigungBonus() const
 {
     double ret = beschleunigungS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamBeschleunigungBonus();
     return ret;
 }
@@ -118,7 +118,7 @@ double Team::getBeschleunigungBonus() const
 double Team::getWendigkeitBonus() const
 {
     double ret = wendigkeitS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamWendigkeitBonus();
     return ret;
 }
@@ -126,7 +126,7 @@ double Team::getWendigkeitBonus() const
 double Team::getAntriebEffizienzBonus() const
 {
     double ret = antriebEffizienzS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamAntriebEffizienzBonus();
     return ret;
 }
@@ -134,7 +134,7 @@ double Team::getAntriebEffizienzBonus() const
 double Team::getEnergieSchildBonus() const
 {
     double ret = energieSchildS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamEnergieSchildBonus();
     return ret;
 }
@@ -142,7 +142,7 @@ double Team::getEnergieSchildBonus() const
 double Team::getEnergieSchildEffizienzBonus() const
 {
     double ret = energieSchildEffizienzS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamEnergieSchildEffizienzBonus();
     return ret;
 }