change array iteration

StickmanWorldOnline/Bestenliste.cpp

@@ -13,26 +13,26 @@ void Bestenliste::setSichtbar( bool sichtbar )
     this->sichtbar = sichtbar;
 }
 
-void Bestenliste::addSpalte( const char *name )
+void Bestenliste::addSpalte( const char* name )
 {
     spalten.add( new Text( name ) );
 }
 
-void Bestenliste::addZeile( const char *name )
+void Bestenliste::addZeile( const char* name )
 {
     zeilen.add( new Text( 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->istGleich( spalte ) )
             break;
     }
     int zeileI = 0;
-    for( auto z = zeilen.getIterator(); z; z++, zeileI++ )
+    for( auto z = zeilen.begin(); z; z++, zeileI++ )
     {
         if( z->istGleich( zeile ) )
             break;
@@ -42,16 +42,16 @@ void Bestenliste::setWert( const char *spalte, const char *zeile, const char *we
     werte.z( zeileI )->set( new Text( 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->istGleich( spalte ) )
             break;
     }
     int zeileI = 0;
-    for( auto z = zeilen.getIterator(); z; z++, spalteI++ )
+    for( auto z = zeilen.begin(); z; z++, spalteI++ )
     {
         if( z->istGleich( zeile ) )
             break;

StickmanWorldOnline/Editor.cpp

@@ -13,7 +13,7 @@ Editor::~Editor()
 {}
 
 // nicht constant
-void Editor::setPfad( char *pfad )
+void Editor::setPfad( char* pfad )
 {
     this->pfad = pfad;
     this->pfad += "/editor";
@@ -24,7 +24,7 @@ void Editor::open()
 
 }
 
-bool Editor::nachricht( SKlient *k )
+bool Editor::nachricht( SKlient* k )
 {
     err = "";
     char n = 0;
@@ -66,10 +66,10 @@ bool Editor::nachricht( SKlient *k )
             k->sendeEncrypted( "\1", 1 );
             int width;
             int height;
-            d.lese( (char *)&width, 4 );
-            d.lese( (char *)&height, 4 );
-            k->sendeEncrypted( (char *)&width, 4 );
-            k->sendeEncrypted( (char *)&height, 4 );
+            d.lese( (char*)&width, 4 );
+            d.lese( (char*)&height, 4 );
+            k->sendeEncrypted( (char*)&width, 4 );
+            k->sendeEncrypted( (char*)&height, 4 );
             d.close();
         }
         else
@@ -86,12 +86,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;
@@ -103,12 +103,12 @@ bool Editor::nachricht( SKlient *k )
                 int id = *files->z( i );
                 int maxWbZeit;
                 int punkte;
-                team.lese( (char *)&maxWbZeit, 4 );
-                team.lese( (char *)&punkte, 4 );
+                team.lese( (char*)&maxWbZeit, 4 );
+                team.lese( (char*)&punkte, 4 );
                 team.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&maxWbZeit, 4 );
-                k->sendeEncrypted( (char *)&punkte, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&maxWbZeit, 4 );
+                k->sendeEncrypted( (char*)&punkte, 4 );
             }
         }
         else
@@ -125,12 +125,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;
@@ -142,12 +142,12 @@ bool Editor::nachricht( SKlient *k )
                 int id = *files->z( i );
                 int spawnX;
                 int spawnY;
-                player.lese( (char *)&spawnX, 4 );
-                player.lese( (char *)&spawnY, 4 );
+                player.lese( (char*)&spawnX, 4 );
+                player.lese( (char*)&spawnY, 4 );
                 player.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&spawnX, 4 );
-                k->sendeEncrypted( (char *)&spawnY, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&spawnX, 4 );
+                k->sendeEncrypted( (char*)&spawnY, 4 );
             }
         }
         else
@@ -164,12 +164,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/bariere";
         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;
@@ -187,24 +187,24 @@ bool Editor::nachricht( SKlient *k )
                 int verschiebungWeite;
                 int autoSchaltungMaxTime;
                 int team;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&breite, 4 );
-                object.lese( (char *)&height, 4 );
-                object.lese( (char *)&style, 4 );
-                object.lese( (char *)&verschiebungWeite, 4 );
-                object.lese( (char *)&autoSchaltungMaxTime, 4 );
-                object.lese( (char *)&team, 4 );
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&breite, 4 );
+                object.lese( (char*)&height, 4 );
+                object.lese( (char*)&style, 4 );
+                object.lese( (char*)&verschiebungWeite, 4 );
+                object.lese( (char*)&autoSchaltungMaxTime, 4 );
+                object.lese( (char*)&team, 4 );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&breite, 4 );
-                k->sendeEncrypted( (char *)&height, 4 );
-                k->sendeEncrypted( (char *)&style, 4 );
-                k->sendeEncrypted( (char *)&verschiebungWeite, 4 );
-                k->sendeEncrypted( (char *)&autoSchaltungMaxTime, 4 );
-                k->sendeEncrypted( (char *)&team, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&breite, 4 );
+                k->sendeEncrypted( (char*)&height, 4 );
+                k->sendeEncrypted( (char*)&style, 4 );
+                k->sendeEncrypted( (char*)&verschiebungWeite, 4 );
+                k->sendeEncrypted( (char*)&autoSchaltungMaxTime, 4 );
+                k->sendeEncrypted( (char*)&team, 4 );
             }
         }
         else
@@ -221,12 +221,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/base";
         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;
@@ -246,28 +246,28 @@ bool Editor::nachricht( SKlient *k )
                 int timerX;
                 int timerY;
                 int timerFarbe;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&breite, 4 );
-                object.lese( (char *)&height, 4 );
-                object.lese( (char *)&maxTime, 4 );
-                object.lese( (char *)&team, 4 );
-                object.lese( (char *)&showTimer, 1 );
-                object.lese( (char *)&timerX, 4 );
-                object.lese( (char *)&timerY, 4 );
-                object.lese( (char *)&timerFarbe, 4 );
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&breite, 4 );
+                object.lese( (char*)&height, 4 );
+                object.lese( (char*)&maxTime, 4 );
+                object.lese( (char*)&team, 4 );
+                object.lese( (char*)&showTimer, 1 );
+                object.lese( (char*)&timerX, 4 );
+                object.lese( (char*)&timerY, 4 );
+                object.lese( (char*)&timerFarbe, 4 );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&breite, 4 );
-                k->sendeEncrypted( (char *)&height, 4 );
-                k->sendeEncrypted( (char *)&maxTime, 4 );
-                k->sendeEncrypted( (char *)&team, 4 );
-                k->sendeEncrypted( (char *)&showTimer, 1 );
-                k->sendeEncrypted( (char *)&timerX, 4 );
-                k->sendeEncrypted( (char *)&timerY, 4 );
-                k->sendeEncrypted( (char *)&timerFarbe, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&breite, 4 );
+                k->sendeEncrypted( (char*)&height, 4 );
+                k->sendeEncrypted( (char*)&maxTime, 4 );
+                k->sendeEncrypted( (char*)&team, 4 );
+                k->sendeEncrypted( (char*)&showTimer, 1 );
+                k->sendeEncrypted( (char*)&timerX, 4 );
+                k->sendeEncrypted( (char*)&timerY, 4 );
+                k->sendeEncrypted( (char*)&timerFarbe, 4 );
             }
         }
         else
@@ -284,12 +284,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/drop";
         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;
@@ -307,28 +307,28 @@ bool Editor::nachricht( SKlient *k )
                 int numDrops;
                 float wahrscheinlichkeit[ ITEMANZAHL ];
                 unsigned char len;
-                object.lese( (char *)&minX, 4 );
-                object.lese( (char *)&minY, 4 );
-                object.lese( (char *)&maxX, 4 );
-                object.lese( (char *)&maxY, 4 );
-                object.lese( (char *)&maxTime, 4 );
-                object.lese( (char *)&numDrops, 4 );
+                object.lese( (char*)&minX, 4 );
+                object.lese( (char*)&minY, 4 );
+                object.lese( (char*)&maxX, 4 );
+                object.lese( (char*)&maxY, 4 );
+                object.lese( (char*)&maxTime, 4 );
+                object.lese( (char*)&numDrops, 4 );
                 for( int j = 0; j < ITEMANZAHL; j++ )
-                    object.lese( (char *)&wahrscheinlichkeit[ j ], 4 );
-                object.lese( (char *)&len, 1 );
-                char *name = new char[ len ];
+                    object.lese( (char*)&wahrscheinlichkeit[ j ], 4 );
+                object.lese( (char*)&len, 1 );
+                char* name = new char[ len ];
                 object.lese( name, len );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&minX, 4 );
-                k->sendeEncrypted( (char *)&minY, 4 );
-                k->sendeEncrypted( (char *)&maxX, 4 );
-                k->sendeEncrypted( (char *)&maxY, 4 );
-                k->sendeEncrypted( (char *)&maxTime, 4 );
-                k->sendeEncrypted( (char *)&numDrops, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&minX, 4 );
+                k->sendeEncrypted( (char*)&minY, 4 );
+                k->sendeEncrypted( (char*)&maxX, 4 );
+                k->sendeEncrypted( (char*)&maxY, 4 );
+                k->sendeEncrypted( (char*)&maxTime, 4 );
+                k->sendeEncrypted( (char*)&numDrops, 4 );
                 for( int j = 0; j < ITEMANZAHL; j++ )
-                    k->sendeEncrypted( (char *)&wahrscheinlichkeit[ j ], 4 );
-                k->sendeEncrypted( (char *)&len, 1 );
+                    k->sendeEncrypted( (char*)&wahrscheinlichkeit[ j ], 4 );
+                k->sendeEncrypted( (char*)&len, 1 );
                 k->sendeEncrypted( name, len );
                 delete[] name;
             }
@@ -347,12 +347,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/schalter";
         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;
@@ -367,18 +367,18 @@ bool Editor::nachricht( SKlient *k )
                 int breite;
                 int height;
                 bool aktive;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&breite, 4 );
-                object.lese( (char *)&height, 4 );
-                object.lese( (char *)&aktive, 1 );
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&breite, 4 );
+                object.lese( (char*)&height, 4 );
+                object.lese( (char*)&aktive, 1 );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&breite, 4 );
-                k->sendeEncrypted( (char *)&height, 4 );
-                k->sendeEncrypted( (char *)&aktive, 1 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&breite, 4 );
+                k->sendeEncrypted( (char*)&height, 4 );
+                k->sendeEncrypted( (char*)&aktive, 1 );
             }
         }
         else
@@ -395,12 +395,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/schiene";
         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;
@@ -414,16 +414,16 @@ bool Editor::nachricht( SKlient *k )
                 int y;
                 int breite;
                 int height;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&breite, 4 );
-                object.lese( (char *)&height, 4 );
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&breite, 4 );
+                object.lese( (char*)&height, 4 );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&breite, 4 );
-                k->sendeEncrypted( (char *)&height, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&breite, 4 );
+                k->sendeEncrypted( (char*)&height, 4 );
             }
         }
         else
@@ -440,12 +440,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/timer";
         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;
@@ -463,26 +463,26 @@ bool Editor::nachricht( SKlient *k )
                 bool runns;
                 int farbe;
                 unsigned char len;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&maxZeit, 4 );
-                object.lese( (char *)&sichtbar, 1 );
-                object.lese( (char *)&autoWiederhohlung, 1 );
-                object.lese( (char *)&runns, 1 );
-                object.lese( (char *)&farbe, 4 );
-                object.lese( (char *)&len, 1 );
-                char *name = new char[ len ];
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&maxZeit, 4 );
+                object.lese( (char*)&sichtbar, 1 );
+                object.lese( (char*)&autoWiederhohlung, 1 );
+                object.lese( (char*)&runns, 1 );
+                object.lese( (char*)&farbe, 4 );
+                object.lese( (char*)&len, 1 );
+                char* name = new char[ len ];
                 object.lese( name, len );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&maxZeit, 4 );
-                k->sendeEncrypted( (char *)&sichtbar, 1 );
-                k->sendeEncrypted( (char *)&autoWiederhohlung, 1 );
-                k->sendeEncrypted( (char *)&runns, 1 );
-                k->sendeEncrypted( (char *)&farbe, 4 );
-                k->sendeEncrypted( (char *)&len, 1 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&maxZeit, 4 );
+                k->sendeEncrypted( (char*)&sichtbar, 1 );
+                k->sendeEncrypted( (char*)&autoWiederhohlung, 1 );
+                k->sendeEncrypted( (char*)&runns, 1 );
+                k->sendeEncrypted( (char*)&farbe, 4 );
+                k->sendeEncrypted( (char*)&len, 1 );
                 k->sendeEncrypted( name, len );
                 delete[]name;
             }
@@ -501,12 +501,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/tunnel";
         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;
@@ -523,22 +523,22 @@ bool Editor::nachricht( SKlient *k )
                 int zielX;
                 int zielY;
                 bool aktiv;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&breite, 4 );
-                object.lese( (char *)&height, 4 );
-                object.lese( (char *)&zielX, 4 );
-                object.lese( (char *)&zielY, 4 );
-                object.lese( (char *)&aktiv, 1 );
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&breite, 4 );
+                object.lese( (char*)&height, 4 );
+                object.lese( (char*)&zielX, 4 );
+                object.lese( (char*)&zielY, 4 );
+                object.lese( (char*)&aktiv, 1 );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&breite, 4 );
-                k->sendeEncrypted( (char *)&height, 4 );
-                k->sendeEncrypted( (char *)&zielX, 4 );
-                k->sendeEncrypted( (char *)&zielY, 4 );
-                k->sendeEncrypted( (char *)&aktiv, 1 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&breite, 4 );
+                k->sendeEncrypted( (char*)&height, 4 );
+                k->sendeEncrypted( (char*)&zielX, 4 );
+                k->sendeEncrypted( (char*)&zielY, 4 );
+                k->sendeEncrypted( (char*)&aktiv, 1 );
             }
         }
         else
@@ -555,12 +555,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/umlenkung";
         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;
@@ -578,24 +578,24 @@ bool Editor::nachricht( SKlient *k )
                 int maxAbklingzeit;
                 bool drehend;
                 bool aktiv;
-                object.lese( (char *)&x, 4 );
-                object.lese( (char *)&y, 4 );
-                object.lese( (char *)&breite, 4 );
-                object.lese( (char *)&height, 4 );
-                object.lese( (char *)&richtung, 1 );
-                object.lese( (char *)&maxAbklingzeit, 4 );
-                object.lese( (char *)&drehend, 1 );
-                object.lese( (char *)&aktiv, 1 );
+                object.lese( (char*)&x, 4 );
+                object.lese( (char*)&y, 4 );
+                object.lese( (char*)&breite, 4 );
+                object.lese( (char*)&height, 4 );
+                object.lese( (char*)&richtung, 1 );
+                object.lese( (char*)&maxAbklingzeit, 4 );
+                object.lese( (char*)&drehend, 1 );
+                object.lese( (char*)&aktiv, 1 );
                 object.close();
-                k->sendeEncrypted( (char *)&id, 4 );
-                k->sendeEncrypted( (char *)&x, 4 );
-                k->sendeEncrypted( (char *)&y, 4 );
-                k->sendeEncrypted( (char *)&breite, 4 );
-                k->sendeEncrypted( (char *)&height, 4 );
-                k->sendeEncrypted( (char *)&richtung, 1 );
-                k->sendeEncrypted( (char *)&maxAbklingzeit, 4 );
-                k->sendeEncrypted( (char *)&drehend, 1 );
-                k->sendeEncrypted( (char *)&aktiv, 1 );
+                k->sendeEncrypted( (char*)&id, 4 );
+                k->sendeEncrypted( (char*)&x, 4 );
+                k->sendeEncrypted( (char*)&y, 4 );
+                k->sendeEncrypted( (char*)&breite, 4 );
+                k->sendeEncrypted( (char*)&height, 4 );
+                k->sendeEncrypted( (char*)&richtung, 1 );
+                k->sendeEncrypted( (char*)&maxAbklingzeit, 4 );
+                k->sendeEncrypted( (char*)&drehend, 1 );
+                k->sendeEncrypted( (char*)&aktiv, 1 );
             }
         }
         else
@@ -612,12 +612,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/trigger";
         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;
@@ -629,7 +629,7 @@ bool Editor::nachricht( SKlient *k )
                 object.open( Datei::Style::lesen );
                 char buffer[ 2048 ];
                 int id = *files->z( i );
-                k->sendeEncrypted( (char *)&id, 4 );
+                k->sendeEncrypted( (char*)&id, 4 );
                 while( size > 0 )
                 {
                     object.lese( buffer, MIN( 2048, (int)size ) );
@@ -653,12 +653,12 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += "/variable";
         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;
@@ -669,8 +669,8 @@ bool Editor::nachricht( SKlient *k )
                 __int64 size = object.getSize();
                 object.open( Datei::Style::lesen );
                 char buffer[ 2048 ];
-                unsigned char len = (unsigned char)( files->z( i )->getLength() - 2 );
-                k->sendeEncrypted( (char *)&len, 1 );
+                unsigned char len = (unsigned char)(files->z( i )->getLength() - 2);
+                k->sendeEncrypted( (char*)&len, 1 );
                 k->sendeEncrypted( *files->z( i ), len );
                 while( size > 0 )
                 {
@@ -700,16 +700,16 @@ bool Editor::nachricht( SKlient *k )
             k->sendeEncrypted( "\1", 1 );
             int width;
             int height;
-            k->getNachrichtEncrypted( (char *)&width, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&width, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
             if( width <= 0 || height <= 0 )
             {
                 err = "Illegal Argument Exception";
                 return 0;
             }
             k->sendeEncrypted( "\1", 1 );
-            d.schreibe( (char *)&width, 4 );
-            d.schreibe( (char *)&height, 4 );
+            d.schreibe( (char*)&width, 4 );
+            d.schreibe( (char*)&height, 4 );
             d.close();
         }
         else
@@ -724,7 +724,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/team/";
         tmpPf += id;
@@ -736,10 +736,10 @@ bool Editor::nachricht( SKlient *k )
             k->sendeEncrypted( "\1", 1 );
             int maxWbZeit;
             int punkte;
-            k->getNachrichtEncrypted( (char *)&maxWbZeit, 4 );
-            k->getNachrichtEncrypted( (char *)&punkte, 4 );
-            d.schreibe( (char *)&maxWbZeit, 4 );
-            d.schreibe( (char *)&punkte, 4 );
+            k->getNachrichtEncrypted( (char*)&maxWbZeit, 4 );
+            k->getNachrichtEncrypted( (char*)&punkte, 4 );
+            d.schreibe( (char*)&maxWbZeit, 4 );
+            d.schreibe( (char*)&punkte, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -755,7 +755,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/player/";
         tmpPf += id;
@@ -767,10 +767,10 @@ bool Editor::nachricht( SKlient *k )
             k->sendeEncrypted( "\1", 1 );
             int spawnX;
             int spawnY;
-            k->getNachrichtEncrypted( (char *)&spawnX, 4 );
-            k->getNachrichtEncrypted( (char *)&spawnY, 4 );
-            d.schreibe( (char *)&spawnX, 4 );
-            d.schreibe( (char *)&spawnY, 4 );
+            k->getNachrichtEncrypted( (char*)&spawnX, 4 );
+            k->getNachrichtEncrypted( (char*)&spawnY, 4 );
+            d.schreibe( (char*)&spawnX, 4 );
+            d.schreibe( (char*)&spawnY, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -786,7 +786,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/bariere/";
         tmpPf += id;
@@ -804,22 +804,22 @@ bool Editor::nachricht( SKlient *k )
             int verschiebungWeite;
             int autoSchaltungMaxTime;
             int team;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&style, 4 );
-            k->getNachrichtEncrypted( (char *)&verschiebungWeite, 4 );
-            k->getNachrichtEncrypted( (char *)&autoSchaltungMaxTime, 4 );
-            k->getNachrichtEncrypted( (char *)&team, 4 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&style, 4 );
-            d.schreibe( (char *)&verschiebungWeite, 4 );
-            d.schreibe( (char *)&autoSchaltungMaxTime, 4 );
-            d.schreibe( (char *)&team, 4 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&style, 4 );
+            k->getNachrichtEncrypted( (char*)&verschiebungWeite, 4 );
+            k->getNachrichtEncrypted( (char*)&autoSchaltungMaxTime, 4 );
+            k->getNachrichtEncrypted( (char*)&team, 4 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&style, 4 );
+            d.schreibe( (char*)&verschiebungWeite, 4 );
+            d.schreibe( (char*)&autoSchaltungMaxTime, 4 );
+            d.schreibe( (char*)&team, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -835,7 +835,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/base/";
         tmpPf += id;
@@ -855,26 +855,26 @@ bool Editor::nachricht( SKlient *k )
             int timerX;
             int timerY;
             int timerFarbe;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char *)&team, 4 );
-            k->getNachrichtEncrypted( (char *)&showTimer, 1 );
-            k->getNachrichtEncrypted( (char *)&timerX, 4 );
-            k->getNachrichtEncrypted( (char *)&timerY, 4 );
-            k->getNachrichtEncrypted( (char *)&timerFarbe, 4 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&maxTime, 4 );
-            d.schreibe( (char *)&team, 4 );
-            d.schreibe( (char *)&showTimer, 1 );
-            d.schreibe( (char *)&timerX, 4 );
-            d.schreibe( (char *)&timerY, 4 );
-            d.schreibe( (char *)&timerFarbe, 4 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
+            k->getNachrichtEncrypted( (char*)&team, 4 );
+            k->getNachrichtEncrypted( (char*)&showTimer, 1 );
+            k->getNachrichtEncrypted( (char*)&timerX, 4 );
+            k->getNachrichtEncrypted( (char*)&timerY, 4 );
+            k->getNachrichtEncrypted( (char*)&timerFarbe, 4 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&maxTime, 4 );
+            d.schreibe( (char*)&team, 4 );
+            d.schreibe( (char*)&showTimer, 1 );
+            d.schreibe( (char*)&timerX, 4 );
+            d.schreibe( (char*)&timerY, 4 );
+            d.schreibe( (char*)&timerFarbe, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -890,7 +890,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/drop/";
         tmpPf += id;
@@ -908,26 +908,26 @@ bool Editor::nachricht( SKlient *k )
             int numDrops;
             float wahrscheinlichkeit[ ITEMANZAHL ];
             unsigned char len;
-            k->getNachrichtEncrypted( (char *)&minX, 4 );
-            k->getNachrichtEncrypted( (char *)&minY, 4 );
-            k->getNachrichtEncrypted( (char *)&maxX, 4 );
-            k->getNachrichtEncrypted( (char *)&maxY, 4 );
-            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char *)&numDrops, 4 );
+            k->getNachrichtEncrypted( (char*)&minX, 4 );
+            k->getNachrichtEncrypted( (char*)&minY, 4 );
+            k->getNachrichtEncrypted( (char*)&maxX, 4 );
+            k->getNachrichtEncrypted( (char*)&maxY, 4 );
+            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
+            k->getNachrichtEncrypted( (char*)&numDrops, 4 );
             for( int i = 0; i < ITEMANZAHL; i++ )
-                k->getNachrichtEncrypted( (char *)&wahrscheinlichkeit[ i ], 4 );
-            k->getNachrichtEncrypted( (char *)&len, 1 );
-            char *name = new char[ len ];
+                k->getNachrichtEncrypted( (char*)&wahrscheinlichkeit[ i ], 4 );
+            k->getNachrichtEncrypted( (char*)&len, 1 );
+            char* name = new char[ len ];
             k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char *)&minX, 4 );
-            d.schreibe( (char *)&minY, 4 );
-            d.schreibe( (char *)&maxX, 4 );
-            d.schreibe( (char *)&maxY, 4 );
-            d.schreibe( (char *)&maxTime, 4 );
-            d.schreibe( (char *)&numDrops, 4 );
+            d.schreibe( (char*)&minX, 4 );
+            d.schreibe( (char*)&minY, 4 );
+            d.schreibe( (char*)&maxX, 4 );
+            d.schreibe( (char*)&maxY, 4 );
+            d.schreibe( (char*)&maxTime, 4 );
+            d.schreibe( (char*)&numDrops, 4 );
             for( int i = 0; i < ITEMANZAHL; i++ )
-                d.schreibe( (char *)&wahrscheinlichkeit[ i ], 4 );
-            d.schreibe( (char *)&len, 1 );
+                d.schreibe( (char*)&wahrscheinlichkeit[ i ], 4 );
+            d.schreibe( (char*)&len, 1 );
             d.schreibe( name, len );
             delete[]name;
             d.close();
@@ -945,7 +945,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/schalter/";
         tmpPf += id;
@@ -960,16 +960,16 @@ bool Editor::nachricht( SKlient *k )
             int breite;
             int height;
             bool aktive;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&aktive, 1 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&aktive, 1 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&aktive, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&aktive, 1 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -985,7 +985,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/schiene/";
         tmpPf += id;
@@ -999,14 +999,14 @@ bool Editor::nachricht( SKlient *k )
             int y;
             int breite;
             int height;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1022,7 +1022,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/timer/";
         tmpPf += id;
@@ -1040,24 +1040,24 @@ bool Editor::nachricht( SKlient *k )
             bool runns;
             int farbe;
             unsigned char len;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&maxZeit, 4 );
-            k->getNachrichtEncrypted( (char *)&sichtbar, 1 );
-            k->getNachrichtEncrypted( (char *)&autoWiederhohlung, 1 );
-            k->getNachrichtEncrypted( (char *)&runns, 1 );
-            k->getNachrichtEncrypted( (char *)&farbe, 4 );
-            k->getNachrichtEncrypted( (char *)&len, 1 );
-            char *name = new char[ len ];
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&maxZeit, 4 );
+            k->getNachrichtEncrypted( (char*)&sichtbar, 1 );
+            k->getNachrichtEncrypted( (char*)&autoWiederhohlung, 1 );
+            k->getNachrichtEncrypted( (char*)&runns, 1 );
+            k->getNachrichtEncrypted( (char*)&farbe, 4 );
+            k->getNachrichtEncrypted( (char*)&len, 1 );
+            char* name = new char[ len ];
             k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&maxZeit, 4 );
-            d.schreibe( (char *)&sichtbar, 1 );
-            d.schreibe( (char *)&autoWiederhohlung, 1 );
-            d.schreibe( (char *)&runns, 1 );
-            d.schreibe( (char *)&farbe, 4 );
-            d.schreibe( (char *)&len, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&maxZeit, 4 );
+            d.schreibe( (char*)&sichtbar, 1 );
+            d.schreibe( (char*)&autoWiederhohlung, 1 );
+            d.schreibe( (char*)&runns, 1 );
+            d.schreibe( (char*)&farbe, 4 );
+            d.schreibe( (char*)&len, 1 );
             d.schreibe( name, len );
             delete[]name;
             d.close();
@@ -1075,7 +1075,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/tunnel/";
         tmpPf += id;
@@ -1092,20 +1092,20 @@ bool Editor::nachricht( SKlient *k )
             int zielX;
             int zielY;
             bool aktiv;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&zielX, 4 );
-            k->getNachrichtEncrypted( (char *)&zielY, 4 );
-            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&zielX, 4 );
-            d.schreibe( (char *)&zielY, 4 );
-            d.schreibe( (char *)&aktiv, 1 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&zielX, 4 );
+            k->getNachrichtEncrypted( (char*)&zielY, 4 );
+            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&zielX, 4 );
+            d.schreibe( (char*)&zielY, 4 );
+            d.schreibe( (char*)&aktiv, 1 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1121,7 +1121,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/umlenkung/";
         tmpPf += id;
@@ -1139,22 +1139,22 @@ bool Editor::nachricht( SKlient *k )
             int maxAbklingzeit;
             bool drehend;
             bool aktiv;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&richtung, 1 );
-            k->getNachrichtEncrypted( (char *)&maxAbklingzeit, 4 );
-            k->getNachrichtEncrypted( (char *)&drehend, 1 );
-            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&richtung, 1 );
-            d.schreibe( (char *)&maxAbklingzeit, 4 );
-            d.schreibe( (char *)&drehend, 1 );
-            d.schreibe( (char *)&aktiv, 1 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&richtung, 1 );
+            k->getNachrichtEncrypted( (char*)&maxAbklingzeit, 4 );
+            k->getNachrichtEncrypted( (char*)&drehend, 1 );
+            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&richtung, 1 );
+            d.schreibe( (char*)&maxAbklingzeit, 4 );
+            d.schreibe( (char*)&drehend, 1 );
+            d.schreibe( (char*)&aktiv, 1 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1170,7 +1170,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/trigger/";
         tmpPf += id;
@@ -1196,9 +1196,9 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         unsigned char len;
-        k->getNachrichtEncrypted( (char *)&len, 1 );
-        char *originalName = new char[ len + 1 ];
-        k->getNachrichtEncrypted( (char *)&originalName, len );
+        k->getNachrichtEncrypted( (char*)&len, 1 );
+        char* originalName = new char[ len + 1 ];
+        k->getNachrichtEncrypted( (char*)&originalName, len );
         originalName[ len ] = 0;
         Text tmpPf = pfad.getText();
         tmpPf += "/variable/";
@@ -1206,9 +1206,9 @@ bool Editor::nachricht( SKlient *k )
         tmpPf += ".v";
         Datei d;
         d.setDatei( tmpPf );
-        k->getNachrichtEncrypted( (char *)&len, 1 );
-        char *name = new char[ len + 1 ];
-        k->getNachrichtEncrypted( (char *)&name, len );
+        k->getNachrichtEncrypted( (char*)&len, 1 );
+        char* name = new char[ len + 1 ];
+        k->getNachrichtEncrypted( (char*)&name, len );
         name[ len ] = 0;
         if( !Text( name ).istGleich( originalName ) )
         {
@@ -1227,7 +1227,7 @@ bool Editor::nachricht( SKlient *k )
         {
             k->sendeEncrypted( "\1", 1 );
             __int64 size;
-            k->getNachrichtEncrypted( (char *)&size, 8 );
+            k->getNachrichtEncrypted( (char*)&size, 8 );
             char buffer[ 2048 ];
             while( size > 0 )
             {
@@ -1265,7 +1265,7 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int breite;
@@ -1274,22 +1274,22 @@ bool Editor::nachricht( SKlient *k )
             int verschiebungWeite;
             int autoSchaltungMaxTime;
             int team;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&style, 4 );
-            k->getNachrichtEncrypted( (char *)&verschiebungWeite, 4 );
-            k->getNachrichtEncrypted( (char *)&autoSchaltungMaxTime, 4 );
-            k->getNachrichtEncrypted( (char *)&team, 4 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&style, 4 );
-            d.schreibe( (char *)&verschiebungWeite, 4 );
-            d.schreibe( (char *)&autoSchaltungMaxTime, 4 );
-            d.schreibe( (char *)&team, 4 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&style, 4 );
+            k->getNachrichtEncrypted( (char*)&verschiebungWeite, 4 );
+            k->getNachrichtEncrypted( (char*)&autoSchaltungMaxTime, 4 );
+            k->getNachrichtEncrypted( (char*)&team, 4 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&style, 4 );
+            d.schreibe( (char*)&verschiebungWeite, 4 );
+            d.schreibe( (char*)&autoSchaltungMaxTime, 4 );
+            d.schreibe( (char*)&team, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1319,7 +1319,7 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int breite;
@@ -1330,26 +1330,26 @@ bool Editor::nachricht( SKlient *k )
             int timerX;
             int timerY;
             int timerFarbe;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char *)&team, 4 );
-            k->getNachrichtEncrypted( (char *)&showTimer, 1 );
-            k->getNachrichtEncrypted( (char *)&timerX, 4 );
-            k->getNachrichtEncrypted( (char *)&timerY, 4 );
-            k->getNachrichtEncrypted( (char *)&timerFarbe, 4 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&maxTime, 4 );
-            d.schreibe( (char *)&team, 4 );
-            d.schreibe( (char *)&showTimer, 1 );
-            d.schreibe( (char *)&timerX, 4 );
-            d.schreibe( (char *)&timerY, 4 );
-            d.schreibe( (char *)&timerFarbe, 4 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
+            k->getNachrichtEncrypted( (char*)&team, 4 );
+            k->getNachrichtEncrypted( (char*)&showTimer, 1 );
+            k->getNachrichtEncrypted( (char*)&timerX, 4 );
+            k->getNachrichtEncrypted( (char*)&timerY, 4 );
+            k->getNachrichtEncrypted( (char*)&timerFarbe, 4 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&maxTime, 4 );
+            d.schreibe( (char*)&team, 4 );
+            d.schreibe( (char*)&showTimer, 1 );
+            d.schreibe( (char*)&timerX, 4 );
+            d.schreibe( (char*)&timerY, 4 );
+            d.schreibe( (char*)&timerFarbe, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1379,7 +1379,7 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int minX;
             int minY;
             int maxX;
@@ -1388,26 +1388,26 @@ bool Editor::nachricht( SKlient *k )
             int numDrops;
             float wahrscheinlichkeit[ ITEMANZAHL ];
             unsigned char len;
-            k->getNachrichtEncrypted( (char *)&minX, 4 );
-            k->getNachrichtEncrypted( (char *)&minY, 4 );
-            k->getNachrichtEncrypted( (char *)&maxX, 4 );
-            k->getNachrichtEncrypted( (char *)&maxY, 4 );
-            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char *)&numDrops, 4 );
+            k->getNachrichtEncrypted( (char*)&minX, 4 );
+            k->getNachrichtEncrypted( (char*)&minY, 4 );
+            k->getNachrichtEncrypted( (char*)&maxX, 4 );
+            k->getNachrichtEncrypted( (char*)&maxY, 4 );
+            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
+            k->getNachrichtEncrypted( (char*)&numDrops, 4 );
             for( int i = 0; i < ITEMANZAHL; i++ )
-                k->getNachrichtEncrypted( (char *)&wahrscheinlichkeit[ i ], 4 );
-            k->getNachrichtEncrypted( (char *)&len, 1 );
-            char *name = new char[ len ];
+                k->getNachrichtEncrypted( (char*)&wahrscheinlichkeit[ i ], 4 );
+            k->getNachrichtEncrypted( (char*)&len, 1 );
+            char* name = new char[ len ];
             k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char *)&minX, 4 );
-            d.schreibe( (char *)&minY, 4 );
-            d.schreibe( (char *)&maxX, 4 );
-            d.schreibe( (char *)&maxY, 4 );
-            d.schreibe( (char *)&maxTime, 4 );
-            d.schreibe( (char *)&numDrops, 4 );
+            d.schreibe( (char*)&minX, 4 );
+            d.schreibe( (char*)&minY, 4 );
+            d.schreibe( (char*)&maxX, 4 );
+            d.schreibe( (char*)&maxY, 4 );
+            d.schreibe( (char*)&maxTime, 4 );
+            d.schreibe( (char*)&numDrops, 4 );
             for( int i = 0; i < ITEMANZAHL; i++ )
-                d.schreibe( (char *)&wahrscheinlichkeit[ i ], 4 );
-            d.schreibe( (char *)&len, 1 );
+                d.schreibe( (char*)&wahrscheinlichkeit[ i ], 4 );
+            d.schreibe( (char*)&len, 1 );
             d.schreibe( name, len );
             delete[]name;
             d.close();
@@ -1439,22 +1439,22 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int breite;
             int height;
             bool aktive;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&aktive, 1 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&aktive, 1 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&aktive, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&aktive, 1 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1484,19 +1484,19 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int breite;
             int height;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1526,7 +1526,7 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int maxZeit;
@@ -1535,24 +1535,24 @@ bool Editor::nachricht( SKlient *k )
             bool runns;
             int farbe;
             unsigned char len;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&maxZeit, 4 );
-            k->getNachrichtEncrypted( (char *)&sichtbar, 1 );
-            k->getNachrichtEncrypted( (char *)&autoWiederhohlung, 1 );
-            k->getNachrichtEncrypted( (char *)&runns, 1 );
-            k->getNachrichtEncrypted( (char *)&farbe, 4 );
-            k->getNachrichtEncrypted( (char *)&len, 1 );
-            char *name = new char[ len ];
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&maxZeit, 4 );
+            k->getNachrichtEncrypted( (char*)&sichtbar, 1 );
+            k->getNachrichtEncrypted( (char*)&autoWiederhohlung, 1 );
+            k->getNachrichtEncrypted( (char*)&runns, 1 );
+            k->getNachrichtEncrypted( (char*)&farbe, 4 );
+            k->getNachrichtEncrypted( (char*)&len, 1 );
+            char* name = new char[ len ];
             k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&maxZeit, 4 );
-            d.schreibe( (char *)&sichtbar, 1 );
-            d.schreibe( (char *)&autoWiederhohlung, 1 );
-            d.schreibe( (char *)&runns, 1 );
-            d.schreibe( (char *)&farbe, 4 );
-            d.schreibe( (char *)&len, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&maxZeit, 4 );
+            d.schreibe( (char*)&sichtbar, 1 );
+            d.schreibe( (char*)&autoWiederhohlung, 1 );
+            d.schreibe( (char*)&runns, 1 );
+            d.schreibe( (char*)&farbe, 4 );
+            d.schreibe( (char*)&len, 1 );
             d.schreibe( name, len );
             delete[]name;
             d.close();
@@ -1584,7 +1584,7 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int breite;
@@ -1592,20 +1592,20 @@ bool Editor::nachricht( SKlient *k )
             int zielX;
             int zielY;
             bool aktiv;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&zielX, 4 );
-            k->getNachrichtEncrypted( (char *)&zielY, 4 );
-            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&zielX, 4 );
-            d.schreibe( (char *)&zielY, 4 );
-            d.schreibe( (char *)&aktiv, 1 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&zielX, 4 );
+            k->getNachrichtEncrypted( (char*)&zielY, 4 );
+            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&zielX, 4 );
+            d.schreibe( (char*)&zielY, 4 );
+            d.schreibe( (char*)&aktiv, 1 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1635,7 +1635,7 @@ bool Editor::nachricht( SKlient *k )
         if( d.open( Datei::Style::schreiben ) )
         {
             k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char *)&id, 4 );
+            k->sendeEncrypted( (char*)&id, 4 );
             int x;
             int y;
             int breite;
@@ -1644,22 +1644,22 @@ bool Editor::nachricht( SKlient *k )
             int maxAbklingzeit;
             bool drehend;
             bool aktiv;
-            k->getNachrichtEncrypted( (char *)&x, 4 );
-            k->getNachrichtEncrypted( (char *)&y, 4 );
-            k->getNachrichtEncrypted( (char *)&breite, 4 );
-            k->getNachrichtEncrypted( (char *)&height, 4 );
-            k->getNachrichtEncrypted( (char *)&richtung, 1 );
-            k->getNachrichtEncrypted( (char *)&maxAbklingzeit, 4 );
-            k->getNachrichtEncrypted( (char *)&drehend, 1 );
-            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
-            d.schreibe( (char *)&x, 4 );
-            d.schreibe( (char *)&y, 4 );
-            d.schreibe( (char *)&breite, 4 );
-            d.schreibe( (char *)&height, 4 );
-            d.schreibe( (char *)&richtung, 1 );
-            d.schreibe( (char *)&maxAbklingzeit, 4 );
-            d.schreibe( (char *)&drehend, 1 );
-            d.schreibe( (char *)&aktiv, 1 );
+            k->getNachrichtEncrypted( (char*)&x, 4 );
+            k->getNachrichtEncrypted( (char*)&y, 4 );
+            k->getNachrichtEncrypted( (char*)&breite, 4 );
+            k->getNachrichtEncrypted( (char*)&height, 4 );
+            k->getNachrichtEncrypted( (char*)&richtung, 1 );
+            k->getNachrichtEncrypted( (char*)&maxAbklingzeit, 4 );
+            k->getNachrichtEncrypted( (char*)&drehend, 1 );
+            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
+            d.schreibe( (char*)&x, 4 );
+            d.schreibe( (char*)&y, 4 );
+            d.schreibe( (char*)&breite, 4 );
+            d.schreibe( (char*)&height, 4 );
+            d.schreibe( (char*)&richtung, 1 );
+            d.schreibe( (char*)&maxAbklingzeit, 4 );
+            d.schreibe( (char*)&drehend, 1 );
+            d.schreibe( (char*)&aktiv, 1 );
             d.close();
             k->sendeEncrypted( "\1", 1 );
             return 1;
@@ -1690,7 +1690,7 @@ bool Editor::nachricht( SKlient *k )
         {
             k->sendeEncrypted( "\1", 1 );
             __int64 size;
-            k->getNachrichtEncrypted( (char *)&size, 8 );
+            k->getNachrichtEncrypted( (char*)&size, 8 );
             char buffer[ 2048 ];
             while( size > 0 )
             {
@@ -1713,9 +1713,9 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         unsigned char len;
-        k->getNachrichtEncrypted( (char *)&len, 1 );
-        char *name = new char[ len + 1 ];
-        k->getNachrichtEncrypted( (char *)&name, len );
+        k->getNachrichtEncrypted( (char*)&len, 1 );
+        char* name = new char[ len + 1 ];
+        k->getNachrichtEncrypted( (char*)&name, len );
         Text tmpPf = pfad.getText();
         tmpPf += "/variable/";
         tmpPf += name;
@@ -1732,7 +1732,7 @@ bool Editor::nachricht( SKlient *k )
         {
             k->sendeEncrypted( "\1", 1 );
             __int64 size;
-            k->getNachrichtEncrypted( (char *)&size, 8 );
+            k->getNachrichtEncrypted( (char*)&size, 8 );
             char buffer[ 2048 ];
             while( size > 0 )
             {
@@ -1755,7 +1755,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/bariere/";
         tmpPf += id;
@@ -1775,7 +1775,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/base/";
         tmpPf += id;
@@ -1795,7 +1795,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/drop/";
         tmpPf += id;
@@ -1815,7 +1815,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/schalter/";
         tmpPf += id;
@@ -1835,7 +1835,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/schiene/";
         tmpPf += id;
@@ -1855,7 +1855,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/timer/";
         tmpPf += id;
@@ -1875,7 +1875,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/tunnel/";
         tmpPf += id;
@@ -1895,7 +1895,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/umlenkung/";
         tmpPf += id;
@@ -1915,7 +1915,7 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         int id;
-        k->getNachrichtEncrypted( (char *)&id, 4 );
+        k->getNachrichtEncrypted( (char*)&id, 4 );
         Text tmpPf = pfad.getText();
         tmpPf += "/trigger/";
         tmpPf += id;
@@ -1935,8 +1935,8 @@ bool Editor::nachricht( SKlient *k )
     {
         k->sendeEncrypted( "\1", 1 );
         unsigned char len;
-        k->getNachrichtEncrypted( (char *)&len, 1 );
-        char *name = new char[ len + 1 ];
+        k->getNachrichtEncrypted( (char*)&len, 1 );
+        char* name = new char[ len + 1 ];
         k->getNachrichtEncrypted( name, len );
         name[ len ] = 0;
         Text tmpPf = pfad.getText();
@@ -1964,7 +1964,7 @@ bool Editor::nachricht( SKlient *k )
 }
 
 // constant
-char *Editor::getLetzterFehler() const
+char* Editor::getLetzterFehler() const
 {
     return err;
 }
@@ -1990,8 +1990,8 @@ bool Editor::createSitzung()
         return 0;
     }
     d.open( Datei::Style::lesen );
-    d.lese( (char *)&spielerAnzahl, 4 );
-    d.lese( (char *)&teamAnzahl, 4 );
+    d.lese( (char*)&spielerAnzahl, 4 );
+    d.lese( (char*)&teamAnzahl, 4 );
     d.close();
     pf = pfad.getText();
     pf.remove( pf.getLength() - 6, pf.getLength() );
@@ -2013,8 +2013,8 @@ 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();
         // teams
         pf = pfad.getText();
@@ -2026,8 +2026,8 @@ bool Editor::createSitzung()
             tmpPf += ".t";
             int maxWbZeit;
             int punkte;
-            d.lese( (char *)&maxWbZeit, 4 );
-            d.lese( (char *)&punkte, 4 );
+            d.lese( (char*)&maxWbZeit, 4 );
+            d.lese( (char*)&punkte, 4 );
             Datei t;
             t.setDatei( tmpPf );
             t.erstellen();
@@ -2039,8 +2039,8 @@ bool Editor::createSitzung()
                 err += __LINE__;
                 err += "\n";
             }
-            t.schreibe( (char *)&maxWbZeit, 4 );
-            t.schreibe( (char *)&punkte, 4 );
+            t.schreibe( (char*)&maxWbZeit, 4 );
+            t.schreibe( (char*)&punkte, 4 );
             t.close();
         }
         // spieler
@@ -2053,8 +2053,8 @@ bool Editor::createSitzung()
             tmpPf += ".p";
             int spawnX;
             int spawnY;
-            d.lese( (char *)&spawnX, 4 );
-            d.lese( (char *)&spawnY, 4 );
+            d.lese( (char*)&spawnX, 4 );
+            d.lese( (char*)&spawnY, 4 );
             Datei s;
             s.setDatei( tmpPf );
             s.erstellen();
@@ -2066,19 +2066,19 @@ bool Editor::createSitzung()
                 err += __LINE__;
                 err += "\n";
             }
-            s.schreibe( (char *)&spawnX, 4 );
-            s.schreibe( (char *)&spawnY, 4 );
+            s.schreibe( (char*)&spawnX, 4 );
+            s.schreibe( (char*)&spawnY, 4 );
             s.close();
         }
         // barieren
         pf = pfad.getText();
         pf += "/bariere/";
         int anz;
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".b";
@@ -2101,11 +2101,11 @@ bool Editor::createSitzung()
         // basen
         pf = pfad.getText();
         pf += "/base/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".b";
@@ -2128,11 +2128,11 @@ bool Editor::createSitzung()
         // drops
         pf = pfad.getText();
         pf += "/drop/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".d";
@@ -2151,23 +2151,23 @@ bool Editor::createSitzung()
             }
             s.schreibe( buffer, 96 );
             unsigned char len;
-            d.lese( (char *)&len, 1 );
-            char *name = new char[ (int)len + 1 ];
+            d.lese( (char*)&len, 1 );
+            char* name = new char[ (int)len + 1 ];
             d.lese( name, len );
             name[ (int)len ] = 0;
-            s.schreibe( (char *)&len, 1 );
-            s.schreibe( (char *)&name, len );
+            s.schreibe( (char*)&len, 1 );
+            s.schreibe( (char*)&name, len );
             delete[] name;
             s.close();
         }
         // schalter
         pf = pfad.getText();
         pf += "/schalter/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".s";
@@ -2190,11 +2190,11 @@ bool Editor::createSitzung()
         // schiene
         pf = pfad.getText();
         pf += "/schiene/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".s";
@@ -2217,11 +2217,11 @@ bool Editor::createSitzung()
         // timer
         pf = pfad.getText();
         pf += "/timer/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".t";
@@ -2240,23 +2240,23 @@ bool Editor::createSitzung()
             }
             s.schreibe( buffer, 19 );
             unsigned char len;
-            d.lese( (char *)&len, 1 );
-            char *name = new char[ (int)len + 1 ];
+            d.lese( (char*)&len, 1 );
+            char* name = new char[ (int)len + 1 ];
             d.lese( name, len );
             name[ (int)len ] = 0;
-            s.schreibe( (char *)&len, 1 );
-            s.schreibe( (char *)&name, len );
+            s.schreibe( (char*)&len, 1 );
+            s.schreibe( (char*)&name, len );
             delete[] name;
             s.close();
         }
         // tunnel
         pf = pfad.getText();
         pf += "/tunnel/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".t";
@@ -2279,11 +2279,11 @@ bool Editor::createSitzung()
         // umlenkung
         pf = pfad.getText();
         pf += "/umlenkung/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".u";
@@ -2307,11 +2307,11 @@ bool Editor::createSitzung()
         MapReader mr;
         pf = pfad.getText();
         pf += "/trigger/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             int id;
-            d.lese( (char *)&id, 4 );
+            d.lese( (char*)&id, 4 );
             Text tmpPf = pf.getText();
             tmpPf += id;
             tmpPf += ".t";
@@ -2327,27 +2327,27 @@ bool Editor::createSitzung()
                 err += "\n";
             }
             unsigned char len;
-            d.lese( (char *)&len, 1 );
-            char *name = new char[ (int)len + 1 ];
+            d.lese( (char*)&len, 1 );
+            char* name = new char[ (int)len + 1 ];
             d.lese( name, len );
             name[ (int)len ] = 0;
-            s.schreibe( (char *)&len, 1 );
-            s.schreibe( (char *)&name, len );
+            s.schreibe( (char*)&len, 1 );
+            s.schreibe( (char*)&name, len );
             delete[] name;
             int ereignisAnzahl;
             int bedingungAnzahl;
             int aktionAnzahl;
-            d.lese( (char *)&ereignisAnzahl, 4 );
-            d.lese( (char *)&bedingungAnzahl, 4 );
-            d.lese( (char *)&aktionAnzahl, 4 );
-            s.schreibe( (char *)&ereignisAnzahl, 4 );
-            s.schreibe( (char *)&bedingungAnzahl, 4 );
-            s.schreibe( (char *)&aktionAnzahl, 4 );
+            d.lese( (char*)&ereignisAnzahl, 4 );
+            d.lese( (char*)&bedingungAnzahl, 4 );
+            d.lese( (char*)&aktionAnzahl, 4 );
+            s.schreibe( (char*)&ereignisAnzahl, 4 );
+            s.schreibe( (char*)&bedingungAnzahl, 4 );
+            s.schreibe( (char*)&aktionAnzahl, 4 );
             for( int j = 0; j < ereignisAnzahl; j++ )
             {
                 int typ;
-                d.lese( (char *)&typ, 4 );
-                s.schreibe( (char *)&typ, 4 );
+                d.lese( (char*)&typ, 4 );
+                s.schreibe( (char*)&typ, 4 );
             }
             for( int j = 0; j < bedingungAnzahl; j++ )
                 mr.writeAktion( mr.readAktion( d ), s );
@@ -2358,12 +2358,12 @@ bool Editor::createSitzung()
         // variable
         pf = pfad.getText();
         pf += "/variable/";
-        d.lese( (char *)&anz, 4 );
+        d.lese( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
             char len;
-            d.lese( (char *)&len, 1 );
-            char *name = new char[ (int)len + 1 ];
+            d.lese( (char*)&len, 1 );
+            char* name = new char[ (int)len + 1 ];
             d.lese( name, len );
             name[ (int)len ] = 0;
             Text tmpPf = pf.getText();
@@ -2398,8 +2398,8 @@ bool Editor::createSitzung()
                 else if( typ == STRING || typ == RICHTUNG )
                 {
                     char len;
-                    d.lese( (char *)&len, 1 );
-                    char *str = new char[ (int)len + 1 ];
+                    d.lese( (char*)&len, 1 );
+                    char* str = new char[ (int)len + 1 ];
                     d.lese( str, len );
                     s.schreibe( &len, 1 );
                     s.schreibe( str, len );
@@ -2408,8 +2408,8 @@ bool Editor::createSitzung()
                 else if( typ != NICHTS )
                 {
                     int v;
-                    d.lese( (char *)&v, 4 );
-                    s.schreibe( (char *)&v, 4 );
+                    d.lese( (char*)&v, 4 );
+                    s.schreibe( (char*)&v, 4 );
                 }
             }
             s.close();
@@ -2453,8 +2453,8 @@ bool Editor::saveSitzung()
         return 0;
     }
     d.open( Datei::Style::lesen );
-    d.lese( (char *)&spielerAnzahl, 4 );
-    d.lese( (char *)&teamAnzahl, 4 );
+    d.lese( (char*)&spielerAnzahl, 4 );
+    d.lese( (char*)&teamAnzahl, 4 );
     d.close();
     pf = pfad.getText();
     pf.remove( pf.getLength() - 6, pf.getLength() );
@@ -2475,8 +2475,8 @@ bool Editor::saveSitzung()
             err += "\n";
         }
         __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();
         for( int i = 0; i < teamAnzahl; i++ )
         {
@@ -2489,10 +2489,10 @@ bool Editor::saveSitzung()
             {
                 int maxWbZeit;
                 int punkte;
-                r.lese( (char *)&maxWbZeit, 4 );
-                r.lese( (char *)&punkte, 4 );
-                d.schreibe( (char *)&maxWbZeit, 4 );
-                d.schreibe( (char *)&punkte, 4 );
+                r.lese( (char*)&maxWbZeit, 4 );
+                r.lese( (char*)&punkte, 4 );
+                d.schreibe( (char*)&maxWbZeit, 4 );
+                d.schreibe( (char*)&punkte, 4 );
                 r.close();
             }
             else
@@ -2517,10 +2517,10 @@ bool Editor::saveSitzung()
             {
                 int spawnX;
                 int spawnY;
-                r.lese( (char *)&spawnX, 4 );
-                r.lese( (char *)&spawnY, 4 );
-                d.schreibe( (char *)&spawnX, 4 );
-                d.schreibe( (char *)&spawnY, 4 );
+                r.lese( (char*)&spawnX, 4 );
+                r.lese( (char*)&spawnY, 4 );
+                d.schreibe( (char*)&spawnX, 4 );
+                d.schreibe( (char*)&spawnY, 4 );
                 r.close();
             }
             else
@@ -2538,12 +2538,12 @@ bool Editor::saveSitzung()
         pf += "/bariere";
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2553,7 +2553,7 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 32 ];
                     r.lese( buffer, 32 );
                     d.schreibe( buffer, 32 );
@@ -2582,8 +2582,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2593,7 +2593,7 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 24 ];
                     r.lese( buffer, 24 );
                     d.schreibe( buffer, 24 );
@@ -2622,8 +2622,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2633,17 +2633,17 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 96 ];
                     r.lese( buffer, 96 );
                     d.schreibe( buffer, 96 );
                     unsigned char len;
-                    r.lese( (char *)&len, 1 );
-                    char *name = new char[ (int)len + 1 ];
+                    r.lese( (char*)&len, 1 );
+                    char* name = new char[ (int)len + 1 ];
                     r.lese( name, len );
                     name[ (int)len ] = 0;
-                    d.schreibe( (char *)&len, 1 );
-                    d.schreibe( (char *)&name, len );
+                    d.schreibe( (char*)&len, 1 );
+                    d.schreibe( (char*)&name, len );
                     delete[] name;
                     r.close();
                 }
@@ -2670,8 +2670,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2681,7 +2681,7 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 17 ];
                     r.lese( buffer, 17 );
                     d.schreibe( buffer, 17 );
@@ -2710,8 +2710,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2721,7 +2721,7 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 16 ];
                     r.lese( buffer, 16 );
                     d.schreibe( buffer, 16 );
@@ -2750,8 +2750,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2761,17 +2761,17 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 19 ];
                     r.lese( buffer, 19 );
                     d.schreibe( buffer, 19 );
                     unsigned char len;
-                    r.lese( (char *)&len, 1 );
-                    char *name = new char[ (int)len + 1 ];
+                    r.lese( (char*)&len, 1 );
+                    char* name = new char[ (int)len + 1 ];
                     r.lese( name, len );
                     name[ (int)len ] = 0;
-                    d.schreibe( (char *)&len, 1 );
-                    d.schreibe( (char *)&name, len );
+                    d.schreibe( (char*)&len, 1 );
+                    d.schreibe( (char*)&name, len );
                     delete[] name;
                     r.close();
                 }
@@ -2798,8 +2798,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2809,7 +2809,7 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 25 ];
                     r.lese( buffer, 25 );
                     d.schreibe( buffer, 25 );
@@ -2838,8 +2838,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2849,7 +2849,7 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     char buffer[ 23 ];
                     r.lese( buffer, 23 );
                     d.schreibe( buffer, 23 );
@@ -2879,8 +2879,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2890,29 +2890,29 @@ bool Editor::saveSitzung()
                 if( r.open( Datei::Style::lesen ) )
                 {
                     int id = (int)*objPf.val();
-                    d.schreibe( (char *)&id, 4 );
+                    d.schreibe( (char*)&id, 4 );
                     unsigned char len;
-                    r.lese( (char *)&len, 1 );
-                    char *name = new char[ (int)len + 1 ];
+                    r.lese( (char*)&len, 1 );
+                    char* name = new char[ (int)len + 1 ];
                     r.lese( name, len );
                     name[ (int)len ] = 0;
-                    d.schreibe( (char *)&len, 1 );
-                    d.schreibe( (char *)&name, len );
+                    d.schreibe( (char*)&len, 1 );
+                    d.schreibe( (char*)&name, len );
                     delete[] name;
                     int ereignisAnzahl;
                     int bedingungAnzahl;
                     int aktionAnzahl;
-                    r.lese( (char *)&ereignisAnzahl, 4 );
-                    r.lese( (char *)&bedingungAnzahl, 4 );
-                    r.lese( (char *)&aktionAnzahl, 4 );
-                    d.schreibe( (char *)&ereignisAnzahl, 4 );
-                    d.schreibe( (char *)&bedingungAnzahl, 4 );
-                    d.schreibe( (char *)&aktionAnzahl, 4 );
+                    r.lese( (char*)&ereignisAnzahl, 4 );
+                    r.lese( (char*)&bedingungAnzahl, 4 );
+                    r.lese( (char*)&aktionAnzahl, 4 );
+                    d.schreibe( (char*)&ereignisAnzahl, 4 );
+                    d.schreibe( (char*)&bedingungAnzahl, 4 );
+                    d.schreibe( (char*)&aktionAnzahl, 4 );
                     for( int j = 0; j < ereignisAnzahl; j++ )
                     {
                         int typ;
-                        r.lese( (char *)&typ, 4 );
-                        d.schreibe( (char *)&typ, 4 );
+                        r.lese( (char*)&typ, 4 );
+                        d.schreibe( (char*)&typ, 4 );
                     }
                     for( int j = 0; j < bedingungAnzahl; j++ )
                         mr.writeAktion( mr.readAktion( r ), d );
@@ -2943,8 +2943,8 @@ bool Editor::saveSitzung()
         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->begin(); objPf && objPf._; objPf++ )
             {
                 Text tmp = pf.getText();
                 tmp += "/";
@@ -2953,8 +2953,8 @@ bool Editor::saveSitzung()
                 r.setDatei( tmp );
                 if( r.open( Datei::Style::lesen ) )
                 {
-                    unsigned char len = (unsigned char)( objPf->getLength() - 2 );
-                    d.schreibe( (char *)&len, 1 );
+                    unsigned char len = (unsigned char)(objPf->getLength() - 2);
+                    d.schreibe( (char*)&len, 1 );
                     d.schreibe( objPf->getText(), len );
                     char typ;
                     r.lese( &typ, 1 );
@@ -2973,8 +2973,8 @@ bool Editor::saveSitzung()
                         else if( typ == STRING || typ == RICHTUNG )
                         {
                             char len;
-                            r.lese( (char *)&len, 1 );
-                            char *str = new char[ (int)len + 1 ];
+                            r.lese( (char*)&len, 1 );
+                            char* str = new char[ (int)len + 1 ];
                             r.lese( str, len );
                             d.schreibe( &len, 1 );
                             d.schreibe( str, len );
@@ -2983,8 +2983,8 @@ bool Editor::saveSitzung()
                         else if( typ != NICHTS )
                         {
                             int v;
-                            r.lese( (char *)&v, 4 );
-                            d.schreibe( (char *)&v, 4 );
+                            r.lese( (char*)&v, 4 );
+                            d.schreibe( (char*)&v, 4 );
                         }
                     }
                     r.close();
@@ -3030,10 +3030,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;

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/Reader.cpp

@@ -3,7 +3,7 @@
 
 
 // Konstruktor
-MapReader::MapReader( int karteId, SSDatenbankV *db, char *tmpPfad )
+MapReader::MapReader( int karteId, SSDatenbankV* db, char* tmpPfad )
     : ReferenceCounter()
 {
     this->karteId = karteId;
@@ -27,13 +27,13 @@ MapReader::~MapReader()
         pfad->release();
 }
 
-Aktion *MapReader::readAktion( Datei &dat )
+Aktion* MapReader::readAktion( Datei& 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 )
@@ -288,35 +288,35 @@ Aktion *MapReader::readAktion( Datei &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:
@@ -327,10 +327,10 @@ Aktion *MapReader::readAktion( Datei &dat )
         params->release();
         char len;
         dat.lese( &len, 1 );
-        char *txt = new char[ len + 1 ];
+        char* txt = new char[ len + 1 ];
         dat.lese( txt, len );
         txt[ (int)len ] = 0;
-        Aktion *ret = new KonstantString( txt );
+        Aktion* ret = new KonstantString( txt );
         delete[] txt;
         return ret;
     }
@@ -339,10 +339,10 @@ Aktion *MapReader::readAktion( Datei &dat )
         params->release();
         char len;
         dat.lese( &len, 1 );
-        char *txt = new char[ len + 1 ];
+        char* txt = new char[ len + 1 ];
         dat.lese( txt, len );
         txt[ (int)len ] = 0;
-        Aktion *ret = new KonstantVariable( txt );
+        Aktion* ret = new KonstantVariable( txt );
         delete[] txt;
         return ret;
     }
@@ -367,10 +367,10 @@ Aktion *MapReader::readAktion( Datei &dat )
     {
         char len;
         dat.lese( &len, 1 );
-        char *txt = new char[ len + 1 ];
+        char* txt = new char[ 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;
     }
@@ -576,13 +576,13 @@ Aktion *MapReader::readAktion( Datei &dat )
 }
 
 
-void MapReader::writeAktion( Aktion *zAk, Datei &dat )
+void MapReader::writeAktion( Aktion* zAk, Datei& 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 );
@@ -590,14 +590,14 @@ void MapReader::writeAktion( Aktion *zAk, Datei &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( "sts.ltgd" );
-    Datei *datei = new Datei();
+    Datei* datei = new Datei();
     datei->setDatei( pf );
     if( !datei->existiert() || datei->istOrdner() )
     {
@@ -605,35 +605,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[ len + 1 ];
+        char* txt = new char[ 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();
@@ -648,16 +648,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
@@ -667,8 +667,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++;
@@ -679,7 +679,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;
@@ -691,19 +691,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( 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;
@@ -717,21 +717,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 );
+        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( id, x, y, breite, height, showTimer, Punkt( timerX, timerY ), timerFarbe, maxTime, zSpiel->getTeam( team ) ) );
     }
     // Drops
-    mapFile.lese( (char *)&anz, 4 );
+    mapFile.lese( (char*)&anz, 4 );
     for( int i = 0; i < anz; i++ )
     {
         int minX;
@@ -742,25 +742,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[ (int)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (int)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;
@@ -769,16 +769,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( 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;
@@ -786,15 +786,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( 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;
@@ -805,24 +805,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[ (int)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (int)len + 1 ];
         mapFile.lese( name, len );
         name[ (int)len ] = 0;
         zSpiel->addTimer( new Timer( 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;
@@ -833,18 +833,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( 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;
@@ -856,60 +856,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( 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[ (int)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (int)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[ (int)len + 1 ];
+        mapFile.lese( (char*)&len, 1 );
+        char* name = new char[ (int)len + 1 ];
         mapFile.lese( name, len );
         name[ (int)len ] = 0;
         char typ;
         mapFile.lese( &typ, 1 );
         char def;
         mapFile.lese( &def, 1 );
-        Variable *var;
+        Variable* var;
         if( !def )
             var = new Variable( NICHTS );
         else
@@ -922,22 +922,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[ (int)len + 1 ];
+                mapFile.lese( (char*)&len, 1 );
+                char* value = new char[ (int)len + 1 ];
                 mapFile.lese( value, len );
                 value[ (int)len ] = 0;
                 var = new String( value );
@@ -947,8 +947,8 @@ void MapReader::ladeKarte( Spiel *zSpiel )
             case RICHTUNG:
             {
                 char len;
-                mapFile.lese( (char *)&len, 1 );
-                char *value = new char[ (int)len + 1 ];
+                mapFile.lese( (char*)&len, 1 );
+                char* value = new char[ (int)len + 1 ];
                 mapFile.lese( value, len );
                 value[ (int)len ] = 0;
                 var = new String( getRichtungFromString( Text( value ) ) );
@@ -958,7 +958,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;
             }
@@ -972,77 +972,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/Spiel.cpp

@@ -132,12 +132,12 @@ Spiel::~Spiel()
 }
 
 // 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()) );
 }
 // call 1
 void Spiel::setSpielId( int id )
@@ -152,35 +152,35 @@ void Spiel::setKarteId( int karteId )
     stat->setKarteId( karteId );
 }
 // call 3
-void Spiel::setTempPfad( char *pfad )
+void Spiel::setTempPfad( char* pfad )
 {
     mapPfad = pfad;
     mapPfad += "/";
 }
 // call 3.5
-void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
+void Spiel::setAccounts( int anzahl, Array< int >* zAccounts )
 {
     if( this->zAccounts )
         this->zAccounts->release();
-    this->zAccounts = dynamic_cast<Array<int> *>( zAccounts->getThis() );
+    this->zAccounts = dynamic_cast<Array<int> *>(zAccounts->getThis());
     spielerAnzahl = anzahl;
 }
 // call 4
-void Spiel::setKlients( int anzahl, RCArray< SSKlientV > *zKlients )
+void Spiel::setKlients( int anzahl, RCArray< SSKlientV >* zKlients )
 {
     if( this->zKlients )
         this->zKlients->release();
-    this->zKlients = dynamic_cast<RCArray<SSKlientV> *>( zKlients->getThis() );
+    this->zKlients = dynamic_cast<RCArray<SSKlientV> *>(zKlients->getThis());
 }
 // call 5
-void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
+void Spiel::setSpielerNummern( int anzahl, Array< int >* spielerNummern )
 {
-    MapReader *reader = new MapReader( karteId, dynamic_cast<SSDatenbankV *>( psqldb->getThis() ), mapPfad );
+    MapReader* reader = new MapReader( karteId, dynamic_cast<SSDatenbankV*>(psqldb->getThis()), mapPfad );
     reader->ladeKarte( this );
     reader->release();
     for( int i = 0; i < anzahl; i++ )
     {
-        for( auto s = spieler.getIterator(); s; s++ )
+        for( auto s : spieler )
         {
             if( s->getId() == spielerNummern->get( i ) )
             {
@@ -190,8 +190,8 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
             }
         }
     }
-    zAccounts = ( Array<int>* )zAccounts->release();
-    zKlients = ( RCArray<SSKlientV>* )zKlients->release();
+    zAccounts = (Array<int>*)zAccounts->release();
+    zKlients = (RCArray<SSKlientV>*)zKlients->release();
     stat->setTeams( &teams );
     stat->setSpieler( &spieler );
 }
@@ -199,7 +199,7 @@ void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
 void Spiel::run()
 {
     log = new Datei();
-    Text *pfad = new Text( "../spiel log/" );
+    Text* pfad = new Text( "../spiel log/" );
     pfad->append( spielId );
     pfad->append( "/verlauf.ksggl" );
     log->setDatei( pfad );
@@ -209,20 +209,20 @@ void Spiel::run()
     time_t t;
     time( &t );
     srand( (unsigned int)t );
-    log->schreibe( (char *)&spielerAnzahl, 4 );
+    log->schreibe( (char*)&spielerAnzahl, 4 );
     int anz = spieler.getEintragAnzahl();
     for( int i = 0; i < anz; i++ )
     {
-        Spieler *tmp = spieler.z( i );
+        Spieler* tmp = spieler.z( i );
         if( tmp && tmp->zKlient() )
         {
             tmp->zKlient()->sendeInit( &spieler, randG.getSeed() );
-            log->schreibe( (char *)&i, 4 );
+            log->schreibe( (char*)&i, 4 );
             int sNum = tmp->getId();
-            log->schreibe( (char *)&sNum, 4 );
+            log->schreibe( (char*)&sNum, 4 );
             tmp->zKlient()->sendeSpielerNummer( sNum );
-            Text *name = psqldb->getAccountRufName( tmp->getAccountId() );
-            char len = (char)( name ? name->getLength() : 0 );
+            Text* name = psqldb->getAccountRufName( tmp->getAccountId() );
+            char len = (char)(name ? name->getLength() : 0);
             log->schreibe( &len, 1 );
             if( len )
                 log->schreibe( name->getText(), len );
@@ -234,9 +234,9 @@ void Spiel::run()
         }
     }
     __int64 randSeed = randG.getSeed();
-    log->schreibe( (char *)&randSeed, 8 );
+    log->schreibe( (char*)&randSeed, 8 );
     Array< char > spielerStatus;
-    ZeitMesser *zeit = new ZeitMesser();
+    ZeitMesser* zeit = new ZeitMesser();
     zeit->messungStart();
     isRunning = 1;
     ende = 0;
@@ -245,7 +245,7 @@ void Spiel::run()
     gameTicks = -1;
     for( int i = 0; i < anz; i++ )
     {
-        Spieler *tmp = spieler.z( i );
+        Spieler* tmp = spieler.z( i );
         if( tmp && tmp->zKlient() )
             tmp->zKlient()->sendeStart();
     }
@@ -258,7 +258,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 )
         {
@@ -293,13 +293,13 @@ void Spiel::run()
                 spieler.z( i )->zKlient()->sendeSpielEnde( 1 );
             }
         }
-        if( spieler.z( i ) && ( !spieler.z( i )->zKlient() || !spieler.z( i )->zKlient()->istOnline() ) )
+        if( spieler.z( i ) && (!spieler.z( i )->zKlient() || !spieler.z( i )->zKlient()->istOnline()) )
             spielerStatus.set( 3, i );
     }
     psqldb->setSpielStatusBeendet( spielId, 5 );
     for( int i = 0; i < anz; i++ )
     {
-        Spieler *tmp = spieler.z( i );
+        Spieler* tmp = spieler.z( i );
         if( tmp )
         {
             psqldb->setSpielSpielerStatus( spielId, tmp->getAccountId(), tmp->getPunkte(), spielerStatus.get( i ) );
@@ -307,7 +307,7 @@ void Spiel::run()
         }
     }
     log->close();
-    log = (Datei *)log->release();
+    log = (Datei*)log->release();
     isRunning = 0;
 }
 // call 7
@@ -320,15 +320,15 @@ void Spiel::klientOffline( int accountId )
     }
 }
 
-void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
+void Spiel::klientOnline( int accountId, SSKlientV* zKlient )
 {
     for( int i = 0; i < spieler.getEintragAnzahl(); i++ )
     {
         if( spieler.z( i )->getAccountId() == accountId )
         {
             c.lock();
-            Spieler *s = spieler.z( i );
-            Klient *tmp = s->zKlient();
+            Spieler* s = spieler.z( i );
+            Klient* tmp = s->zKlient();
             tmp->online( zKlient );
             tmp->sendeSpielerNummer( s->getId() );
             //--------------------------
@@ -337,7 +337,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 )
         return;
@@ -347,7 +347,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         c.unlock();
         return;
     }
-    char *msgBeg = bytes;
+    char* msgBeg = bytes;
     int msgLen = len;
     int msgAccount = accountId;
     bool saveMSG = 1;
@@ -359,7 +359,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         len--;
         for( int i = 0; i < spieler.getEintragAnzahl(); i++ )
         {
-            Spieler *tmp = spieler.z( i );
+            Spieler* tmp = spieler.z( i );
             if( tmp && tmp->getAccountId() == accountId )
             {
                 if( !tmp->setTastenStand( *bytes, 1 ) )
@@ -367,13 +367,13 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                     saveMSG = 0;
                     break;
                 }
-                Ereignis *e = new Ereignis( SPIELER_KEY_PRESSED );
+                Ereignis* e = new Ereignis( SPIELER_KEY_PRESSED );
                 e->addParameter( "Betroffene Taste", new Integer( *bytes, 1 ) );
-                e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler *>( tmp->getThis() ) );
+                e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler*>(tmp->getThis()) );
                 throwEvent( e );
                 for( int j = 0; j < spieler.getEintragAnzahl(); j++ )
                 {
-                    Spieler *s = spieler.z( j );
+                    Spieler* s = spieler.z( j );
                     if( s && s->zKlient() )
                         s->zKlient()->sendeTastaturStatus( tmp->getId(), *bytes, 1 );
                 }
@@ -386,7 +386,7 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         len--;
         for( int i = 0; i < spieler.getEintragAnzahl(); i++ )
         {
-            Spieler *tmp = spieler.z( i );
+            Spieler* tmp = spieler.z( i );
             if( tmp && tmp->getAccountId() == accountId )
             {
                 if( !tmp->setTastenStand( (unsigned char)*bytes, 0 ) )
@@ -394,13 +394,13 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                     saveMSG = 0;
                     break;
                 }
-                Ereignis *e = new Ereignis( SPIELER_KEY_RELEASED );
+                Ereignis* e = new Ereignis( SPIELER_KEY_RELEASED );
                 e->addParameter( "Betroffene Taste", new Integer( *bytes, 1 ) );
-                e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler *>( tmp->getThis() ) );
+                e->addParameter( "Ausführender Spieler", dynamic_cast<Spieler*>(tmp->getThis()) );
                 throwEvent( e );
                 for( int j = 0; j < spieler.getEintragAnzahl(); j++ )
                 {
-                    Spieler *s = spieler.z( j );
+                    Spieler* s = spieler.z( j );
                     if( s && s->zKlient() )
                         s->zKlient()->sendeTastaturStatus( tmp->getId(), *bytes, 0 );
                 }
@@ -412,12 +412,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 < spieler.getEintragAnzahl(); i++ )
             {
-                Spieler *tmp = spieler.z( i );
+                Spieler* tmp = spieler.z( i );
                 if( tmp && tmp->zKlient() )
                     tmp->zKlient()->sendeChatNachricht( txt->getText() );
             }
@@ -439,16 +439,16 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
         int spielerNum = 0;
         for( int i = 0; i < spieler.getEintragAnzahl(); i++ )
         {
-            Spieler *tmp = spieler.z( i );
+            Spieler* tmp = spieler.z( i );
             if( tmp && tmp->getAccountId() == msgAccount )
             {
                 spielerNum = tmp->getId();
                 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 );
     }
     c.unlock();
@@ -474,15 +474,15 @@ void Spiel::tick( double zeit )
     {
         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 ) )
                 {
@@ -500,15 +500,15 @@ void Spiel::tick( double zeit )
     {
         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 ) )
                 {
@@ -533,7 +533,7 @@ void Spiel::tick( double zeit )
     }
     Richtung rs[] = { OBEN, RECHTS, UNTEN, LINKS };
     // spieler bewegungen
-    for( auto s = spieler.getIterator(); s; s++ )
+    for( auto s : spieler )
     {
         if( s->zKlient() )
             s->zKlient()->sendeTick();
@@ -544,28 +544,28 @@ void Spiel::tick( double zeit )
                 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 ) )
             {
@@ -577,7 +577,7 @@ void Spiel::tick( double zeit )
         {
             if( zuletztBariereGetroffenesGeschoss )
                 zuletztBariereGetroffenesGeschoss->release();
-            zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss *>( g->getThis() );
+            zuletztBariereGetroffenesGeschoss = dynamic_cast<Geschoss*>(g->getThis());
             g->tick( -zeit );
             switch( g->getTyp() )
             {
@@ -602,7 +602,7 @@ void Spiel::tick( double zeit )
                     g->invertDirection();
                 break;
             case GESCHOSS_MINE:
-                for( auto s = spieler.getIterator(); s; s++ )
+                for( auto s : spieler )
                 {
                     if( s->abstandZu( g ) < 50 )
                     {
@@ -620,23 +620,23 @@ void Spiel::tick( double zeit )
         }
         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 ) )
                     {
@@ -654,16 +654,16 @@ void Spiel::tick( double zeit )
                 // 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 );
                         }
                     }
@@ -675,7 +675,7 @@ void Spiel::tick( double zeit )
                     {
                         if( i == j )
                             continue;
-                        Geschoss *g2 = shots.z( j );
+                        Geschoss* g2 = shots.z( j );
                         if( g2->intersectsWith( g ) )
                         {
                             if( g2->getTyp() == GESCHOSS_PFEIL )
@@ -695,7 +695,7 @@ void Spiel::tick( double zeit )
                 if( !removed )
                 {
                     // geschoss - spieler intersection
-                    for( auto s = spieler.getIterator(); s; s++ )
+                    for( auto s : spieler )
                     {
                         if( s->istAmLeben() && g->intersectsWith( s ) )
                         {
@@ -712,13 +712,13 @@ void Spiel::tick( double zeit )
                                 break;
                             }
                             case GESCHOSS_DRACHENAUGE:
-                                s->addEffekt( new DrachenAugeEffect( g->zBesitzer(), s._ ) );
+                                s->addEffekt( new DrachenAugeEffect( g->zBesitzer(), s ) );
                                 break;
                             case GESCHOSS_FEUERBALL:
                                 feuer.add( new FeuerballTreffer( ++nextId, (int)g->getX() - (int)g->getWidth() / 2, (int)g->getY() - (int)g->getHeight() / 2, g->getBesitzer(), 10 ) );
                                 break;
                             case GESCHOSS_MINE:
-                                for( auto s2 = spieler.getIterator(); s2; s2++ )
+                                for( auto s2 : spieler )
                                 {
                                     if( s2->abstandZu( g ) < 50 )
                                     {
@@ -749,7 +749,7 @@ void Spiel::tick( double zeit )
     // 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() )
         {
@@ -759,7 +759,7 @@ void Spiel::tick( double zeit )
         }
         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( f->zVerursacher(), s ) );
@@ -767,23 +767,23 @@ void Spiel::tick( double zeit )
         }
     }
     // 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 );
@@ -792,10 +792,10 @@ void Spiel::tick( double zeit )
     }
 }
 
-void Spiel::addVariable( const char *name, Variable *var )
+void Spiel::addVariable( const char* name, Variable* var )
 {
     bool found = 0;
-    for( auto v = variablen.getIterator(); v; v++ )
+    for( auto v : variablen )
     {
         if( v->getName().istGleich( name ) )
         {
@@ -809,10 +809,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 ) )
         {
@@ -825,90 +825,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 )
     {
@@ -919,7 +919,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++ )
@@ -955,129 +955,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();
@@ -1085,9 +1085,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();
@@ -1102,20 +1102,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 );
         }
@@ -1125,7 +1125,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;
@@ -1148,101 +1148,101 @@ int Spiel::getTickCount() const
     return gameTicks;
 }
 
-void Spiel::setEnde( Team *zGewinner )
+void Spiel::setEnde( Team* zGewinner )
 {
     zWinner = zGewinner;
     ende = true;
 }
 
-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 )
@@ -1270,346 +1270,346 @@ 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;
 }
 
-StatistikV *Spiel::getStatistik() const
+StatistikV* Spiel::getStatistik() const
 {
-    return dynamic_cast<StatistikV *>( stat->getThis() );
+    return dynamic_cast<StatistikV*>(stat->getThis());
 }

StickmanWorldOnline/Spieler.cpp

@@ -104,7 +104,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;
@@ -157,7 +157,7 @@ void Inventar::removeItem( GegenstandTyp typ, int anzahl )
 }
 
 
-Spieler::Spieler( int id, Team *team, int spawnX, int spawnY, int farbe )
+Spieler::Spieler( int id, Team* team, int spawnX, int spawnY, int farbe )
     : GameObject( SPIELER, spawnX, spawnY, 40, 50 )
 {
     klient = 0;
@@ -233,10 +233,10 @@ bool Spieler::setTastenStand( unsigned char taste, bool pressed )
             ausrichtung = MITTE;
         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;
@@ -252,7 +252,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();
@@ -267,14 +267,14 @@ void Spieler::setAccount( int id )
     this->accountId = id;
 }
 
-void Spieler::setKlient( Klient *klient )
+void Spieler::setKlient( Klient* klient )
 {
     if( this->klient )
         this->klient->release();
     this->klient = klient;
 }
 
-void Spieler::addEffekt( Effect *e )
+void Spieler::addEffekt( Effect* e )
 {
     effekte.add( e );
 }
@@ -284,12 +284,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 > (float)maxErfahrung )
@@ -298,11 +298,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 )
@@ -322,13 +322,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;
@@ -348,21 +348,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
@@ -372,7 +372,7 @@ void Spieler::addKill()
     kills++;
 }
 
-void Spieler::addTreffer( Spiel *zSpiel )
+void Spieler::addTreffer( Spiel* zSpiel )
 {
     addErfahrung( 2, zSpiel );
     treffer++;
@@ -398,22 +398,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() )
     {
@@ -448,11 +448,11 @@ void Spieler::tick( double zeit, Spiel *zSpiel )
     inv.tick( zeit );
 }
 
-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 );
@@ -460,8 +460,8 @@ void Spieler::useItem( Spiel *zSpiel )
         {
         case PFEIL:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( 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->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( this ) );
@@ -477,8 +477,8 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case KUGEL:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( 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->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( this, getAusrichtung() ) );
@@ -488,44 +488,44 @@ void Spieler::useItem( Spiel *zSpiel )
             break;
         case DRACHENAUGE:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( 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->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->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->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( this, getAusrichtung() ) );
             break;
         case MINE:
             geschosseGeschossen++;
-            zSpiel->setSpielerZuletztGeschossen( dynamic_cast<Spieler *>( getThis() ) );
-            zSpiel->addGeschoss( new Geschoss( 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->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 );
@@ -537,17 +537,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++;
@@ -577,19 +577,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;
@@ -599,39 +599,39 @@ 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 );
     if( leben == 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();
-        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 )
+void Spieler::heilung( float heal, Spiel* zSpiel )
 {
     if( istAmLeben() )
     {
         heal = heal + leben > (float)maxLeben ? (float)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 );
     }
@@ -662,12 +662,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;
@@ -704,7 +704,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 )
@@ -748,19 +748,19 @@ float Spieler::getSchadenBonus() const
     return schadensBonus;
 }
 
-Klient *Spieler::zKlient() const
+Klient* Spieler::zKlient() const
 {
     return klient;
 }
 
-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
@@ -775,7 +775,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
@@ -791,7 +791,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 )
@@ -803,7 +803,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 )
@@ -812,10 +812,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 )
@@ -827,7 +827,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 )
@@ -951,7 +951,7 @@ GegenstandTyp Spieler::getInventorySlot( int index ) const
     return inv.getItemTyp( index );
 }
 
-const char *Spieler::getName() const
+const char* Spieler::getName() const
 {
     return name;
 }

StickmanWorldOnline/Statistik.cpp

@@ -41,12 +41,12 @@ 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;
-    for( auto s = spieler->getIterator(); s; s++ )
+    for( auto s : *spieler )
         zk->sendeSpielerStatistik( s );
-    for( auto t = teams->getIterator(); t; t++ )
+    for( auto t : *teams )
         zk->sendeTeamStatistik( t );
     zk->sendeStatistikLadenFertig();
     for( int i = 0; i < spieler->getEintragAnzahl(); i++ )
@@ -67,7 +67,7 @@ void Statistik::setKarteId( int id )
     karteId = id;
 }
 
-void Statistik::setPSQLDB( SSDatenbankV *db )
+void Statistik::setPSQLDB( SSDatenbankV* db )
 {
     if( this->db )
         this->db->release();
@@ -79,13 +79,13 @@ void Statistik::spielEnde( int team )
     gewinnerTeam = team;
 }
 
-void Statistik::setTeams( RCArray< Team > *zTeams )
+void Statistik::setTeams( RCArray< Team >* zTeams )
 {
     for( int i = 0; i < zTeams->getEintragAnzahl(); i++ )
         teams->set( zTeams->get( i ), i );
 }
 
-void Statistik::setSpieler( RCArray< Spieler > *zSpieler )
+void Statistik::setSpieler( RCArray< Spieler >* zSpieler )
 {
     for( int i = 0; i < zSpieler->getEintragAnzahl(); i++ )
     {
@@ -109,7 +109,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 )
@@ -131,7 +131,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 ];
@@ -158,7 +158,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 );

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,12 +155,12 @@ 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 );
 }
 
 
-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;
@@ -200,25 +200,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 ) )
         {
@@ -227,7 +227,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
@@ -240,7 +240,7 @@ int Trigger::getRuns() const
     return runCount;
 }
 
-const char *Trigger::getName() const
+const char* Trigger::getName() const
 {
     return name.getText();
 }
@@ -251,7 +251,7 @@ bool Trigger::istAktiv() const
 }
 
 
-TriggerRun::TriggerRun( Trigger *trig, Ereignis *e, Spiel *zSpiel )
+TriggerRun::TriggerRun( Trigger* trig, Ereignis* e, Spiel* zSpiel )
     : ReferenceCounter()
 {
     trigger = trig;
@@ -276,7 +276,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() )
@@ -285,7 +285,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());
 }