change array iteration

Asteroids/Asteroids.vcxproj

@@ -22,32 +22,32 @@
     <ProjectGuid>{E2BFB1FB-F888-490A-8159-D0F01D9C734A}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>Asteroids</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>

Asteroids/Editor/Abstract/Model.cpp

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

Asteroids/Editor/Editor.cpp

@@ -25,7 +25,7 @@ AsteroidsEditor::AsteroidsEditor()
     i = 0;
     alpha = 0;
     status = START;
-    dialogs = new Array< Dialog * >();
+    dialogs = new Array< Dialog* >();
     sts = 0;
     rend = 1;
     daten = 0;
@@ -57,7 +57,7 @@ AsteroidsEditor::~AsteroidsEditor()
 void AsteroidsEditor::ladeKarte()
 {
     if( sts )
-        sts = (SpielerTeamStruktur *)sts->release();
+        sts = (SpielerTeamStruktur*)sts->release();
     sts = new SpielerTeamStruktur();
     klient->getSpielerTeamStruktur( sts );
     if( daten )
@@ -65,8 +65,8 @@ void AsteroidsEditor::ladeKarte()
         daten->stopWork();
         daten->release();
     }
-    daten = new KarteDaten( dynamic_cast<EditorKlient *>( klient->getThis() ), sts );
-    i->setDaten( dynamic_cast<KarteDaten *>( daten->getThis() ) );
+    daten = new KarteDaten( dynamic_cast<EditorKlient*>(klient->getThis()), sts );
+    i->setDaten( dynamic_cast<KarteDaten*>(daten->getThis()) );
     minimap->setWelt( daten->getWelt(), 0 );
     minimap->lookAtWorldPos( daten->zWelt()->getWorldInfo().size / 2 );
     minimap->lookAtWorldArea( (float)daten->zWelt()->getWorldInfo().size.x, (float)daten->zWelt()->getWorldInfo().size.y );
@@ -74,7 +74,7 @@ void AsteroidsEditor::ladeKarte()
 }
 
 // nicht constant
-void AsteroidsEditor::addDialog( Dialog *d )
+void AsteroidsEditor::addDialog( Dialog* d )
 {
     c.lock();
     dialogs->add( d );
@@ -82,21 +82,21 @@ void AsteroidsEditor::addDialog( Dialog *d )
 }
 
 // nicht constant
-void AsteroidsEditor::setUIFactory( UIInit &uiFactory )
+void AsteroidsEditor::setUIFactory( UIInit& uiFactory )
 {
     this->uiFactory = uiFactory;
     if( !i && windowSize != Punkt() )
         i = new Interface( uiFactory, windowSize );
 }
 
-void AsteroidsEditor::setKlient( KSGClient::EditorServerClient *ekv )
+void AsteroidsEditor::setKlient( KSGClient::EditorServerClient* ekv )
 {
     if( klient )
         klient->release();
     klient = new EditorKlient( ekv );
 }
 
-void AsteroidsEditor::setLadeAnimation( Animation2D *la )
+void AsteroidsEditor::setLadeAnimation( Animation2D* la )
 {
     if( laden )
         laden->release();
@@ -109,32 +109,29 @@ void AsteroidsEditor::setSichtbar()
     Punkt mS = windowSize;
     if( windowSize != Punkt() )
     {
-        EditorKlient *k = dynamic_cast<EditorKlient *>( klient->getThis() );
-        TextRenderer *zS = new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
-        new AsynchronCall( [this, k, zS, mS]( void ) -> void
-        {
+        EditorKlient* k = dynamic_cast<EditorKlient*>(klient->getThis());
+        TextRenderer* zS = new TextRenderer( dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()) );
+        new AsynchronCall( [this, k, zS, mS]( void ) -> void {
             int ret = k->init();
             if( ret == 2 )
             {
-                std::function< void() > wiederherstellen = [this, k]
-                {
+                std::function< void() > wiederherstellen = [this, k] {
                     status = START;
                     ladeKarte();
                     this->status = INITIALIZED;
                 };
-                std::function< void() > verwerfen = [this, k, zS, mS]
-                {
+                std::function< void() > verwerfen = [this, k, zS, mS] {
                     status = START;
                     if( !k->sitzungVerwerfen() )
                     {
                         Text t = "Fehler beim verwerfen der Sitzung: ";
                         t += k->getLastError();
-                        this->addDialog( new Nachricht( dynamic_cast<TextRenderer *>( zS->getThis() ), uiFactory, t, mS, 0 ) );
+                        this->addDialog( new Nachricht( dynamic_cast<TextRenderer*>(zS->getThis()), uiFactory, t, mS, 0 ) );
                     }
                     ladeKarte();
                     this->status = INITIALIZED;
                 };
-                this->addDialog( new Frage( dynamic_cast<TextRenderer *>( zS->getThis() ), uiFactory, "Es wurde eine alte ungespeicherte Sitzung gefunden. möchtest du sie Wiederherstellen?", "Ja", "Nein", wiederherstellen, verwerfen, verwerfen, mS ) );
+                this->addDialog( new Frage( dynamic_cast<TextRenderer*>(zS->getThis()), uiFactory, "Es wurde eine alte ungespeicherte Sitzung gefunden. möchtest du sie Wiederherstellen?", "Ja", "Nein", wiederherstellen, verwerfen, verwerfen, mS ) );
                 this->status = INITIALIZED;
             }
             else if( ret == 1 )
@@ -144,9 +141,9 @@ void AsteroidsEditor::setSichtbar()
             }
             else
             {
-                Status *st = &status;
+                Status* st = &status;
                 this->status = INITIALIZED;
-                this->addDialog( new Nachricht( dynamic_cast<TextRenderer *>( zS->getThis() ), uiFactory, Text( "Fehler beim Initialisieren: " ) += k->getLastError(), mS, [st]() { *st = EXIT; } ) );
+                this->addDialog( new Nachricht( dynamic_cast<TextRenderer*>(zS->getThis()), uiFactory, Text( "Fehler beim Initialisieren: " ) += k->getLastError(), mS, [st]() { *st = EXIT; } ) );
             }
             zS->release();
             k->release();
@@ -155,10 +152,10 @@ void AsteroidsEditor::setSichtbar()
     rend = 1;
 }
 
-void AsteroidsEditor::doPublicMausEreignis( MausEreignis &me )
+void AsteroidsEditor::doPublicMausEreignis( MausEreignis& me )
 {
     c.lock();
-    for( auto i = dialogs->getIterator(); i && i._; i++ )
+    for( auto i : *dialogs )
         i->doPublicMausEreignis( me );
     bool dialogActive = dialogs->hat( 0 );
     int anz = dialogs->getEintragAnzahl();
@@ -169,14 +166,13 @@ void AsteroidsEditor::doPublicMausEreignis( MausEreignis &me )
         if( i->hatVerlassen() && status == INITIALIZED && !dialogActive && me.id == ME_RLinks )
         {
             status = WARTEND;
-            EditorKlient *k = dynamic_cast<EditorKlient *>( klient->getThis() );
-            TextRenderer *zS = new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
+            EditorKlient* k = dynamic_cast<EditorKlient*>(klient->getThis());
+            TextRenderer* zS = new TextRenderer( dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()) );
             Punkt mS = windowSize;
-            new AsynchronCall( [this, k, zS, mS]( void ) -> void
-            {
+            new AsynchronCall( [this, k, zS, mS]( void ) -> void {
                 if( !k->sitzungBeenden() )
                 {
-                    this->addDialog( new Nachricht( dynamic_cast<TextRenderer *>( zS->getThis() ), uiFactory, Text( "Fehler beim Speichern: " ) += k->getLastError(), mS, 0 ) );
+                    this->addDialog( new Nachricht( dynamic_cast<TextRenderer*>(zS->getThis()), uiFactory, Text( "Fehler beim Speichern: " ) += k->getLastError(), mS, 0 ) );
                     status = INITIALIZED;
                 }
                 else
@@ -191,14 +187,14 @@ void AsteroidsEditor::doPublicMausEreignis( MausEreignis &me )
         if( me.id == ME_PLinks )
         {
             Vertex pos = kamera->getWorldCoordinates( Punkt( me.mx, me.my ) );
-            moveObj = (EditorObject *)daten->zWelt()->zObjectAt( (int)pos.x, (int)pos.y, 1 );
+            moveObj = (EditorObject*)daten->zWelt()->zObjectAt( (int)pos.x, (int)pos.y, 1 );
             if( moveObj )
                 me.verarbeitet = 1;
         }
         if( me.id == ME_PMitte )
         {
             Vertex pos = kamera->getWorldCoordinates( Punkt( me.mx, me.my ) );
-            rotObj = (EditorObject *)daten->zWelt()->zObjectAt( (int)pos.x, (int)pos.y, 1 );
+            rotObj = (EditorObject*)daten->zWelt()->zObjectAt( (int)pos.x, (int)pos.y, 1 );
             if( rotObj )
                 me.verarbeitet = 1;
         }
@@ -212,7 +208,7 @@ void AsteroidsEditor::doPublicMausEreignis( MausEreignis &me )
             }
             if( rotObj )
             {
-                rotObj->addDrehung( ( me.mx - maus.x ) / 100.f );
+                rotObj->addDrehung( (me.mx - maus.x) / 100.f );
                 rend = 1;
                 me.verarbeitet = 1;
             }
@@ -260,10 +256,10 @@ void AsteroidsEditor::doPublicMausEreignis( MausEreignis &me )
     maus.y = me.my;
 }
 
-void AsteroidsEditor::doTastaturEreignis( TastaturEreignis &te )
+void AsteroidsEditor::doTastaturEreignis( TastaturEreignis& te )
 {
     c.lock();
-    for( auto i = dialogs->getIterator(); i && i._; i++ )
+    for( auto i : *dialogs )
         i->doTastaturEreignis( te );
     int anz = dialogs->getEintragAnzahl();
     c.unlock();
@@ -273,7 +269,7 @@ void AsteroidsEditor::doTastaturEreignis( TastaturEreignis &te )
 
 bool AsteroidsEditor::tick( double z )
 {
-    if( ( status == WARTEND || status == START || ( daten && daten->hasAktions() ) ) )
+    if( (status == WARTEND || status == START || (daten && daten->hasAktions())) )
     {
         if( alpha != 100 )
         {
@@ -281,13 +277,13 @@ bool AsteroidsEditor::tick( double z )
                 laden->setSichtbar( 1 );
             if( alpha < 100 )
             {
-                alpha += (unsigned char)( 100 * z );
+                alpha += (unsigned char)(100 * z);
                 if( alpha > 100 )
                     alpha = 100;
             }
             else
             {
-                alpha -= (unsigned char)( 100 * z );
+                alpha -= (unsigned char)(100 * z);
                 if( alpha < 100 )
                     alpha = 100;
             }
@@ -301,7 +297,7 @@ bool AsteroidsEditor::tick( double z )
         if( alpha + 100 * z > 255 )
             alpha = 255;
         else
-            alpha += (unsigned char)( 100 * z );
+            alpha += (unsigned char)(100 * z);
         rend = 1;
     }
     if( laden )
@@ -310,7 +306,7 @@ bool AsteroidsEditor::tick( double z )
     rend |= minimap->tick( z );
     rend |= kamera->tick( z );
     c.lock();
-    for( auto i = dialogs->getIterator(); i && i._; i++ )
+    for( auto i : *dialogs )
         rend |= i->tick( z );
     c.unlock();
     bool tmp = rend;
@@ -318,7 +314,7 @@ bool AsteroidsEditor::tick( double z )
     return tmp;
 }
 
-void AsteroidsEditor::render( Bild &zRObj )
+void AsteroidsEditor::render( Bild& zRObj )
 {
     if( windowSize == Punkt() )
     {

Asteroids/Editor/Interface/Dialogs/ResourceDialog.cpp

@@ -9,7 +9,7 @@ using namespace Editor;
 //  daten: Ein Zeiger auf die Karte, welche alle möglichen resouren enthält
 //  onClose: Eine Funktion die aufgerufen wird, sobald der Dialog geschlossen wird. Es wird der ausgewählte Pfad oder 0 übergeben.
 //  screenSize: Die größe des Bildschirms zum positionieren des dialogs
-ResourceDialog::ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDialogType typ, Editor::KarteDaten *daten, std::function< void( const char *path ) > onClose, Punkt screenSize )
+ResourceDialog::ResourceDialog( TextRenderer* tr, UIInit& uiFactory, ResourceDialogType typ, Editor::KarteDaten* daten, std::function< void( const char* path ) > onClose, Punkt screenSize )
     : Dialog( tr )
 {
     setTitel( "Resource Auswahl" );
@@ -23,31 +23,30 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDia
     m2v->setPosition( 5, 30 );
 
     bv = initBildZ( 5, 30, 390, 390, uiFactory, BildZ::Style::normal & ~Zeichnung::Style::Sichtbar, 0 );
-    addMember( dynamic_cast<BildZ *>( bv->getThis() ) );
-    addMember( dynamic_cast<M2DVorschau *>( m2v->getThis() ) );
+    addMember( dynamic_cast<BildZ*>(bv->getThis()) );
+    addMember( dynamic_cast<M2DVorschau*>(m2v->getThis()) );
 
     paths = initAuswahlBox( 5, 5, 390, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
-    if( ( typ | ALLOW_RESOURCES ) == typ )
+    if( (typ | ALLOW_RESOURCES) == typ )
     {
         int anz = daten->getResourceAnzahl();
         for( int i = 0; i < anz; i++ )
         {
-            ResourceDaten *r = daten->getResource( i );
-            if( r->path.hat( ".ltdb/" ) && ( typ | TEXTUR ) == typ )
+            ResourceDaten* r = daten->getResource( i );
+            if( r->path.hat( ".ltdb/" ) && (typ | TEXTUR) == typ )
                 paths->addEintrag( r->path );
-            if( r->path.hat( ".m2/" ) && ( typ | MODEL2D ) == typ )
+            if( r->path.hat( ".m2/" ) && (typ | MODEL2D) == typ )
                 paths->addEintrag( r->path );
         }
     }
-    if( ( typ | ALLOW_NEW_RESOURCES ) == typ )
+    if( (typ | ALLOW_NEW_RESOURCES) == typ )
     {
-        daten->loadUnusedResourcePaths( [this, typ]( RCArray< Text > *unusedPaths )
-        {
-            for( auto p = unusedPaths->getIterator(); p; p++ )
+        daten->loadUnusedResourcePaths( [this, typ]( RCArray< Text >* unusedPaths ) {
+            for( auto p : *unusedPaths )
             {
-                if( p->hat( ".ltdb/" ) && ( typ | TEXTUR ) == typ )
+                if( p->hat( ".ltdb/" ) && (typ | TEXTUR) == typ )
                     paths->addEintrag( p->getText() );
-                if( p->hat( ".m2/" ) && ( typ | MODEL2D ) == typ )
+                if( p->hat( ".m2/" ) && (typ | MODEL2D) == typ )
                     paths->addEintrag( p->getText() );
             }
             unusedPaths->release();
@@ -71,8 +70,7 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDia
         m2v->removeStyle( Zeichnung::Style::Sichtbar );
         bv->removeStyle( Zeichnung::Style::Sichtbar );
     }
-    paths->setEventAktion( [this]( void *p, AuswahlBox *a, int unused, int auswahl )
-    {
+    paths->setEventAktion( [this]( void* p, AuswahlBox* a, int unused, int auswahl ) {
         Text path = paths->zEintragText( paths->getAuswahl() )->getText();
         if( path.hat( ".ltdb/" ) )
         {
@@ -95,10 +93,9 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDia
         }
     } );
 
-    Knopf *ok = initKnopf( 295, 425, 100, 20, uiFactory, Knopf::Style::Normal, "ok" );
+    Knopf* ok = initKnopf( 295, 425, 100, 20, uiFactory, Knopf::Style::Normal, "ok" );
     addMember( ok );
-    ok->setMausEreignis( [this, onClose]( void *p, void *o, MausEreignis me )
-    {
+    ok->setMausEreignis( [this, onClose]( void* p, void* o, MausEreignis me ) {
         if( me.id == ME_RLinks )
         {
             removeStyle( Fenster::Style::Sichtbar );
@@ -106,10 +103,9 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDia
         }
         return 1;
     } );
-    Knopf *abbrechen = initKnopf( 5, 425, 100, 20, uiFactory, Knopf::Style::Normal, "abbrechen" );
+    Knopf* abbrechen = initKnopf( 5, 425, 100, 20, uiFactory, Knopf::Style::Normal, "abbrechen" );
     addMember( abbrechen );
-    auto abbruchAction = [this, onClose]( void *p, void *o, MausEreignis me )
-    {
+    auto abbruchAction = [this, onClose]( void* p, void* o, MausEreignis me ) {
         if( me.id == ME_RLinks )
         {
             removeStyle( Fenster::Style::Sichtbar );
@@ -119,8 +115,8 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDia
     };
     abbrechen->setMausEreignis( abbruchAction );
     setClosingMe( abbruchAction );
-    bool *verl = &verlassen;
-    addMember( dynamic_cast<AuswahlBox *>( paths->getThis() ) );
+    bool* verl = &verlassen;
+    addMember( dynamic_cast<AuswahlBox*>(paths->getThis()) );
     if( !paths->getEintragAnzahl() )
     {
         removeStyle( Zeichnung::Style::Sichtbar );

Asteroids/Editor/Interface/RightTools/RightTools.cpp

@@ -9,17 +9,16 @@ RightTool::RightTool()
 RightTool::~RightTool()
 {}
 
-void RightTool::renderDialogs( Bild &rObj )
+void RightTool::renderDialogs( Bild& rObj )
 {}
 
 
-RightTools::RightTools( UIInit &uiFactory, Punkt maxSize )
+RightTools::RightTools( UIInit& uiFactory, Punkt maxSize )
     : ZeichnungHintergrund()
 {
     this->maxSize = maxSize;
     toolAuswahl = initAuswahlBox( 5, 5, 290, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
-    toolAuswahl->setEventAktion( [this]( void *, AuswahlBox *, int, int neu )
-    {
+    toolAuswahl->setEventAktion( [this]( void*, AuswahlBox*, int, int neu ) {
         this->selectTool( neu );
     } );
     tools = new RCArray< RightTool >();
@@ -38,7 +37,7 @@ RightTools::~RightTools()
     toolAuswahl->release();
 }
 
-void RightTools::addTool( RightTool *tool, char *name )
+void RightTools::addTool( RightTool* tool, char* name )
 {
     if( !toolAuswahl->getEintragAnzahl() )
         tool->addStyle( Zeichnung::Style::Sichtbar );
@@ -48,7 +47,7 @@ void RightTools::addTool( RightTool *tool, char *name )
     tool->setSize( 290, maxSize.y - 35 );
 }
 
-void RightTools::doPublicMausEreignis( MausEreignis &me )
+void RightTools::doPublicMausEreignis( MausEreignis& me )
 {
     me.mx -= pos.x, me.my -= pos.y;
     toolAuswahl->doPublicMausEreignis( me );
@@ -60,7 +59,7 @@ void RightTools::doPublicMausEreignis( MausEreignis &me )
     me.mx += pos.x, me.my += pos.y;
 }
 
-void RightTools::doTastaturEreignis( TastaturEreignis &te )
+void RightTools::doTastaturEreignis( TastaturEreignis& te )
 {
     toolAuswahl->doTastaturEreignis( te );
     int anz = tools->getEintragAnzahl();
@@ -82,7 +81,7 @@ bool RightTools::tick( double tickVal )
     return ret;
 }
 
-void RightTools::render( Bild &rObj )
+void RightTools::render( Bild& rObj )
 {
     __super::render( rObj );
     if( rObj.setDrawOptions( pos, gr ) )
@@ -105,6 +104,6 @@ void RightTools::render( Bild &rObj )
 void RightTools::selectTool( int index )
 {
     int i = 0;
-    for( auto e = tools->getIterator(); e; e++ )
+    for( auto e : *tools )
         e->setStyle( Zeichnung::Style::Sichtbar, i++ == index );
 }

Asteroids/Editor/Karte/EditorKarte.cpp

@@ -15,7 +15,7 @@ SpielerDaten::SpielerDaten()
     : Model()
 {}
 
-SpielerDaten::SpielerDaten( const SpielerDaten &daten )
+SpielerDaten::SpielerDaten( const SpielerDaten& daten )
 {
     *this = daten;
     views->getThis();
@@ -26,7 +26,7 @@ TeamDaten::TeamDaten()
     : Model()
 {}
 
-TeamDaten::TeamDaten( const TeamDaten &daten )
+TeamDaten::TeamDaten( const TeamDaten& daten )
 {
     *this = daten;
     views->getThis();
@@ -37,7 +37,7 @@ ObjektDaten::ObjektDaten()
     : Model()
 {}
 
-ObjektDaten::ObjektDaten( const ObjektDaten &daten )
+ObjektDaten::ObjektDaten( const ObjektDaten& daten )
 {
     *this = daten;
     views->getThis();
@@ -60,7 +60,7 @@ bool EditorObject::isObjekt( EditorObject::ObjektTyp typ, int id )
 }
 
 
-EdSpieler::EdSpieler( SpielerDaten *model )
+EdSpieler::EdSpieler( SpielerDaten* model )
     : EditorObject( SPIELER, model->id )
 {
     mdl = model;
@@ -77,7 +77,7 @@ void EdSpieler::update()
 }
 
 
-EdObjekt::EdObjekt( ObjektDaten *model )
+EdObjekt::EdObjekt( ObjektDaten* model )
     : EditorObject( OBJEKT, model->id )
 {
     mdl = model;
@@ -100,13 +100,13 @@ UpdateObserver::UpdateObserver( std::function< void() > f )
     this->f = f;
 }
 
-void UpdateObserver::update( Model *m )
+void UpdateObserver::update( Model* m )
 {
     f();
 }
 
 
-KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
+KarteDaten::KarteDaten( EditorKlient* client, SpielerTeamStruktur* sts )
     : Thread()
 {
     HMODULE dll = Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
@@ -114,7 +114,7 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
     welt = new Welt2D();
     welt->setCircular( 1 );
     this->client = client;
-    this->sts = (SpielerTeamStruktur *)sts->getThis();
+    this->sts = (SpielerTeamStruktur*)sts->getThis();
     client->loadMapSize( size );
     client->loadResources( resources );
     client->loadSpieler( spieler );
@@ -122,12 +122,12 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
     client->loadObjekte( objekte );
     welt->setSize( size.x, size.y );
     welt->setSize( 1 );
-    for( auto s = spieler.getIterator(); s; s++ )
+    for( auto s : spieler )
     {
-        Model2DObject *model = new EdSpieler( s._ );
-        Bild *bild;
+        Model2DObject* model = new EdSpieler( s );
+        Bild* bild;
         int fc = sts->spielerFarbe->get( s->id - 1 );
-        for( auto r = resources.getIterator(); r; r++ )
+        for( auto r : resources )
         {
             if( r->id == s->m2d )
                 model->setModel( client->loadModel( r->path ) );
@@ -136,10 +136,10 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
         }
         if( bild )
         {
-            Bild *shb = new Bild();
+            Bild* shb = new Bild();
             shb->neuBild( bild->getBreite(), bild->getHeight(), 0 );
             int maxP = shb->getBreite() * shb->getHeight();
-            int *buffer = bild->getBuffer();
+            int* buffer = bild->getBuffer();
             for( int i = 0; i < maxP; i++ )
             {
                 if( buffer[ i ] )
@@ -148,7 +148,7 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
                     shb->alphaPixelDP2D( i, buffer[ i ] );
                 }
             }
-            Textur2D *textur = new Textur2D();
+            Textur2D* textur = new Textur2D();
             textur->setTexturZ( shb );
             model->setTextur( textur, "ship" );
             bild->release();
@@ -157,31 +157,27 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
         model->setDrehung( (float)s->rot );
         model->setCollision( 0 );
         welt->addObject( model );
-        SpielerDaten *d = s._;
-        d->addView( new UpdateObserver( [this, d]()
-        {
-            aktionen.add( [this, d]()
-            {
+        SpielerDaten* d = s;
+        d->addView( new UpdateObserver( [this, d]() {
+            aktionen.add( [this, d]() {
                 this->client->saveSpieler( d );
             } );
         } ) );
     }
-    for( auto t = teams.getIterator(); t; t++ )
+    for( auto t : teams )
     {
-        TeamDaten *d = t._;
-        d->addView( new UpdateObserver( [this, d]()
-        {
-            aktionen.add( [this, d]()
-            {
+        TeamDaten* d = t;
+        d->addView( new UpdateObserver( [this, d]() {
+            aktionen.add( [this, d]() {
                 this->client->saveTeam( d );
             } );
         } ) );
     }
-    for( auto o = objekte.getIterator(); o; o++ )
+    for( auto o : objekte )
     {
-        Model2DObject *model = new EdObjekt( o._ );
-        Bild *bild;
-        for( auto r = resources.getIterator(); r; r++ )
+        Model2DObject* model = new EdObjekt( o );
+        Bild* bild;
+        for( auto r : resources )
         {
             if( r->id == o->m2d )
                 model->setModel( client->loadModel( r->path ) );
@@ -190,7 +186,7 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
         }
         if( bild )
         {
-            Textur2D *textur = new Textur2D();
+            Textur2D* textur = new Textur2D();
             textur->setTexturZ( bild );
             model->setTextur( textur );
         }
@@ -199,15 +195,13 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
         model->setSize( o->scale );
         model->setCollision( 0 );
         welt->addObject( model );
-        ObjektDaten *d = o._;
-        d->addView( new UpdateObserver( [this, d, model]()
-        {
-            aktionen.add( [this, d, model]()
-            {
+        ObjektDaten* d = o;
+        d->addView( new UpdateObserver( [this, d, model]() {
+            aktionen.add( [this, d, model]() {
                 this->client->saveObjekt( d );
-                Bild *bild = 0;
-                Model2DData *da = 0;
-                for( auto r = resources.getIterator(); r; r++ )
+                Bild* bild = 0;
+                Model2DData* da = 0;
+                for( auto r : resources )
                 {
                     if( r->id == d->m2d )
                         da = this->client->loadModel( r->path );
@@ -216,10 +210,9 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
                 }
                 if( bild && da )
                 {
-                    Textur2D *textur = new Textur2D();
+                    Textur2D* textur = new Textur2D();
                     textur->setTexturZ( bild );
-                    model->postAction( [model, da, textur]()
-                    {
+                    model->postAction( [model, da, textur]() {
                         model->setModel( da );
                         model->setTextur( textur );
                     } );
@@ -241,14 +234,14 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
 KarteDaten::~KarteDaten()
 {
     cs.lock();
-    for( auto i = resources.getIterator(); i; i++ )
-        delete i._;
-    for( auto i = objekte.getIterator(); i; i++ )
-        delete i._;
-    for( auto i = spieler.getIterator(); i; i++ )
-        delete i._;
-    for( auto i = teams.getIterator(); i; i++ )
-        delete i._;
+    for( auto i : resources )
+        delete i;
+    for( auto i : objekte )
+        delete i;
+    for( auto i : spieler )
+        delete i;
+    for( auto i : teams )
+        delete i;
     sts->release();
     client->release();
     welt->release();
@@ -256,9 +249,9 @@ KarteDaten::~KarteDaten()
     cs.unlock();
 }
 
-void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > callBack )
+void KarteDaten::addObjekt( ObjektDaten& daten, std::function< void( int ) > callBack )
 {
-    ObjektDaten *nd = new ObjektDaten( daten );
+    ObjektDaten* nd = new ObjektDaten( daten );
     cs.lock();
     nd->id = 0;
     bool found = 0;
@@ -266,7 +259,7 @@ void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > cal
     {
         nd->id++;
         found = 0;
-        for( auto o = objekte.getIterator(); o; o++ )
+        for( auto o : objekte )
         {
             if( o->id == nd->id )
             {
@@ -276,9 +269,9 @@ void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > cal
         }
     } while( found );
     objekte.add( nd );
-    Model2DObject *model = new EdObjekt( nd );
-    Bild *bild;
-    for( auto r = resources.getIterator(); r; r++ )
+    Model2DObject* model = new EdObjekt( nd );
+    Bild* bild;
+    for( auto r : resources )
     {
         if( r->id == nd->m2d )
             model->setModel( client->loadModel( r->path ) );
@@ -287,7 +280,7 @@ void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > cal
     }
     if( bild )
     {
-        Textur2D *textur = new Textur2D();
+        Textur2D* textur = new Textur2D();
         textur->setTexturZ( bild );
         model->setTextur( textur );
     }
@@ -296,14 +289,12 @@ void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > cal
     model->setSize( nd->scale );
     model->setCollision( 0 );
     welt->addObject( model );
-    nd->addView( new UpdateObserver( [this, nd, model]()
-    {
-        aktionen.add( [this, nd, model]()
-        {
+    nd->addView( new UpdateObserver( [this, nd, model]() {
+        aktionen.add( [this, nd, model]() {
             this->client->saveObjekt( nd );
-            Bild *bild = 0;
-            Model2DData *d = 0;
-            for( auto r = resources.getIterator(); r; r++ )
+            Bild* bild = 0;
+            Model2DData* d = 0;
+            for( auto r : resources )
             {
                 if( r->id == nd->m2d )
                     d = this->client->loadModel( r->path );
@@ -312,10 +303,9 @@ void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > cal
             }
             if( bild && d )
             {
-                Textur2D *textur = new Textur2D();
+                Textur2D* textur = new Textur2D();
                 textur->setTexturZ( bild );
-                model->postAction( [model, d, textur]()
-                {
+                model->postAction( [model, d, textur]() {
                     model->setModel( d );
                     model->setTextur( textur );
                 } );
@@ -329,9 +319,8 @@ void KarteDaten::addObjekt( ObjektDaten &daten, std::function< void( int ) > cal
             }
         } );
     } ) );
-    EditorKlient *c = client;
-    aktionen.add( [nd, c, callBack]()
-    {
+    EditorKlient* c = client;
+    aktionen.add( [nd, c, callBack]() {
         if( c->saveObjekt( nd ) )
             callBack( nd->id );
         else
@@ -344,19 +333,18 @@ void KarteDaten::removeObjekt( int index )
 {
     cs.lock();
     int id = objekte.get( index )->id;
-    EditorObject *obj = 0;
+    EditorObject* obj = 0;
     for( auto o = welt->getMembers(); o; o++ )
     {
-        obj = (EditorObject *)o._;
+        obj = (EditorObject*)o._;
         if( obj->isObjekt( EditorObject::OBJEKT, id ) )
             break;
     }
     welt->removeObject( obj );
     delete objekte.get( index );
     objekte.remove( index );
-    EditorKlient *c = client;
-    aktionen.add( [id, c]()
-    {
+    EditorKlient* c = client;
+    aktionen.add( [id, c]() {
         c->deleteObjekt( id );
     } );
     cs.unlock();
@@ -380,43 +368,43 @@ void KarteDaten::thread()
     }
 }
 
-ResourceDaten *KarteDaten::getResource( int index )
+ResourceDaten* KarteDaten::getResource( int index )
 {
-    ResourceDaten *ret = 0;
+    ResourceDaten* ret = 0;
     cs.lock();
     ret = resources.get( index );
     cs.unlock();
     return ret;
 }
 
-ObjektDaten *KarteDaten::getObjekt( int index )
+ObjektDaten* KarteDaten::getObjekt( int index )
 {
-    ObjektDaten *ret = 0;
+    ObjektDaten* ret = 0;
     cs.lock();
     ret = objekte.get( index );
     cs.unlock();
     return ret;
 }
 
-SpielerDaten *KarteDaten::getSpieler( int index )
+SpielerDaten* KarteDaten::getSpieler( int index )
 {
-    SpielerDaten *ret = 0;
+    SpielerDaten* ret = 0;
     cs.lock();
     ret = spieler.get( index );
     cs.unlock();
     return ret;
 }
 
-TeamDaten *KarteDaten::getTeam( int index )
+TeamDaten* KarteDaten::getTeam( int index )
 {
-    TeamDaten *ret = 0;
+    TeamDaten* ret = 0;
     cs.lock();
     ret = teams.get( index );
     cs.unlock();
     return ret;
 }
 
-const char *KarteDaten::getTeamName( int index )
+const char* KarteDaten::getTeamName( int index )
 {
     return sts->teamName->z( teams.get( index )->id - 1 )->getText();
 }
@@ -425,7 +413,7 @@ int KarteDaten::getSpielerIndexById( int id )
 {
     int index = 0;
     cs.lock();
-    for( auto i = spieler.getIterator(); i; i++ )
+    for( auto i : spieler )
     {
         if( i->id == id )
             break;
@@ -444,7 +432,7 @@ int KarteDaten::getTeamIndexById( int id )
 {
     int index = 0;
     cs.lock();
-    for( auto i = teams.getIterator(); i; i++ )
+    for( auto i : teams )
     {
         if( i->id == id )
             break;
@@ -463,7 +451,7 @@ int KarteDaten::getObjektIndexById( int id )
 {
     int index = 0;
     cs.lock();
-    for( auto i = objekte.getIterator(); i; i++ )
+    for( auto i : objekte )
     {
         if( i->id == id )
             break;
@@ -482,7 +470,7 @@ int KarteDaten::getResourceIndexById( int id )
 {
     int index = 0;
     cs.lock();
-    for( auto i = resources.getIterator(); i; i++ )
+    for( auto i : resources )
     {
         if( i->id == id )
             break;
@@ -502,7 +490,7 @@ bool KarteDaten::hasError() const
     return !error.istGleich( "" );
 }
 
-char *KarteDaten::getError() const
+char* KarteDaten::getError() const
 {
     return error;
 }
@@ -512,19 +500,19 @@ bool KarteDaten::hasAktions() const
     return aktionen.getEintragAnzahl() > 0;
 }
 
-Welt2D *KarteDaten::getWelt() const
+Welt2D* KarteDaten::getWelt() const
 {
-    return dynamic_cast<Welt2D *>( welt->getThis() );
+    return dynamic_cast<Welt2D*>(welt->getThis());
 }
 
-Welt2D *KarteDaten::zWelt() const
+Welt2D* KarteDaten::zWelt() const
 {
     return welt;
 }
 
-void KarteDaten::getResourceIdFromPath( const char *path, std::function< void( int ) > callBack )
+void KarteDaten::getResourceIdFromPath( const char* path, std::function< void( int ) > callBack )
 {
-    for( auto r = resources.getIterator(); r; r++ )
+    for( auto r : resources )
     {
         if( r->path.istGleich( path ) )
         {
@@ -532,15 +520,14 @@ void KarteDaten::getResourceIdFromPath( const char *path, std::function< void( i
             return;
         }
     }
-    aktionen.add( [this, path, callBack]()
-    {
+    aktionen.add( [this, path, callBack]() {
         int id = client->addResource( path );
         if( !id )
         {
             callBack( 0 );
             return;
         }
-        ResourceDaten *nr = new ResourceDaten();
+        ResourceDaten* nr = new ResourceDaten();
         nr->id = id;
         nr->path = path;
         cs.lock();
@@ -550,9 +537,9 @@ void KarteDaten::getResourceIdFromPath( const char *path, std::function< void( i
     } );
 }
 
-bool KarteDaten::doesResourceExist( const char *path )
+bool KarteDaten::doesResourceExist( const char* path )
 {
-    for( auto r = resources.getIterator(); r; r++ )
+    for( auto r : resources )
     {
         if( r->path.istGleich( path ) )
             return 1;
@@ -560,9 +547,9 @@ bool KarteDaten::doesResourceExist( const char *path )
     return 0;
 }
 
-Model2DData *KarteDaten::loadModelFromRessource( int id )
+Model2DData* KarteDaten::loadModelFromRessource( int id )
 {
-    for( auto r = resources.getIterator(); r; r++ )
+    for( auto r : resources )
     {
         if( r->id == id )
             return client->loadModel( r->path );
@@ -570,9 +557,9 @@ Model2DData *KarteDaten::loadModelFromRessource( int id )
     return 0;
 }
 
-Bild *KarteDaten::loadBildFromRessource( int id )
+Bild* KarteDaten::loadBildFromRessource( int id )
 {
-    for( auto r = resources.getIterator(); r; r++ )
+    for( auto r : resources )
     {
         if( r->id == id )
             return client->loadBild( r->path );
@@ -580,28 +567,27 @@ Bild *KarteDaten::loadBildFromRessource( int id )
     return 0;
 }
 
-Model2DData *KarteDaten::loadModelFromPath( const char *path )
+Model2DData* KarteDaten::loadModelFromPath( const char* path )
 {
     return client->loadModel( path );
 }
 
-Bild *KarteDaten::loadBildFromPath( const char *path )
+Bild* KarteDaten::loadBildFromPath( const char* path )
 {
     return client->loadBild( path );
 }
 
-void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text > * ) > callBack )
+void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text >* ) > callBack )
 {
     cs.lock();
-    aktionen.add( [this, callBack]()
-    {
-        RCArray< Text > *result = new RCArray< Text >();
+    aktionen.add( [this, callBack]() {
+        RCArray< Text >* result = new RCArray< Text >();
         loadSpielResourcePathsFromFolder( "data/spiele/Asteroids", result );
-        RCArray< Text > *mapPaths = client->getAllMapResourcePaths();
-        for( auto mp = mapPaths->getIterator(); mp; mp++ )
+        RCArray< Text >* mapPaths = client->getAllMapResourcePaths();
+        for( auto mp : *mapPaths )
         {
             if( !doesResourceExist( mp->getText() ) )
-                result->add( dynamic_cast<Text *>( mp->getThis() ) );
+                result->add( dynamic_cast<Text*>(mp->getThis()) );
         }
         mapPaths->release();
         callBack( result );
@@ -609,17 +595,17 @@ void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text > *
     cs.unlock();
 }
 
-void KarteDaten::loadSpielResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths )
+void KarteDaten::loadSpielResourcePathsFromFolder( const char* folderPath, RCArray< Text >* zPaths )
 {
     Datei f;
     f.setDatei( folderPath );
     if( f.istOrdner() )
     {
-        RCArray< Text > *list = f.getDateiListe();
-        for( auto n = list->getIterator(); n; n++ )
+        RCArray< Text >* list = f.getDateiListe();
+        for( auto n : *list )
         {
             Text path( folderPath );
-            path += Text( "/" ) + (const char *)n->getText();
+            path += Text( "/" ) + (const char*)n->getText();
             loadSpielResourcePathsFromFolder( path, zPaths );
         }
         list->release();
@@ -634,9 +620,9 @@ void KarteDaten::loadSpielResourcePathsFromFolder( const char *folderPath, RCArr
             int anz = d.getBildAnzahl();
             for( int i = 0; i < anz; i++ )
             {
-                Text *path = new Text( folderPath );
+                Text* path = new Text( folderPath );
                 path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
-                path->append( (const char *)( Text( "/" ) + (const char *)d.zBildListe()->z( i )->getText() ) );
+                path->append( (const char*)(Text( "/" ) + (const char*)d.zBildListe()->z( i )->getText()) );
                 if( doesResourceExist( path->getText() ) )
                     path->release();
                 else
@@ -651,9 +637,9 @@ void KarteDaten::loadSpielResourcePathsFromFolder( const char *folderPath, RCArr
             int anz = d.getModelAnzahl();
             for( int i = 0; i < anz; i++ )
             {
-                Text *path = new Text( folderPath );
+                Text* path = new Text( folderPath );
                 path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
-                path->append( (const char *)( Text( "/" ) + (const char *)d.zModelName( i )->getText() ) );
+                path->append( (const char*)(Text( "/" ) + (const char*)d.zModelName( i )->getText()) );
                 if( doesResourceExist( path->getText() ) )
                     path->release();
                 else
@@ -663,16 +649,16 @@ void KarteDaten::loadSpielResourcePathsFromFolder( const char *folderPath, RCArr
         if( f.zPfad()->hat( ".gsl" ) )
         {
             HMODULE dll = Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
-            GSL::GSLDateiV *d = getGSLDatei();
-            d->setDatei( (char *)folderPath );
+            GSL::GSLDateiV* d = getGSLDatei();
+            d->setDatei( (char*)folderPath );
             d->leseDaten();
             int anz = d->getSoundAnzahl();
             for( int i = 0; i < anz; i++ )
             {
-                Text *path = new Text( folderPath );
+                Text* path = new Text( folderPath );
                 path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
-                Text *name = d->getSoundName( i );
-                path->append( (const char *)( Text( "/" ) + (const char *)name->getText() ) );
+                Text* name = d->getSoundName( i );
+                path->append( (const char*)(Text( "/" ) + (const char*)name->getText()) );
                 name->release();
                 if( doesResourceExist( path->getText() ) )
                     path->release();

Asteroids/Editor/Netzwerk/EditorKlient.cpp

@@ -26,13 +26,13 @@ SpielerTeamStruktur::~SpielerTeamStruktur()
     teamSize->release();
 }
 
-SpielerTeamStrukturV *SpielerTeamStruktur::getThis()
+SpielerTeamStrukturV* SpielerTeamStruktur::getThis()
 {
     ref++;
     return this;
 }
 
-SpielerTeamStrukturV *SpielerTeamStruktur::release()
+SpielerTeamStrukturV* SpielerTeamStruktur::release()
 {
     ref--;
     if( !ref )
@@ -44,7 +44,7 @@ SpielerTeamStrukturV *SpielerTeamStruktur::release()
 // Inhalt der EditorKlient Klasse aus EditorKlient.h
 // Konstruktor
 //  k: Der zu verwendende Klient
-EditorKlient::EditorKlient( KSGClient::EditorServerClient *k )
+EditorKlient::EditorKlient( KSGClient::EditorServerClient* k )
     : ReferenceCounter()
 {
     klient = k;
@@ -62,7 +62,7 @@ EditorKlient::~EditorKlient()
 //          0, sonnst
 int EditorKlient::init()
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -77,8 +77,8 @@ int EditorKlient::init()
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -92,7 +92,7 @@ int EditorKlient::init()
 // Verwirft die vorhandene Sitzung und erstellt eine neue
 bool EditorKlient::sitzungVerwerfen()
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -105,8 +105,8 @@ bool EditorKlient::sitzungVerwerfen()
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -120,7 +120,7 @@ bool EditorKlient::sitzungVerwerfen()
 // Speichert Sitzung und beendet Editor
 bool EditorKlient::sitzungBeenden()
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -133,8 +133,8 @@ bool EditorKlient::sitzungBeenden()
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -145,9 +145,9 @@ bool EditorKlient::sitzungBeenden()
     return ret == 1;
 }
 
-bool EditorKlient::saveTeam( const TeamDaten *team )
+bool EditorKlient::saveTeam( const TeamDaten* team )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -159,28 +159,28 @@ bool EditorKlient::saveTeam( const TeamDaten *team )
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->sendeEncrypted( (char *)&team->id, 4 );
-        k->sendeEncrypted( (char *)&team->maxPunkte, 4 );
-        k->sendeEncrypted( (char *)&team->beschleunigung, 8 );
-        k->sendeEncrypted( (char *)&team->maxStabilität, 4 );
-        k->sendeEncrypted( (char *)&team->maxEnergie, 4 );
-        k->sendeEncrypted( (char *)&team->reparatur, 8 );
-        k->sendeEncrypted( (char *)&team->akkuLeistung, 8 );
-        k->sendeEncrypted( (char *)&team->laserIntensität, 4 );
-        k->sendeEncrypted( (char *)&team->laserEffizienz, 4 );
-        k->sendeEncrypted( (char *)&team->laserTempo, 4 );
-        k->sendeEncrypted( (char *)&team->wendigkeit, 8 );
-        k->sendeEncrypted( (char *)&team->antriebEffizienz, 8 );
-        k->sendeEncrypted( (char *)&team->energieSchild, 8 );
-        k->sendeEncrypted( (char *)&team->energieSchildEffizienz, 8 );
-        k->sendeEncrypted( (char *)&team->punkte, 4 );
+        k->sendeEncrypted( (char*)&team->id, 4 );
+        k->sendeEncrypted( (char*)&team->maxPunkte, 4 );
+        k->sendeEncrypted( (char*)&team->beschleunigung, 8 );
+        k->sendeEncrypted( (char*)&team->maxStabilität, 4 );
+        k->sendeEncrypted( (char*)&team->maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&team->reparatur, 8 );
+        k->sendeEncrypted( (char*)&team->akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&team->laserIntensität, 4 );
+        k->sendeEncrypted( (char*)&team->laserEffizienz, 4 );
+        k->sendeEncrypted( (char*)&team->laserTempo, 4 );
+        k->sendeEncrypted( (char*)&team->wendigkeit, 8 );
+        k->sendeEncrypted( (char*)&team->antriebEffizienz, 8 );
+        k->sendeEncrypted( (char*)&team->energieSchild, 8 );
+        k->sendeEncrypted( (char*)&team->energieSchildEffizienz, 8 );
+        k->sendeEncrypted( (char*)&team->punkte, 4 );
         k->getNachrichtEncrypted( &ret, 1 );
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -191,9 +191,9 @@ bool EditorKlient::saveTeam( const TeamDaten *team )
     return ret == 1;
 }
 
-bool EditorKlient::saveSpieler( const SpielerDaten *spieler )
+bool EditorKlient::saveSpieler( const SpielerDaten* spieler )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -205,33 +205,33 @@ bool EditorKlient::saveSpieler( const SpielerDaten *spieler )
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->sendeEncrypted( (char *)&spieler->id, 4 );
-        k->sendeEncrypted( (char *)&spieler->pos.x, 4 );
-        k->sendeEncrypted( (char *)&spieler->pos.y, 4 );
-        k->sendeEncrypted( (char *)&spieler->rot, 8 );
-        k->sendeEncrypted( (char *)&spieler->beschleunigung, 8 );
-        k->sendeEncrypted( (char *)&spieler->maxStabilität, 4 );
-        k->sendeEncrypted( (char *)&spieler->maxEnergie, 4 );
-        k->sendeEncrypted( (char *)&spieler->reparatur, 8 );
-        k->sendeEncrypted( (char *)&spieler->akkuLeistung, 8 );
-        k->sendeEncrypted( (char *)&spieler->laserIntensität, 4 );
-        k->sendeEncrypted( (char *)&spieler->laserEffizienz, 4 );
-        k->sendeEncrypted( (char *)&spieler->laserTempo, 4 );
-        k->sendeEncrypted( (char *)&spieler->wendigkeit, 8 );
-        k->sendeEncrypted( (char *)&spieler->antriebEffizienz, 8 );
-        k->sendeEncrypted( (char *)&spieler->energieSchild, 8 );
-        k->sendeEncrypted( (char *)&spieler->energieSchildEffizienz, 8 );
-        k->sendeEncrypted( (char *)&spieler->netzwerk, 4 );
-        k->sendeEncrypted( (char *)&spieler->skillPunkte, 4 );
-        k->sendeEncrypted( (char *)&spieler->m2d, 4 );
-        k->sendeEncrypted( (char *)&spieler->bild, 4 );
+        k->sendeEncrypted( (char*)&spieler->id, 4 );
+        k->sendeEncrypted( (char*)&spieler->pos.x, 4 );
+        k->sendeEncrypted( (char*)&spieler->pos.y, 4 );
+        k->sendeEncrypted( (char*)&spieler->rot, 8 );
+        k->sendeEncrypted( (char*)&spieler->beschleunigung, 8 );
+        k->sendeEncrypted( (char*)&spieler->maxStabilität, 4 );
+        k->sendeEncrypted( (char*)&spieler->maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&spieler->reparatur, 8 );
+        k->sendeEncrypted( (char*)&spieler->akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&spieler->laserIntensität, 4 );
+        k->sendeEncrypted( (char*)&spieler->laserEffizienz, 4 );
+        k->sendeEncrypted( (char*)&spieler->laserTempo, 4 );
+        k->sendeEncrypted( (char*)&spieler->wendigkeit, 8 );
+        k->sendeEncrypted( (char*)&spieler->antriebEffizienz, 8 );
+        k->sendeEncrypted( (char*)&spieler->energieSchild, 8 );
+        k->sendeEncrypted( (char*)&spieler->energieSchildEffizienz, 8 );
+        k->sendeEncrypted( (char*)&spieler->netzwerk, 4 );
+        k->sendeEncrypted( (char*)&spieler->skillPunkte, 4 );
+        k->sendeEncrypted( (char*)&spieler->m2d, 4 );
+        k->sendeEncrypted( (char*)&spieler->bild, 4 );
         k->getNachrichtEncrypted( &ret, 1 );
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -242,9 +242,9 @@ bool EditorKlient::saveSpieler( const SpielerDaten *spieler )
     return ret == 1;
 }
 
-bool EditorKlient::saveObjekt( const ObjektDaten *objekt )
+bool EditorKlient::saveObjekt( const ObjektDaten* objekt )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -256,27 +256,27 @@ bool EditorKlient::saveObjekt( const ObjektDaten *objekt )
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->sendeEncrypted( (char *)&objekt->pos.x, 4 );
-        k->sendeEncrypted( (char *)&objekt->pos.y, 4 );
-        k->sendeEncrypted( (char *)&objekt->rot, 4 );
-        k->sendeEncrypted( (char *)&objekt->scale, 4 );
-        k->sendeEncrypted( (char *)&objekt->id, 4 );
-        k->sendeEncrypted( (char *)&objekt->m2d, 4 );
-        k->sendeEncrypted( (char *)&objekt->bild, 4 );
-        k->sendeEncrypted( (char *)&objekt->style, 4 );
-        k->sendeEncrypted( (char *)&objekt->maxStabilität, 4 );
-        k->sendeEncrypted( (char *)&objekt->maxEnergie, 4 );
-        k->sendeEncrypted( (char *)&objekt->energieRadius, 4 );
-        k->sendeEncrypted( (char *)&objekt->reparatur, 8 );
-        k->sendeEncrypted( (char *)&objekt->akkuLeistung, 8 );
-        k->sendeEncrypted( (char *)&objekt->team, 1 );
+        k->sendeEncrypted( (char*)&objekt->pos.x, 4 );
+        k->sendeEncrypted( (char*)&objekt->pos.y, 4 );
+        k->sendeEncrypted( (char*)&objekt->rot, 4 );
+        k->sendeEncrypted( (char*)&objekt->scale, 4 );
+        k->sendeEncrypted( (char*)&objekt->id, 4 );
+        k->sendeEncrypted( (char*)&objekt->m2d, 4 );
+        k->sendeEncrypted( (char*)&objekt->bild, 4 );
+        k->sendeEncrypted( (char*)&objekt->style, 4 );
+        k->sendeEncrypted( (char*)&objekt->maxStabilität, 4 );
+        k->sendeEncrypted( (char*)&objekt->maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&objekt->energieRadius, 4 );
+        k->sendeEncrypted( (char*)&objekt->reparatur, 8 );
+        k->sendeEncrypted( (char*)&objekt->akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&objekt->team, 1 );
         k->getNachrichtEncrypted( &ret, 1 );
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -289,7 +289,7 @@ bool EditorKlient::saveObjekt( const ObjektDaten *objekt )
 
 bool EditorKlient::deleteObjekt( int id )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -301,14 +301,14 @@ bool EditorKlient::deleteObjekt( int id )
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->sendeEncrypted( (char *)&id, 4 );
+        k->sendeEncrypted( (char*)&id, 4 );
         k->getNachrichtEncrypted( &ret, 1 );
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -319,9 +319,9 @@ bool EditorKlient::deleteObjekt( int id )
     return ret == 1;
 }
 
-bool EditorKlient::loadResources( Array< ResourceDaten * > &resources )
+bool EditorKlient::loadResources( Array< ResourceDaten* >& resources )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -334,14 +334,14 @@ bool EditorKlient::loadResources( Array< ResourceDaten * > &resources )
     if( ret == 1 )
     {
         int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
-            ResourceDaten *resource = new ResourceDaten();
-            k->getNachrichtEncrypted( (char *)&resource->id, 4 );
+            ResourceDaten* resource = new ResourceDaten();
+            k->getNachrichtEncrypted( (char*)&resource->id, 4 );
             char len = 0;
-            k->getNachrichtEncrypted( (char *)&len, 1 );
-            char *path = new char[ len + 1 ];
+            k->getNachrichtEncrypted( (char*)&len, 1 );
+            char* path = new char[ len + 1 ];
             path[ len ] = 0;
             k->getNachrichtEncrypted( path, len );
             resource->path = path;
@@ -352,8 +352,8 @@ bool EditorKlient::loadResources( Array< ResourceDaten * > &resources )
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -364,9 +364,9 @@ bool EditorKlient::loadResources( Array< ResourceDaten * > &resources )
     return ret == 1;
 }
 
-int EditorKlient::addResource( const char *path )
+int EditorKlient::addResource( const char* path )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -379,13 +379,13 @@ int EditorKlient::addResource( const char *path )
     if( ret == 1 )
     {
         unsigned char len = (unsigned char)strlen( path );
-        k->sendeEncrypted( (char *)&len, 1 );
+        k->sendeEncrypted( (char*)&len, 1 );
         k->sendeEncrypted( path, len );
         k->getNachrichtEncrypted( &ret, 1 );
         if( ret == 1 )
         {
             int id = 0;
-            k->getNachrichtEncrypted( (char *)&id, 4 );
+            k->getNachrichtEncrypted( (char*)&id, 4 );
             klient->endEditorMessage();
             return id;
         }
@@ -393,8 +393,8 @@ int EditorKlient::addResource( const char *path )
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -405,9 +405,9 @@ int EditorKlient::addResource( const char *path )
     return 0;
 }
 
-bool EditorKlient::loadSpieler( Array< SpielerDaten * > &spieler )
+bool EditorKlient::loadSpieler( Array< SpielerDaten* >& spieler )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -420,38 +420,38 @@ bool EditorKlient::loadSpieler( Array< SpielerDaten * > &spieler )
     if( ret == 1 )
     {
         int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
-            SpielerDaten *player = new SpielerDaten();
-            k->getNachrichtEncrypted( (char *)&player->id, 4 );
-            k->getNachrichtEncrypted( (char *)&player->pos.x, 4 );
-            k->getNachrichtEncrypted( (char *)&player->pos.y, 4 );
-            k->getNachrichtEncrypted( (char *)&player->rot, 8 );
-            k->getNachrichtEncrypted( (char *)&player->beschleunigung, 8 );
-            k->getNachrichtEncrypted( (char *)&player->maxStabilität, 4 );
-            k->getNachrichtEncrypted( (char *)&player->maxEnergie, 4 );
-            k->getNachrichtEncrypted( (char *)&player->reparatur, 8 );
-            k->getNachrichtEncrypted( (char *)&player->akkuLeistung, 8 );
-            k->getNachrichtEncrypted( (char *)&player->laserIntensität, 4 );
-            k->getNachrichtEncrypted( (char *)&player->laserEffizienz, 4 );
-            k->getNachrichtEncrypted( (char *)&player->laserTempo, 4 );
-            k->getNachrichtEncrypted( (char *)&player->wendigkeit, 8 );
-            k->getNachrichtEncrypted( (char *)&player->antriebEffizienz, 8 );
-            k->getNachrichtEncrypted( (char *)&player->energieSchild, 8 );
-            k->getNachrichtEncrypted( (char *)&player->energieSchildEffizienz, 8 );
-            k->getNachrichtEncrypted( (char *)&player->netzwerk, 4 );
-            k->getNachrichtEncrypted( (char *)&player->skillPunkte, 4 );
-            k->getNachrichtEncrypted( (char *)&player->m2d, 4 );
-            k->getNachrichtEncrypted( (char *)&player->bild, 4 );
+            SpielerDaten* player = new SpielerDaten();
+            k->getNachrichtEncrypted( (char*)&player->id, 4 );
+            k->getNachrichtEncrypted( (char*)&player->pos.x, 4 );
+            k->getNachrichtEncrypted( (char*)&player->pos.y, 4 );
+            k->getNachrichtEncrypted( (char*)&player->rot, 8 );
+            k->getNachrichtEncrypted( (char*)&player->beschleunigung, 8 );
+            k->getNachrichtEncrypted( (char*)&player->maxStabilität, 4 );
+            k->getNachrichtEncrypted( (char*)&player->maxEnergie, 4 );
+            k->getNachrichtEncrypted( (char*)&player->reparatur, 8 );
+            k->getNachrichtEncrypted( (char*)&player->akkuLeistung, 8 );
+            k->getNachrichtEncrypted( (char*)&player->laserIntensität, 4 );
+            k->getNachrichtEncrypted( (char*)&player->laserEffizienz, 4 );
+            k->getNachrichtEncrypted( (char*)&player->laserTempo, 4 );
+            k->getNachrichtEncrypted( (char*)&player->wendigkeit, 8 );
+            k->getNachrichtEncrypted( (char*)&player->antriebEffizienz, 8 );
+            k->getNachrichtEncrypted( (char*)&player->energieSchild, 8 );
+            k->getNachrichtEncrypted( (char*)&player->energieSchildEffizienz, 8 );
+            k->getNachrichtEncrypted( (char*)&player->netzwerk, 4 );
+            k->getNachrichtEncrypted( (char*)&player->skillPunkte, 4 );
+            k->getNachrichtEncrypted( (char*)&player->m2d, 4 );
+            k->getNachrichtEncrypted( (char*)&player->bild, 4 );
             spieler.add( player );
         }
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -462,9 +462,9 @@ bool EditorKlient::loadSpieler( Array< SpielerDaten * > &spieler )
     return ret == 1;
 }
 
-bool EditorKlient::loadTeams( Array< TeamDaten * > &teams )
+bool EditorKlient::loadTeams( Array< TeamDaten* >& teams )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -477,33 +477,33 @@ bool EditorKlient::loadTeams( Array< TeamDaten * > &teams )
     if( ret == 1 )
     {
         int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
-            TeamDaten *team = new TeamDaten();
-            k->getNachrichtEncrypted( (char *)&team->id, 4 );
-            k->getNachrichtEncrypted( (char *)&team->maxPunkte, 4 );
-            k->getNachrichtEncrypted( (char *)&team->beschleunigung, 8 );
-            k->getNachrichtEncrypted( (char *)&team->maxStabilität, 4 );
-            k->getNachrichtEncrypted( (char *)&team->maxEnergie, 4 );
-            k->getNachrichtEncrypted( (char *)&team->reparatur, 8 );
-            k->getNachrichtEncrypted( (char *)&team->akkuLeistung, 8 );
-            k->getNachrichtEncrypted( (char *)&team->laserIntensität, 4 );
-            k->getNachrichtEncrypted( (char *)&team->laserEffizienz, 4 );
-            k->getNachrichtEncrypted( (char *)&team->laserTempo, 4 );
-            k->getNachrichtEncrypted( (char *)&team->wendigkeit, 8 );
-            k->getNachrichtEncrypted( (char *)&team->antriebEffizienz, 8 );
-            k->getNachrichtEncrypted( (char *)&team->energieSchild, 8 );
-            k->getNachrichtEncrypted( (char *)&team->energieSchildEffizienz, 8 );
-            k->getNachrichtEncrypted( (char *)&team->punkte, 4 );
+            TeamDaten* team = new TeamDaten();
+            k->getNachrichtEncrypted( (char*)&team->id, 4 );
+            k->getNachrichtEncrypted( (char*)&team->maxPunkte, 4 );
+            k->getNachrichtEncrypted( (char*)&team->beschleunigung, 8 );
+            k->getNachrichtEncrypted( (char*)&team->maxStabilität, 4 );
+            k->getNachrichtEncrypted( (char*)&team->maxEnergie, 4 );
+            k->getNachrichtEncrypted( (char*)&team->reparatur, 8 );
+            k->getNachrichtEncrypted( (char*)&team->akkuLeistung, 8 );
+            k->getNachrichtEncrypted( (char*)&team->laserIntensität, 4 );
+            k->getNachrichtEncrypted( (char*)&team->laserEffizienz, 4 );
+            k->getNachrichtEncrypted( (char*)&team->laserTempo, 4 );
+            k->getNachrichtEncrypted( (char*)&team->wendigkeit, 8 );
+            k->getNachrichtEncrypted( (char*)&team->antriebEffizienz, 8 );
+            k->getNachrichtEncrypted( (char*)&team->energieSchild, 8 );
+            k->getNachrichtEncrypted( (char*)&team->energieSchildEffizienz, 8 );
+            k->getNachrichtEncrypted( (char*)&team->punkte, 4 );
             teams.add( team );
         }
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -514,9 +514,9 @@ bool EditorKlient::loadTeams( Array< TeamDaten * > &teams )
     return ret == 1;
 }
 
-bool EditorKlient::loadObjekte( Array< ObjektDaten * > &objekte )
+bool EditorKlient::loadObjekte( Array< ObjektDaten* >& objekte )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -529,32 +529,32 @@ bool EditorKlient::loadObjekte( Array< ObjektDaten * > &objekte )
     if( ret == 1 )
     {
         int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
         for( int i = 0; i < anz; i++ )
         {
-            ObjektDaten *objekt = new ObjektDaten();
-            k->getNachrichtEncrypted( (char *)&objekt->pos.x, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->pos.y, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->rot, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->scale, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->id, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->m2d, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->bild, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->style, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->maxStabilität, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->maxEnergie, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->energieRadius, 4 );
-            k->getNachrichtEncrypted( (char *)&objekt->reparatur, 8 );
-            k->getNachrichtEncrypted( (char *)&objekt->akkuLeistung, 8 );
-            k->getNachrichtEncrypted( (char *)&objekt->team, 1 );
+            ObjektDaten* objekt = new ObjektDaten();
+            k->getNachrichtEncrypted( (char*)&objekt->pos.x, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->pos.y, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->rot, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->scale, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->id, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->m2d, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->bild, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->style, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->maxStabilität, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->maxEnergie, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->energieRadius, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->reparatur, 8 );
+            k->getNachrichtEncrypted( (char*)&objekt->akkuLeistung, 8 );
+            k->getNachrichtEncrypted( (char*)&objekt->team, 1 );
             objekte.add( objekt );
         }
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -565,7 +565,7 @@ bool EditorKlient::loadObjekte( Array< ObjektDaten * > &objekte )
     return ret == 1;
 }
 
-Bild *EditorKlient::loadBild( const char *templatePath )
+Bild* EditorKlient::loadBild( const char* templatePath )
 {
     Text txt( templatePath );
     Text pfad;
@@ -592,14 +592,14 @@ Bild *EditorKlient::loadBild( const char *templatePath )
             {
                 while( pfad.anzahlVon( "/" ) > 1 )
                 {
-                    Text *name = pfad.getTeilText( 0, pfad.positionVon( "/" ) );
+                    Text* name = pfad.getTeilText( 0, pfad.positionVon( "/" ) );
                     klient->deOrdnerÖffnen( name );
                     pfad.remove( 0, name->getLength() + 1 );
                     name->release();
                 }
-                Text *datei = pfad.getTeilText( 0, pfad.positionVon( ".ltdb/" ) + 5 );
-                Text *bild = pfad.getTeilText( pfad.positionVon( ".ltdb/" ) + 6 );
-                Bild *res = klient->deBildLaden( datei, bild, 0 );
+                Text* datei = pfad.getTeilText( 0, pfad.positionVon( ".ltdb/" ) + 5 );
+                Text* bild = pfad.getTeilText( pfad.positionVon( ".ltdb/" ) + 6 );
+                Bild* res = klient->deBildLaden( datei, bild, 0 );
                 datei->release();
                 bild->release();
                 cs.unlock();
@@ -612,7 +612,7 @@ Bild *EditorKlient::loadBild( const char *templatePath )
     return 0;
 }
 
-Model2DData *EditorKlient::loadModel( const char *templatePath )
+Model2DData* EditorKlient::loadModel( const char* templatePath )
 {
     Text txt( templatePath );
     Text pfad;
@@ -624,7 +624,7 @@ Model2DData *EditorKlient::loadModel( const char *templatePath )
         {
             int pos = pfad.positionVon( ".m2/", pfad.anzahlVon( ".m2/" ) - 1 );
             M2Datei datei;
-            Text *file = pfad.getTeilText( 0, pos + 3 );
+            Text* file = pfad.getTeilText( 0, pos + 3 );
             datei.setPfad( file->getText() );
             file->release();
             datei.leseDaten();
@@ -641,14 +641,14 @@ Model2DData *EditorKlient::loadModel( const char *templatePath )
             {
                 while( pfad.anzahlVon( "/" ) > 1 )
                 {
-                    Text *name = pfad.getTeilText( 0, pfad.positionVon( "/" ) );
+                    Text* name = pfad.getTeilText( 0, pfad.positionVon( "/" ) );
                     klient->deOrdnerÖffnen( name );
                     pfad.remove( 0, name->getLength() + 1 );
                     name->release();
                 }
-                Text *datei = pfad.getTeilText( 0, pfad.positionVon( ".m2/" ) + 3 );
-                Text *model = pfad.getTeilText( pfad.positionVon( ".m2/" ) + 4 );
-                Model2DData *res = klient->deModelLaden( datei, model, 0 );
+                Text* datei = pfad.getTeilText( 0, pfad.positionVon( ".m2/" ) + 3 );
+                Text* model = pfad.getTeilText( pfad.positionVon( ".m2/" ) + 4 );
+                Model2DData* res = klient->deModelLaden( datei, model, 0 );
                 datei->release();
                 model->release();
                 cs.unlock();
@@ -661,24 +661,24 @@ Model2DData *EditorKlient::loadModel( const char *templatePath )
     return 0;
 }
 
-RCArray< Text > *EditorKlient::getAllMapResourcePaths()
+RCArray< Text >* EditorKlient::getAllMapResourcePaths()
 {
     cs.lock();
     klient->deResetPath();
-    RCArray< Text > *result = new RCArray< Text >();
+    RCArray< Text >* result = new RCArray< Text >();
     loadMapResourcePathsFromFolder( "map:", result );
     cs.unlock();
     return result;
 }
 
-void EditorKlient::loadMapResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths )
+void EditorKlient::loadMapResourcePathsFromFolder( const char* folderPath, RCArray< Text >* zPaths )
 {
-    RCArray< Text > *files = new RCArray< Text >();
+    RCArray< Text >* files = new RCArray< Text >();
     klient->deGetDateiListe( files );
-    for( auto f = files->getIterator(); f; f++ )
+    for( auto f : *files )
     {
         Text path( folderPath );
-        path += Text( "/" ) + *f._;
+        path += Text( "/" ) + *f;
         if( !f->hat( "." ) )
         {
             klient->deOrdnerÖffnen( f );
@@ -688,26 +688,26 @@ void EditorKlient::loadMapResourcePathsFromFolder( const char *folderPath, RCArr
         }
         else if( f->hat( ".ltdb" ) )
         {
-            RCArray< Text > *bilder = new RCArray< Text >();
+            RCArray< Text >* bilder = new RCArray< Text >();
             klient->deGetBildListe( f, bilder );
-            for( auto n = bilder->getIterator(); n; n++ )
-                zPaths->add( new Text( path + "/" + *n._ ) );
+            for( auto n : *bilder )
+                zPaths->add( new Text( path + "/" + *n ) );
             bilder->release();
         }
         else if( f->hat( ".m2" ) )
         {
-            RCArray< Text > *models = new RCArray< Text >();
+            RCArray< Text >* models = new RCArray< Text >();
             klient->deGetModelListe( f, models );
-            for( auto n = models->getIterator(); n; n++ )
-                zPaths->add( new Text( path + "/" + *n._ ) );
+            for( auto n : *models )
+                zPaths->add( new Text( path + "/" + *n ) );
             models->release();
         }
         else if( f->hat( ".gsl" ) )
         {
-            RCArray< Text > *sounds = new RCArray< Text >();
+            RCArray< Text >* sounds = new RCArray< Text >();
             klient->deGetSoundListe( f, sounds );
-            for( auto n = sounds->getIterator(); n; n++ )
-                zPaths->add( new Text( path + "/" + *n._ ) );
+            for( auto n : *sounds )
+                zPaths->add( new Text( path + "/" + *n ) );
             sounds->release();
         }
     }
@@ -715,14 +715,14 @@ void EditorKlient::loadMapResourcePathsFromFolder( const char *folderPath, RCArr
 }
 
 // Lädt die Spieler Team Struktur
-bool EditorKlient::getSpielerTeamStruktur( SpielerTeamStrukturV *sts )
+bool EditorKlient::getSpielerTeamStruktur( SpielerTeamStrukturV* sts )
 {
     return klient->ladeTeamDaten( sts );
 }
 
-bool EditorKlient::loadMapSize( Punkt &size )
+bool EditorKlient::loadMapSize( Punkt& size )
 {
-    Network::Klient *k = klient->beginEditorMessage();
+    Network::Klient* k = klient->beginEditorMessage();
     if( !k )
     {
         error = klient->getLetzterFehler();
@@ -734,14 +734,14 @@ bool EditorKlient::loadMapSize( Punkt &size )
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->getNachrichtEncrypted( (char *)&size.x, 4 );
-        k->getNachrichtEncrypted( (char *)&size.y, 4 );
+        k->getNachrichtEncrypted( (char*)&size.x, 4 );
+        k->getNachrichtEncrypted( (char*)&size.y, 4 );
     }
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *err = new char[ l + 1 ];
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char* err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
         error = err;
@@ -753,7 +753,7 @@ bool EditorKlient::loadMapSize( Punkt &size )
 }
 
 // Gibt den Letzten Fehler zurück
-char *EditorKlient::getLastError() const
+char* EditorKlient::getLastError() const
 {
     return error;
 }

Asteroids/Spiel/Karte/Karte.cpp

@@ -33,22 +33,22 @@ Karte::~Karte()
 }
 
 // nicht constant
-void Karte::ladeSts( Datei *zDatei )
+void Karte::ladeSts( Datei* zDatei )
 {
-    zDatei->lese( (char *)&spielerAnzahl, 4 );
-    zDatei->lese( (char *)&teamAnzahl, 4 );
+    zDatei->lese( (char*)&spielerAnzahl, 4 );
+    zDatei->lese( (char*)&teamAnzahl, 4 );
     spielerFarbe->leeren();
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         int farbe = 0;
-        zDatei->lese( (char *)&farbe, 4 );
+        zDatei->lese( (char*)&farbe, 4 );
         spielerFarbe->set( farbe, i );
     }
     teamFarbe->leeren();
     for( int i = 0; i < teamAnzahl; i++ )
     {
         int farbe = 0;
-        zDatei->lese( (char *)&farbe, 4 );
+        zDatei->lese( (char*)&farbe, 4 );
         teamFarbe->set( farbe, i );
     }
     teamName->leeren();
@@ -56,10 +56,10 @@ void Karte::ladeSts( Datei *zDatei )
     {
         char län = 0;
         zDatei->lese( &län, 1 );
-        char *txt = new char[ län + 1 ];
+        char* txt = new char[ län + 1 ];
         txt[ (int)län ] = 0;
         zDatei->lese( txt, län );
-        Text *name = new Text( txt );
+        Text* name = new Text( txt );
         delete[] txt;
         teamName->set( name, i );
     }
@@ -67,38 +67,38 @@ void Karte::ladeSts( Datei *zDatei )
     for( int i = 0; i < teamAnzahl; i++ )
     {
         int größe = 0;
-        zDatei->lese( (char *)&größe, 4 );
+        zDatei->lese( (char*)&größe, 4 );
         teamGröße->set( größe, i );
     }
 }
 
-void Karte::ladeMap( Datei *zDatei, int mapId, KSGClient::SpielServerClient *zSpielKlient, Text *zGamePath )
+void Karte::ladeMap( Datei* zDatei, int mapId, KSGClient::SpielServerClient* zSpielKlient, Text* zGamePath )
 {
     int ressourceAnz = 0;
-    zDatei->lese( (char *)&ressourceAnz, 4 );
+    zDatei->lese( (char*)&ressourceAnz, 4 );
     for( int i = 0; i < ressourceAnz; i++ )
     {
         ressources->add( new RessourceStr( zDatei, mapId, zGamePath ) );
-        zSpielKlient->setLadenProzent( 15 + (int)( 35 * ( (double)( i + 1 ) / ressourceAnz ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 15 + (int)(35 * ((double)(i + 1) / ressourceAnz) + 0.5) );
     }
-    zDatei->lese( (char *)&größe.x, 4 );
-    zDatei->lese( (char *)&größe.y, 4 );
+    zDatei->lese( (char*)&größe.x, 4 );
+    zDatei->lese( (char*)&größe.y, 4 );
     int objektAnzahl = 0;
-    zDatei->lese( (char *)&objektAnzahl, 4 );
+    zDatei->lese( (char*)&objektAnzahl, 4 );
     for( int i = 0; i < objektAnzahl; i++ )
     {
         objekte->add( new ObjektStr( zDatei ) );
-        zSpielKlient->setLadenProzent( 50 + (int)( 10 * ( (double)( i + 1 ) / objektAnzahl ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 50 + (int)(10 * ((double)(i + 1) / objektAnzahl) + 0.5) );
     }
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         spieler->add( new SpielerStr( zDatei ) );
-        zSpielKlient->setLadenProzent( 60 + (int)( 5 * ( (double)( i + 1 ) / spielerAnzahl ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 60 + (int)(5 * ((double)(i + 1) / spielerAnzahl) + 0.5) );
     }
     for( int i = 0; i < teamAnzahl; i++ )
     {
         teams->add( new TeamStr( zDatei ) );
-        zSpielKlient->setLadenProzent( 65 + (int)( 5 * ( (double)( i + 1 ) / teamAnzahl ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 65 + (int)(5 * ((double)(i + 1) / teamAnzahl) + 0.5) );
     }
 }
 
@@ -108,74 +108,74 @@ Vec2< int > Karte::getSize() const
     return größe;
 }
 
-Spieler *Karte::createSpieler( int sNum, UIInit &uiFactory, KSGClient::InformationServerClient *zInfoK, Animation2DData *zFStart, Animation2DData *zFBurn ) const
+Spieler* Karte::createSpieler( int sNum, UIInit& uiFactory, KSGClient::InformationServerClient* zInfoK, Animation2DData* zFStart, Animation2DData* zFBurn ) const
 {
     if( sNum < 0 || sNum >= spielerAnzahl )
         return 0;
-    SpielerStr *player = 0;
-    for( auto s = spieler->getIterator(); s; s++ )
+    SpielerStr* player = 0;
+    for( auto s : *spieler )
     {
         if( s->id == sNum + 1 )
             player = s;
     }
     if( !player )
         return 0;
-    Spieler *ret = new Spieler( zInfoK, uiFactory, player );
-    for( auto i = ressources->getIterator(); i && i && i._; i++ )
+    Spieler* ret = new Spieler( zInfoK, uiFactory, player );
+    for( auto i : *ressources )
     {
         if( i->getId() == player->m2d )
-            ret->setModelData( dynamic_cast<Model2DData *>( i->zReccourceM2()->getThis() ), zFStart, zFBurn );
+            ret->setModelData( dynamic_cast<Model2DData*>(i->zReccourceM2()->getThis()), zFStart, zFBurn );
         if( i->getId() == player->bild )
             ret->setSpielerFarbe( spielerFarbe->hat( sNum ) ? spielerFarbe->get( sNum ) : 0, i->zReccourceTxt() );
     }
     return ret;
 }
 
-Team *Karte::createTeam( int tNum ) const
+Team* Karte::createTeam( int tNum ) const
 {
     if( tNum < 0 || tNum >= teamAnzahl )
         return 0;
-    TeamStr *team = 0;
-    for( auto t = teams->getIterator(); t; t++ )
+    TeamStr* team = 0;
+    for( auto t : *teams )
     {
         if( t->id == tNum + 1 )
             team = t;
     }
     if( !team )
         return 0;
-    Team *ret = new Team( teamFarbe->get( tNum ), teamName->z( tNum )->getText(), team );
+    Team* ret = new Team( teamFarbe->get( tNum ), teamName->z( tNum )->getText(), team );
     return ret;
 }
 
-SpielObjekt *Karte::createObjekt( int oNum, UIInit &uiFactory ) const
+SpielObjekt* Karte::createObjekt( int oNum, UIInit& uiFactory ) const
 {
     if( oNum <= 0 )
         return 0;
-    ObjektStr *obj = 0;
-    for( auto o = objekte->getIterator(); o; o++ )
+    ObjektStr* obj = 0;
+    for( auto o : *objekte )
     {
         if( o->id == oNum )
             obj = o;
     }
     if( !obj )
         return 0;
-    SpielObjekt *ret = new SpielObjekt( obj, uiFactory );
-    Bild *bild = 0;
-    for( auto i = ressources->getIterator(); i && i._; i++ )
+    SpielObjekt* ret = new SpielObjekt( obj, uiFactory );
+    Bild* bild = 0;
+    for( auto i : *ressources )
     {
         if( i->getId() == obj->m2d )
-            ret->setModel( dynamic_cast<Model2DData *>( i->zReccourceM2()->getThis() ) );
+            ret->setModel( dynamic_cast<Model2DData*>(i->zReccourceM2()->getThis()) );
         if( i->getId() == obj->bild )
-            bild = dynamic_cast<Bild *>( i->zReccourceTxt()->getThis() );
+            bild = dynamic_cast<Bild*>(i->zReccourceTxt()->getThis());
     }
     if( bild )
         ret->setTextur( bild );
     return ret;
 }
 
-Iterator< ObjektStr * > Karte::getObjekte() const
+Iterator< ObjektStr* > Karte::getObjekte() const
 {
-    return objekte->getIterator();
+    return objekte->begin();
 }
 
 int Karte::getMaxTeamAnzahl() const

Asteroids/Spiel/SpielKlasse.cpp

@@ -37,10 +37,10 @@ SpielKlasse::SpielKlasse()
     welt->setCircular( 1 );
     welt->setAirResistance( 0.001f );
     kam = new Kamera2D();
-    kam->setWelt( dynamic_cast<Welt2D *>( welt->getThis() ), 1 );
+    kam->setWelt( dynamic_cast<Welt2D*>(welt->getThis()), 1 );
     minimap = new Kamera2D();
     minimap->setSize( 200, 200 );
-    minimap->setWelt( dynamic_cast<Welt2D *>( welt->getThis() ), 0 );
+    minimap->setWelt( dynamic_cast<Welt2D*>(welt->getThis()), 0 );
     minimap->setStyle( ZeichnungHintergrund::Style::Sichtbar | ZeichnungHintergrund::Style::Rahmen );
     minimap->setRahmenFarbe( 0xFFFFFFFF );
     minimap->setName( "minimap" );
@@ -137,34 +137,34 @@ void SpielKlasse::goToPresence( int zeit )
 void SpielKlasse::load()
 {
     spielZeit = last.spielZeit;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         i->load();
-    for( auto i = objekte->getIterator(); i; i++ )
+    for( auto i : *objekte )
         i->load();
-    for( auto i = schüsse->getIterator(); i; i++ )
+    for( auto i : *schüsse )
         i->load();
-    for( auto i = asteroids->getIterator(); i; i++ )
+    for( auto i : *asteroids )
         i->load();
-    for( auto i = pixel->getIterator(); i; i++ )
+    for( auto i : *pixel )
         i->load();
-    for( auto i = deads->getIterator(); i; i++ )
+    for( auto i : *deads )
         i->load();
 }
 
 void SpielKlasse::save()
 {
     last.spielZeit = spielZeit;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         i->save();
-    for( auto i = objekte->getIterator(); i; i++ )
+    for( auto i : *objekte )
         i->save();
-    for( auto i = schüsse->getIterator(); i; i++ )
+    for( auto i : *schüsse )
         i->save();
-    for( auto i = asteroids->getIterator(); i; i++ )
+    for( auto i : *asteroids )
         i->save();
-    for( auto i = pixel->getIterator(); i; i++ )
+    for( auto i : *pixel )
         i->save();
-    for( auto i = deads->getIterator(); i; i++ )
+    for( auto i : *deads )
         i->save();
 }
 
@@ -175,7 +175,7 @@ void SpielKlasse::tick()
     int asteroidAnz = asteroids->getEintragAnzahl();
     for( int i = 0; i < asteroidAnz; i++ )
     {
-        Asteroid *p = asteroids->z( i );
+        Asteroid* p = asteroids->z( i );
         if( p->isDead() )
         {
             welt->removeObject( p );
@@ -198,7 +198,7 @@ void SpielKlasse::unlock()
         uiFactory.initParam.bildschirm->unlock();
 }
 
-void SpielKlasse::setUIFactory( UIInit &uiFactory )
+void SpielKlasse::setUIFactory( UIInit& uiFactory )
 {
     this->uiFactory = uiFactory;
     chat = new SpielChat( uiFactory );
@@ -208,7 +208,7 @@ void SpielKlasse::setUIFactory( UIInit &uiFactory )
         shipGUI = new SpielerGUI( uiFactory );
 }
 
-void SpielKlasse::nachricht( int län, char *bytes )
+void SpielKlasse::nachricht( int län, char* bytes )
 {
     if( !län )
         return;
@@ -218,7 +218,7 @@ void SpielKlasse::nachricht( int l
     unlock();
 }
 
-void SpielKlasse::setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient )
+void SpielKlasse::setKlients( KSGClient::InformationServerClient* infoKlient, KSGClient::SpielServerClient* spielKlient )
 {
     if( this->infoKlient )
         this->infoKlient->release();
@@ -247,30 +247,30 @@ void SpielKlasse::ladeDaten()
     csv.open( Datei::Style::schreiben );
     csv.schreibe( "Spielernummer;Skill ID\n", 23 );
     // load frame annimation
-    Text *gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
+    Text* gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
     LTDBDatei flammenStartLTDB;
-    Text *f_start = new Text( gamePath->getText() );
+    Text* f_start = new Text( gamePath->getText() );
     f_start->append( "/bilder/f_start.ltdb" );
     flammenStartLTDB.setDatei( f_start );
     flammenStartLTDB.leseDaten( 0 );
-    Animation2DData *flammenStart = new Animation2DData();
-    flammenStart->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenStartLTDB.getThis() ) );
+    Animation2DData* flammenStart = new Animation2DData();
+    flammenStart->ladeAnimation( dynamic_cast<LTDBDatei*>(flammenStartLTDB.getThis()) );
     flammenStart->setFPS( 75 );
     flammenStart->setWiederhohlend( 0 );
     spielKlient->setLadenProzent( 7 );
     LTDBDatei flammenLTDB;
-    Text *f_burn = new Text( gamePath->getText() );
+    Text* f_burn = new Text( gamePath->getText() );
     f_burn->append( "/bilder/f_burn.ltdb" );
     flammenLTDB.setDatei( f_burn );
-    Animation2DData *flammenBurn = new Animation2DData();
-    flammenBurn->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenLTDB.getThis() ) );
+    Animation2DData* flammenBurn = new Animation2DData();
+    flammenBurn->ladeAnimation( dynamic_cast<LTDBDatei*>(flammenLTDB.getThis()) );
     flammenBurn->setFPS( 60 );
     flammenBurn->setWiederhohlend( 1 );
     map = new Karte();
-    Text *mapPf = new Text( "data/tmp/Karten/" );
+    Text* mapPf = new Text( "data/tmp/Karten/" );
     mapPf->append( karteId );
     mapPf->append( "/spiel/data/data.sts" );
-    Datei *stsD = new Datei();
+    Datei* stsD = new Datei();
     stsD->setDatei( mapPf->getText() );
     stsD->open( Datei::Style::lesen );
     map->ladeSts( stsD );
@@ -278,7 +278,7 @@ void SpielKlasse::ladeDaten()
     stsD->release();
     spielKlient->setLadenProzent( 15 );
     mapPf->ersetzen( mapPf->getLength() - 3, mapPf->getLength(), "map" );
-    Datei *mapD = new Datei();
+    Datei* mapD = new Datei();
     mapD->setDatei( mapPf->getText() );
     mapD->open( Datei::Style::lesen );
     map->ladeMap( mapD, karteId, spielKlient, gamePath );
@@ -287,7 +287,7 @@ void SpielKlasse::ladeDaten()
     mapPf->release();
     for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
     {
-        Spieler *s = map->createSpieler( i, uiFactory, infoKlient, flammenStart, flammenBurn );
+        Spieler* s = map->createSpieler( i, uiFactory, infoKlient, flammenStart, flammenBurn );
         spieler->set( s, i );
     }
     flammenStart->release();
@@ -298,9 +298,9 @@ void SpielKlasse::ladeDaten()
         teams->add( map->createTeam( i ) );
     for( auto o = map->getObjekte(); o; o++ )
     {
-        SpielObjekt *obj = map->createObjekt( o->id, uiFactory );
+        SpielObjekt* obj = map->createObjekt( o->id, uiFactory );
         obj->setTeam( teams->get( o->team - 1 ) );
-        welt->addObject( dynamic_cast<SpielObjekt *>( obj->getThis() ) );
+        welt->addObject( dynamic_cast<SpielObjekt*>(obj->getThis()) );
         objekte->add( obj );
     }
     bestenliste->setTeamAnzahl( map->getMaxTeamAnzahl() );
@@ -321,19 +321,19 @@ void SpielKlasse::ladeDaten()
     LTDBDatei asteroidTexturD;
     Text aTexturPfad = gamePath->getText();
     aTexturPfad += "/bilder/asteroids.ltdb";
-    asteroidTexturD.setDatei( dynamic_cast<Text *>( aTexturPfad.getThis() ) );
+    asteroidTexturD.setDatei( dynamic_cast<Text*>(aTexturPfad.getThis()) );
     asteroidTexturD.leseDaten( 0 );
     for( int i = 0; i < anz; i++ )
     {
-        Text *name = new Text( astroidModels.zModelName( i )->getText() );
+        Text* name = new Text( astroidModels.zModelName( i )->getText() );
         name->append( ".png" );
-        Textur2D *txt = new Textur2D();
+        Textur2D* txt = new Textur2D();
         txt->setTexturZ( asteroidTexturD.laden( 0, name ) );
         asteroidTextures->add( txt );
     }
     spielKlient->setLadenProzent( 98 );
     LTDBDatei skillLTDB;
-    Text *skillLTDBPfad = new Text( gamePath->getText() );
+    Text* skillLTDBPfad = new Text( gamePath->getText() );
     skillLTDBPfad->append( "/bilder/skills.ltdb" );
     skillLTDB.setDatei( skillLTDBPfad );
     skillLTDB.leseDaten( 0 );
@@ -344,7 +344,7 @@ void SpielKlasse::ladeDaten()
     gamePath->release();
 }
 
-void SpielKlasse::doPublicMausEreignis( MausEreignis &me )
+void SpielKlasse::doPublicMausEreignis( MausEreignis& me )
 {
     if( end )
     {
@@ -366,7 +366,7 @@ void SpielKlasse::doPublicMausEreignis( MausEreignis &me )
         bestenliste->doPublicMausEreignis( me );
 }
 
-void SpielKlasse::doTastaturEreignis( TastaturEreignis &te )
+void SpielKlasse::doTastaturEreignis( TastaturEreignis& te )
 {
     bestenliste->doTastaturEreignis( te );
     if( end )
@@ -580,12 +580,12 @@ void SpielKlasse::stknVerarbeitung()
     lock();
     for( int i = 0; i < stkna; i++ )
     {
-        STKNachricht *n = stkn->z( i );
+        STKNachricht* n = stkn->z( i );
         int zeit = n->getSpielZeit();
         while( zeit > spielZeit )
             tick();
         int län = n->getLength();
-        char *bytes = n->getNachricht();
+        char* bytes = n->getNachricht();
         län--;
         int sNum = 0;
         int presence = spielZeit;
@@ -595,10 +595,10 @@ void SpielKlasse::stknVerarbeitung()
         {
         case 0: // spieler drückt gas
             bytes++;
-            sNum = *(int *)bytes;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto i = spieler->getIterator(); i; i++ )
+            for( auto i : *spieler )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
@@ -609,10 +609,10 @@ void SpielKlasse::stknVerarbeitung()
             break;
         case 1: // spieler lässt gas los
             bytes++;
-            sNum = *(int *)bytes;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto i = spieler->getIterator(); i; i++ )
+            for( auto i : *spieler )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
@@ -623,10 +623,10 @@ void SpielKlasse::stknVerarbeitung()
             break;
         case 2: // spieler drückt rotl
             bytes++;
-            sNum = *(int *)bytes;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto i = spieler->getIterator(); i; i++ )
+            for( auto i : *spieler )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
@@ -637,10 +637,10 @@ void SpielKlasse::stknVerarbeitung()
             break;
         case 3: // spieler lässt rotl los
             bytes++;
-            sNum = *(int *)bytes;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto i = spieler->getIterator(); i; i++ )
+            for( auto i : *spieler )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
@@ -651,10 +651,10 @@ void SpielKlasse::stknVerarbeitung()
             break;
         case 4: // spieler drückt rotr
             bytes++;
-            sNum = *(int *)bytes;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto i = spieler->getIterator(); i; i++ )
+            for( auto i : *spieler )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
@@ -665,10 +665,10 @@ void SpielKlasse::stknVerarbeitung()
             break;
         case 5: // spieler lässt rotr los
             bytes++;
-            sNum = *(int *)bytes;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto i = spieler->getIterator(); i; i++ )
+            for( auto i : *spieler )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
@@ -686,21 +686,21 @@ void SpielKlasse::stknVerarbeitung()
                 län--;
                 for( int i = 0; i < spielerAnzahl; i++ )
                 {
-                    int sNum = *(int *)bytes;
-                    Spieler *tmp = spieler->z( sNum - 1 );
-                    tmp->addSkill( new ShieldBoost( dynamic_cast<Bild *>( shieldBoost->getThis() ) ) );
-                    tmp->addSkill( new SpeedBoost( dynamic_cast<Bild *>( speedBoost->getThis() ) ) );
+                    int sNum = *(int*)bytes;
+                    Spieler* tmp = spieler->z( sNum - 1 );
+                    tmp->addSkill( new ShieldBoost( dynamic_cast<Bild*>(shieldBoost->getThis()) ) );
+                    tmp->addSkill( new SpeedBoost( dynamic_cast<Bild*>(speedBoost->getThis()) ) );
                     bytes += 4;
                     län -= 4;
-                    tmp->setAccountId( *(int *)bytes );
+                    tmp->setAccountId( *(int*)bytes );
                     bytes += 4;
                     län -= 4;
                     tmp->setTeam( teams->z( map->getTeamNummer( sNum ) ) );
-                    tmp->zTeam()->spieler->add( dynamic_cast<Spieler *>( tmp->getThis() ) );
+                    tmp->zTeam()->spieler->add( dynamic_cast<Spieler*>(tmp->getThis()) );
                     bestenliste->addSpieler( tmp );
                     bestenliste->updateSpieler( tmp );
                     bestenliste->updateTeam( tmp->zTeam() );
-                    welt->addObject( dynamic_cast<Spieler *>( tmp->getThis() ) );
+                    welt->addObject( dynamic_cast<Spieler*>(tmp->getThis()) );
                 }
                 int max = map->getMaxSpielerAnzahl();
                 for( int i = 0; i < max; i++ )
@@ -718,7 +718,7 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                Text *txt = new Text( "" );
+                Text* txt = new Text( "" );
                 txt->append( bytes, län );
                 chat->addNachricht( txt->getText() );
                 txt->release();
@@ -727,7 +727,7 @@ void SpielKlasse::stknVerarbeitung()
             break;
         case 0x9: // Spieler Nummer
             bytes++;
-            spielerNummer = *(int *)bytes;
+            spielerNummer = *(int*)bytes;
             län -= 4;
             for( int i = 0; i < spielerAnzahl; i++ )
             {
@@ -747,7 +747,7 @@ void SpielKlasse::stknVerarbeitung()
             csv.schreibe( "\n\nSpielernummer;Kills;Tode;Schaden gemacht;Schaden bekommen;Schüsse;Treffer\n", 2 );
             for( int i = 0; i < spielerAnzahl; i++ )
             {
-                Spieler *s = spieler->z( i );
+                Spieler* s = spieler->z( i );
                 Text line = s->getSpielerNummer();
                 line += ";";
                 line += s->getKills();
@@ -774,7 +774,7 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                sNum = *(int *)bytes;
+                sNum = *(int*)bytes;
                 bytes += 4;
                 län -= 4;
                 char art = *bytes;
@@ -789,7 +789,7 @@ void SpielKlasse::stknVerarbeitung()
                 {
                     if( spieler->z( i )->getSpielerNummer() == sNum )
                     {
-                        Team *tmp = spieler->z( i )->zTeam();
+                        Team* tmp = spieler->z( i )->zTeam();
                         spieler->z( i )->setSkill( art );
                         tmp->akkuLeistung = tmp->getAkkuLeistungBonus();
                         tmp->beschleunigung = tmp->getBeschleunigungBonus();
@@ -821,25 +821,25 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                int id = *(int *)bytes;
+                int id = *(int*)bytes;
                 bytes += 4;
                 län -= 4;
-                sNum = *(int *)bytes;
+                sNum = *(int*)bytes;
                 bytes += 4;
                 län -= 4;
-                float xPos = *(float *)bytes;
+                float xPos = *(float*)bytes;
                 bytes += 4;
                 län -= 4;
-                float yPos = *(float *)bytes;
+                float yPos = *(float*)bytes;
                 bytes += 4;
                 län -= 4;
-                float xSpeed = *(float *)bytes;
+                float xSpeed = *(float*)bytes;
                 bytes += 4;
                 län -= 4;
-                float ySpeed = *(float *)bytes;
+                float ySpeed = *(float*)bytes;
                 bytes += 4;
                 län -= 4;
-                double intensität = *(double *)bytes;
+                double intensität = *(double*)bytes;
                 län -= 8;
                 int farbe = 0;
                 goBackInTime( zeit );
@@ -848,15 +848,15 @@ void SpielKlasse::stknVerarbeitung()
                     if( spieler->z( i )->getSpielerNummer() == sNum )
                     {
                         if( spieler->z( i )->getPosition() != Vertex( xPos, yPos ) )
-                            chat->addNachricht( Text( "asynchrony detected difference: " ) += ( spieler->z( i )->getPosition() - Vertex( xPos, yPos ) ).getLength(), 0xFFFF0000 );
+                            chat->addNachricht( Text( "asynchrony detected difference: " ) += (spieler->z( i )->getPosition() - Vertex( xPos, yPos )).getLength(), 0xFFFF0000 );
                         spieler->z( i )->setPosition( Vertex( xPos, yPos ) );
                         spieler->z( i )->hatGeschossen();
                         farbe = spieler->z( i )->zTeam()->farbe;
                         break;
                     }
                 }
-                Laser *l = new Laser( id, Vertex( xPos, yPos ), Vertex( xSpeed, ySpeed ), sNum, intensität, farbe );
-                welt->addObject( dynamic_cast<Laser *>( l->getThis() ) );
+                Laser* l = new Laser( id, Vertex( xPos, yPos ), Vertex( xSpeed, ySpeed ), sNum, intensität, farbe );
+                welt->addObject( dynamic_cast<Laser*>(l->getThis()) );
                 schüsse->add( l );
                 goToPresence( presence );
                 if( sNum == spielerNummer )
@@ -877,30 +877,30 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                int schuss = *(int *)bytes;
+                int schuss = *(int*)bytes;
                 bytes += 4;
                 län -= 4;
-                int sNum = *(int *)bytes;
+                int sNum = *(int*)bytes;
                 bytes += 4;
                 län -= 4;
-                float erf = *(float *)bytes;
+                float erf = *(float*)bytes;
                 bytes += 4;
                 län -= 4;
-                int skillP = *(int *)bytes;
+                int skillP = *(int*)bytes;
                 län -= 4;
                 goBackInTime( zeit );
                 int sAnz = schüsse->getEintragAnzahl();
                 for( int i = 0; i < sAnz; i++ )
                 {
-                    Laser *tmp = schüsse->z( i );
+                    Laser* tmp = schüsse->z( i );
                     if( tmp && tmp->getId() == schuss )
                     {
                         if( sNum >= 0 )
                         {
                             double intens = 0;
-                            Spieler *attacker = 0;
-                            Spieler *attacked = 0;
-                            for( auto s = spieler->getIterator(); s; s++ )
+                            Spieler* attacker = 0;
+                            Spieler* attacked = 0;
+                            for( auto s : *spieler )
                             {
                                 if( s->getSpielerNummer() == tmp->getSpieler() )
                                     attacker = s;
@@ -917,9 +917,9 @@ void SpielKlasse::stknVerarbeitung()
                                 bestenliste->updateSpieler( attacked );
                                 attacker->machSchaden( intens, attacked->getLevel() );
                                 if( attacker->getEp() != erf )
-                                    chat->addNachricht( Text( "asynchrony detected ep difference: " ) += ( erf - attacker->getEp() ), 0xFFFF0000 );
+                                    chat->addNachricht( Text( "asynchrony detected ep difference: " ) += (erf - attacker->getEp()), 0xFFFF0000 );
                                 if( attacker->getSkillP() != skillP )
-                                    chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += ( skillP - attacker->getSkillP() ), 0xFFFF0000 );
+                                    chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += (skillP - attacker->getSkillP()), 0xFFFF0000 );
                                 bestenliste->updateSpieler( attacker );
                             }
                         }
@@ -931,7 +931,7 @@ void SpielKlasse::stknVerarbeitung()
                 goToPresence( presence );
                 if( sNum == spielerNummer )
                 {
-                    for( auto s = spieler->getIterator(); s; s++ )
+                    for( auto s : *spieler )
                     {
                         if( s->getSpielerNummer() == spielerNummer )
                         {
@@ -946,12 +946,12 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                int sNum = *(int *)bytes;
+                int sNum = *(int*)bytes;
                 län -= 4;
                 goBackInTime( zeit );
-                for( auto s = spieler->getIterator(); s; s++ )
+                for( auto i : *spieler )
                 {
-                    if( s->getSpielerNummer() == sNum )
+                    for( auto s : *spieler )
                     {
                         s->wiederbelebung();
                         break;
@@ -960,7 +960,7 @@ void SpielKlasse::stknVerarbeitung()
                 goToPresence( presence );
                 if( sNum == spielerNummer )
                 {
-                    for( auto s = spieler->getIterator(); s; s++ )
+                    for( auto s : *spieler )
                     {
                         if( s->getSpielerNummer() == spielerNummer )
                         {
@@ -975,15 +975,15 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                sNum = *(int *)bytes;
+                sNum = *(int*)bytes;
                 bytes += 4;
                 län -= 4;
-                int killer = *(int *)bytes;
+                int killer = *(int*)bytes;
                 län -= 4;
                 goBackInTime( zeit );
-                Spieler *dead = 0;
-                Spieler *kill = 0;
-                for( auto s = spieler->getIterator(); s; s++ )
+                Spieler* dead = 0;
+                Spieler* kill = 0;
+                for( auto s : *spieler )
                 {
                     if( s->getSpielerNummer() == sNum )
                         dead = s;
@@ -992,10 +992,10 @@ void SpielKlasse::stknVerarbeitung()
                 }
                 if( dead )
                 {
-                    DeadPlayer *dp = dead->sterben();
+                    DeadPlayer* dp = dead->sterben();
                     if( dp )
                     {
-                        welt->addObject( dynamic_cast<DeadPlayer *>( dp->getThis() ) );
+                        welt->addObject( dynamic_cast<DeadPlayer*>(dp->getThis()) );
                         deads->add( dp );
                     }
                     bestenliste->updateSpieler( dead );
@@ -1026,32 +1026,32 @@ void SpielKlasse::stknVerarbeitung()
             Vertex pos, speed;
             float rot, rotS;
             bytes++;
-            int id = *(int *)bytes;
+            int id = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            pos.x = *(float *)bytes;
+            pos.x = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            pos.y = *(float *)bytes;
+            pos.y = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            speed.x = *(float *)bytes;
+            speed.x = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            speed.y = *(float *)bytes;
+            speed.y = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            rot = *(float *)bytes;
+            rot = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            rotS = *(float *)bytes;
+            rotS = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            int index = *(int *)bytes;
+            int index = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            Asteroid *na = new Asteroid( id, pos, speed, rot, rotS, asteroidModels->get( index ), asteroidTextures->get( index ) );
-            welt->addObject( dynamic_cast<Asteroid *>( na->getThis() ) );
+            Asteroid* na = new Asteroid( id, pos, speed, rot, rotS, asteroidModels->get( index ), asteroidTextures->get( index ) );
+            welt->addObject( dynamic_cast<Asteroid*>(na->getThis()) );
             asteroids->add( na );
             goToPresence( presence );
             break;
@@ -1060,56 +1060,56 @@ void SpielKlasse::stknVerarbeitung()
         {
             Vertex pos;
             bytes++;
-            int schuss = *(int *)bytes;
+            int schuss = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            int asteroid = *(int *)bytes;
+            int asteroid = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            pos.x = *(float *)bytes;
+            pos.x = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            pos.y = *(float *)bytes;
+            pos.y = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            __int64 seed = *(__int64 *)bytes;
+            __int64 seed = *(__int64*)bytes;
             bytes += 8;
             län -= 8;
-            int newAsteroid = *(int *)bytes;
+            int newAsteroid = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            float erf = *(float *)bytes;
+            float erf = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            int skillP = *(int *)bytes;
+            int skillP = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             int aAnz = asteroids->getEintragAnzahl();
             for( int i = 0; i < aAnz; i++ )
             {
-                Asteroid *a = asteroids->z( i );
+                Asteroid* a = asteroids->z( i );
                 if( a->getId() == asteroid )
                 {
                     int sAnz = schüsse->getEintragAnzahl();
                     for( int j = 0; j < sAnz; j++ )
                     {
-                        Laser *tmp = schüsse->z( j );
+                        Laser* tmp = schüsse->z( j );
                         if( tmp && tmp->getId() == schuss )
                         {
-                            for( auto s = spieler->getIterator(); s; s++ )
+                            for( auto s : *spieler )
                             {
                                 if( s->getSpielerNummer() == tmp->getSpieler() )
                                 {
                                     s->addTreffer( (float)tmp->getIntensität( a->getSpeed() ), 0 );
                                     if( s->getEp() != erf )
-                                        chat->addNachricht( Text( "asynchrony detected ep difference: " ) += ( erf - s->getEp() ), 0xFFFF0000 );
+                                        chat->addNachricht( Text( "asynchrony detected ep difference: " ) += (erf - s->getEp()), 0xFFFF0000 );
                                     if( s->getSkillP() != skillP )
-                                        chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += ( skillP - s->getSkillP() ), 0xFFFF0000 );
+                                        chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += (skillP - s->getSkillP()), 0xFFFF0000 );
                                     break;
                                 }
                             }
-                            Asteroid *na = a->split( pos, tmp->getSpeed(), seed, newAsteroid );
-                            welt->addObject( dynamic_cast<Asteroid *>( na->getThis() ) );
+                            Asteroid* na = a->split( pos, tmp->getSpeed(), seed, newAsteroid );
+                            welt->addObject( dynamic_cast<Asteroid*>(na->getThis()) );
                             asteroids->add( na );
                             welt->removeObject( tmp );
                             schüsse->remove( j );
@@ -1124,18 +1124,18 @@ void SpielKlasse::stknVerarbeitung()
         case 0x13: // Pixel
         {
             bytes++;
-            int asteroid = *(int *)bytes;
+            int asteroid = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            int pixelId = *(int *)bytes;
+            int pixelId = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            for( auto a = asteroids->getIterator(); a; a++ )
+            for( auto a : *asteroids )
             {
                 if( a->getId() == asteroid )
                 {
-                    Pixel *p = new Pixel( a->getPosition(), a->getSpeed(), a->getMasse() / 50, pixelId );
-                    welt->addObject( dynamic_cast<Pixel *>( p->getThis() ) );
+                    Pixel* p = new Pixel( a->getPosition(), a->getSpeed(), a->getMasse() / 50, pixelId );
+                    welt->addObject( dynamic_cast<Pixel*>(p->getThis()) );
                     pixel->add( p );
                     a->setDead();
                     break;
@@ -1147,21 +1147,21 @@ void SpielKlasse::stknVerarbeitung()
         case 0x14: // Pixel einsammeln
         {
             bytes++;
-            int pixelId = *(int *)bytes;
+            int pixelId = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            int spielerId = *(int *)bytes;
+            int spielerId = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             int pixelAnz = pixel->getEintragAnzahl();
             for( int i = 0; i < pixelAnz; i++ )
             {
-                Pixel *p = pixel->z( i );
+                Pixel* p = pixel->z( i );
                 if( p->getId() == pixelId )
                 {
                     if( spielerId >= 0 )
                     {
-                        for( auto s = spieler->getIterator(); s; s++ )
+                        for( auto s : *spieler )
                         {
                             if( s->getSpielerNummer() == spielerId )
                             {
@@ -1183,13 +1183,13 @@ void SpielKlasse::stknVerarbeitung()
         case 0x15: // Use active Skill
         {
             bytes++;
-            int sNum = *(int *)bytes;
+            int sNum = *(int*)bytes;
             bytes += 4;
             län -= 4;
             char skillId = *bytes;
             län--;
             goBackInTime( zeit );
-            for( auto s = spieler->getIterator(); s; s++ )
+            for( auto s : *spieler )
             {
                 if( s->getSpielerNummer() == sNum )
                     s->useSkill( skillId );
@@ -1200,35 +1200,35 @@ void SpielKlasse::stknVerarbeitung()
         case 0x16: // Objekt treffer
         {
             bytes++;
-            int schuss = *(int *)bytes;
+            int schuss = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            int oId = *(int *)bytes;
+            int oId = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            float erf = *(float *)bytes;
+            float erf = *(float*)bytes;
             bytes += 4;
             län -= 4;
-            int skillP = *(int *)bytes;
+            int skillP = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             int sAnz = schüsse->getEintragAnzahl();
             for( int i = 0; i < sAnz; i++ )
             {
-                Laser *tmp = schüsse->z( i );
+                Laser* tmp = schüsse->z( i );
                 if( tmp && tmp->getId() == schuss )
                 {
                     if( sNum >= 0 )
                     {
                         double intens = 0;
-                        Spieler *attacker = 0;
-                        SpielObjekt *attacked = 0;
-                        for( auto s = spieler->getIterator(); s; s++ )
+                        Spieler* attacker = 0;
+                        SpielObjekt* attacked = 0;
+                        for( auto s : *spieler )
                         {
                             if( s->getSpielerNummer() == tmp->getSpieler() )
                                 attacker = s;
                         }
-                        for( auto o = objekte->getIterator(); o; o++ )
+                        for( auto o : *objekte )
                         {
                             if( o->getObjektId() == oId )
                                 attacked = o;
@@ -1242,9 +1242,9 @@ void SpielKlasse::stknVerarbeitung()
                             attacked->calcDeadPlayerObject( schüsse->z( i ) );
                             attacker->machSchaden( intens, attacked->getLevel(), attacked->doesShotAddEp() );
                             if( attacker->getEp() != erf )
-                                chat->addNachricht( Text( "asynchrony detected ep difference: " ) += ( erf - attacker->getEp() ), 0xFFFF0000 );
+                                chat->addNachricht( Text( "asynchrony detected ep difference: " ) += (erf - attacker->getEp()), 0xFFFF0000 );
                             if( attacker->getSkillP() != skillP )
-                                chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += ( skillP - attacker->getSkillP() ), 0xFFFF0000 );
+                                chat->addNachricht( Text( "asynchrony detected skillPunkte difference: " ) += (skillP - attacker->getSkillP()), 0xFFFF0000 );
                             bestenliste->updateSpieler( attacker );
                         }
                     }
@@ -1256,7 +1256,7 @@ void SpielKlasse::stknVerarbeitung()
             goToPresence( presence );
             if( sNum == spielerNummer )
             {
-                for( auto s = spieler->getIterator(); s; s++ )
+                for( auto s : *spieler )
                 {
                     if( s->getSpielerNummer() == spielerNummer )
                     {
@@ -1270,30 +1270,30 @@ void SpielKlasse::stknVerarbeitung()
         case 0x17: // Objekt Tod
         {
             bytes++;
-            int oId = *(int *)bytes;
+            int oId = *(int*)bytes;
             bytes += 4;
             län -= 4;
-            int killer = *(int *)bytes;
+            int killer = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
-            SpielObjekt *dead = 0;
-            Spieler *kill = 0;
-            for( auto s = spieler->getIterator(); s; s++ )
+            SpielObjekt* dead = 0;
+            Spieler* kill = 0;
+            for( auto s : *spieler )
             {
                 if( s->getSpielerNummer() == killer )
                     kill = s;
             }
-            for( auto o = objekte->getIterator(); o; o++ )
+            for( auto o : *objekte )
             {
                 if( o->getObjektId() == oId )
                     dead = o;
             }
             if( dead )
             {
-                DeadPlayer *dp = dead->sterben();
+                DeadPlayer* dp = dead->sterben();
                 if( dp )
                 {
-                    welt->addObject( dynamic_cast<DeadPlayer *>( dp->getThis() ) );
+                    welt->addObject( dynamic_cast<DeadPlayer*>(dp->getThis()) );
                     deads->add( dp );
                 }
             }
@@ -1390,23 +1390,23 @@ bool SpielKlasse::tick( double zeit )
         {
             if( !this->setKam || isnan( kam->getWorldPosition().x ) || isnan( kam->getWorldPosition().y ) )
                 kam->lookAtWorldPos( tPos );
-            Vertex str = ( tPos - kam->getWorldPosition() );
-            if( ( tPos + welt->getWorldInfo().size - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + welt->getWorldInfo().size - kam->getWorldPosition() );
-            if( ( tPos - welt->getWorldInfo().size - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos - welt->getWorldInfo().size - kam->getWorldPosition() );
-            if( ( tPos + Punkt( welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + Punkt( welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition() );
-            if( ( tPos + Punkt( -welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + Punkt( -welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition() );
-            if( ( tPos + Punkt( 0, welt->getWorldInfo().size.y ) - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + Punkt( 0, welt->getWorldInfo().size.y ) - kam->getWorldPosition() );
-            if( ( tPos + Punkt( 0, -welt->getWorldInfo().size.y ) - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + Punkt( 0, -welt->getWorldInfo().size.y ) - kam->getWorldPosition() );
-            if( ( tPos + Punkt( welt->getWorldInfo().size.x, -welt->getWorldInfo().size.y ) - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + Punkt( welt->getWorldInfo().size.x, -welt->getWorldInfo().size.y ) - kam->getWorldPosition() );
-            if( ( tPos + Punkt( -welt->getWorldInfo().size.x, welt->getWorldInfo().size.y ) - kam->getWorldPosition() ).getLengthSq() < str.getLengthSq() )
-                str = ( tPos + Punkt( -welt->getWorldInfo().size.x, welt->getWorldInfo().size.y ) - kam->getWorldPosition() );
+            Vertex str = (tPos - kam->getWorldPosition());
+            if( (tPos + welt->getWorldInfo().size - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + welt->getWorldInfo().size - kam->getWorldPosition());
+            if( (tPos - welt->getWorldInfo().size - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos - welt->getWorldInfo().size - kam->getWorldPosition());
+            if( (tPos + Punkt( welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + Punkt( welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition());
+            if( (tPos + Punkt( -welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + Punkt( -welt->getWorldInfo().size.x, 0 ) - kam->getWorldPosition());
+            if( (tPos + Punkt( 0, welt->getWorldInfo().size.y ) - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + Punkt( 0, welt->getWorldInfo().size.y ) - kam->getWorldPosition());
+            if( (tPos + Punkt( 0, -welt->getWorldInfo().size.y ) - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + Punkt( 0, -welt->getWorldInfo().size.y ) - kam->getWorldPosition());
+            if( (tPos + Punkt( welt->getWorldInfo().size.x, -welt->getWorldInfo().size.y ) - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + Punkt( welt->getWorldInfo().size.x, -welt->getWorldInfo().size.y ) - kam->getWorldPosition());
+            if( (tPos + Punkt( -welt->getWorldInfo().size.x, welt->getWorldInfo().size.y ) - kam->getWorldPosition()).getLengthSq() < str.getLengthSq() )
+                str = (tPos + Punkt( -welt->getWorldInfo().size.x, welt->getWorldInfo().size.y ) - kam->getWorldPosition());
             float faktor = str.getLength() / 200.f;
             if( faktor > 1.f )
                 faktor = 1.f;
@@ -1421,7 +1421,7 @@ bool SpielKlasse::tick( double zeit )
     return 1;
 }
 
-void SpielKlasse::render( Bild &zRObj )
+void SpielKlasse::render( Bild& zRObj )
 {
     if( !rendern )
         return;

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -7,7 +7,7 @@
 
 // Inhalt der Spieler Klasse aus Spieler.h
 // Konstruktor
-Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, UIInit &uiFactory, SpielerStr *zStr )
+Spieler::Spieler( KSGClient::InformationServerClient* zInfoK, UIInit& uiFactory, SpielerStr* zStr )
     : Model2DObject()
 {
     activeSkills = new RCArray< ActiveSkill >();
@@ -16,7 +16,7 @@ Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, UIInit &uiFactory,
     sNum = zStr->id;
     farbe = 0;
     zteam = 0;
-    info = dynamic_cast<KSGClient::InformationServerClient *>( zInfoK->getThis() );
+    info = dynamic_cast<KSGClient::InformationServerClient*>(zInfoK->getThis());
     name = 0;
     for( int i = 0; i < T_MAX; i++ )
         tastatur[ i ] = 0;
@@ -82,158 +82,158 @@ double Spieler::calculateBeschleunigung()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getBeschleunigungFactor();
         bonus += s->getBeschleunigungBonus();
     }
-    return ( beschleunigung + zteam->beschleunigung ) * factor + bonus;
+    return (beschleunigung + zteam->beschleunigung) * factor + bonus;
 }
 
 double Spieler::calculateReparatur()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getReparaturFactor();
         bonus += s->getReparaturBonus();
     }
-    return ( reparatur + zteam->reparatur ) * factor + bonus;
+    return (reparatur + zteam->reparatur) * factor + bonus;
 }
 
 double Spieler::calculateLaserIntensität()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getLaserIntensitätFactor();
         bonus += s->getLaserIntensitätBonus();
     }
-    return ( laserIntensität + zteam->laserIntensität ) * factor + bonus;
+    return (laserIntensität + zteam->laserIntensität) * factor + bonus;
 }
 
 double Spieler::calculateLaserEffizienz()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getLaserEffizienzFactor();
         bonus += s->getLaserEffizienzBonus();
     }
-    return ( laserEffizienz + zteam->laserEffizienz ) * factor + bonus;
+    return (laserEffizienz + zteam->laserEffizienz) * factor + bonus;
 }
 
 double Spieler::calculateAkkuLeistung()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getAkkuLeistungFactor();
         bonus += s->getAkkuLeistungBonus();
     }
-    return ( akkuLeistung + zteam->akkuLeistung ) * factor + bonus;
+    return (akkuLeistung + zteam->akkuLeistung) * factor + bonus;
 }
 
 double Spieler::calculateMaxEnergie()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getMaxEnergieFactor();
         bonus += s->getMaxEnergieBonus();
     }
-    return ( maxEnergie + zteam->maxEnergie ) * factor + bonus;
+    return (maxEnergie + zteam->maxEnergie) * factor + bonus;
 }
 
 double Spieler::calculateMaxStabilität()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getMaxStabilitätFactor();
         bonus += s->getMaxStabilitätBonus();
     }
-    return ( maxStabilität + zteam->maxStabilität ) * factor + bonus;
+    return (maxStabilität + zteam->maxStabilität) * factor + bonus;
 }
 
 double Spieler::calculateLaserTempo()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getLaserTempoFactor();
         bonus += s->getLaserTempoBonus();
     }
-    return ( laserTempo + zteam->laserTempo ) * factor + bonus;
+    return (laserTempo + zteam->laserTempo) * factor + bonus;
 }
 
 double Spieler::calculateWendigkeit()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getWendigkeitFactor();
         bonus += s->getWendigkeitBonus();
     }
-    return ( wendigkeit + zteam->wendigkeit ) * factor + bonus;
+    return (wendigkeit + zteam->wendigkeit) * factor + bonus;
 }
 
 double Spieler::calculateAntriebEffizienz()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getAntriebEffizienzFactor();
         bonus += s->getAntriebEffizienzBonus();
     }
-    return ( antriebEffizienz + zteam->antriebEffizienz ) * factor + bonus;
+    return (antriebEffizienz + zteam->antriebEffizienz) * factor + bonus;
 }
 
 double Spieler::calculateEnergieSchild()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getEnergieSchildFactor();
         bonus += s->getEnergieSchildBonus();
     }
-    return ( energieSchild + zteam->energieSchild ) * factor + bonus;
+    return (energieSchild + zteam->energieSchild) * factor + bonus;
 }
 
 double Spieler::calculateEnergieSchildEffizienz()
 {
     double factor = 1;
     double bonus = 0;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
     {
         factor *= s->getEnergieSchildEffizienzFactor();
         bonus += s->getEnergieSchildEffizienzBonus();
     }
-    return ( energieSchildEffizienz + zteam->energieSchildEffizienz ) * factor + bonus;
+    return (energieSchildEffizienz + zteam->energieSchildEffizienz) * factor + bonus;
 }
 
 double Spieler::calculateLaserCost()
 {
-    double kosten = ( calculateLaserIntensität() / 2 +
-                      calculateLaserTempo() / 9 ) *
-        ( 1 / ( calculateLaserEffizienz() / 25 ) );
+    double kosten = (calculateLaserIntensität() / 2 +
+                      calculateLaserTempo() / 9) *
+        (1 / (calculateLaserEffizienz() / 25));
     if( kosten < 1 )
         kosten = 1;
     return kosten;
 }
 
 // nicht constant
-void Spieler::addSkill( ActiveSkill *skill )
+void Spieler::addSkill( ActiveSkill* skill )
 {
     activeSkills->add( skill );
 }
@@ -244,57 +244,57 @@ void Spieler::useSkill( int id )
         activeSkills->z( id )->activate();
 }
 
-void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn )
+void Spieler::setModelData( Model2DData* data, Animation2DData* zFStart, Animation2DData* zFBurn )
 {
-    for( auto i = data->polygons->getIterator(); i; i++ )
+    for( auto i : *data->polygons )
     {
-        if( i._.name->istGleich( "engine_l" ) )
+        if( i.name->istGleich( "engine_l" ) )
         {
-            stL = *i._.schwerpunkt;
+            stL = *i.schwerpunkt;
             Vertex l, r;
             for( int j = 0; j < 4; j++ )
             {
-                if( i._.tKordinaten->get( j ).y == 1.f )
+                if( i.tKordinaten->get( j ).y == 1.f )
                 {
-                    if( i._.tKordinaten->get( j ).x == 0.f )
-                        l = i._.vertex->get( j );
-                    if( i._.tKordinaten->get( j ).x == 1.f )
-                        r = i._.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 0.f )
+                        l = i.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 1.f )
+                        r = i.vertex->get( j );
                 }
             }
-            kL = ( ( l + ( r - l ) * 0.5 ) - stL );
+            kL = ((l + (r - l) * 0.5) - stL);
         }
-        if( i._.name->istGleich( "engine_r" ) )
+        if( i.name->istGleich( "engine_r" ) )
         {
-            stR = *i._.schwerpunkt;
+            stR = *i.schwerpunkt;
             Vertex l, r;
             for( int j = 0; j < 4; j++ )
             {
-                if( i._.tKordinaten->get( j ).y == 1.f )
+                if( i.tKordinaten->get( j ).y == 1.f )
                 {
-                    if( i._.tKordinaten->get( j ).x == 0.f )
-                        l = i._.vertex->get( j );
-                    if( i._.tKordinaten->get( j ).x == 1.f )
-                        r = i._.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 0.f )
+                        l = i.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 1.f )
+                        r = i.vertex->get( j );
                 }
             }
-            kR = ( ( l + ( r - l ) * 0.5 ) - stR );
+            kR = ((l + (r - l) * 0.5) - stR);
         }
-        if( i._.name->istGleich( "engine_m" ) )
+        if( i.name->istGleich( "engine_m" ) )
         {
-            stM = *i._.schwerpunkt;
+            stM = *i.schwerpunkt;
             Vertex l, r;
             for( int j = 0; j < 4; j++ )
             {
-                if( i._.tKordinaten->get( j ).y == 1.f )
+                if( i.tKordinaten->get( j ).y == 1.f )
                 {
-                    if( i._.tKordinaten->get( j ).x == 0.f )
-                        l = i._.vertex->get( j );
-                    if( i._.tKordinaten->get( j ).x == 1.f )
-                        r = i._.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 0.f )
+                        l = i.vertex->get( j );
+                    if( i.tKordinaten->get( j ).x == 1.f )
+                        r = i.vertex->get( j );
                 }
             }
-            kM = ( ( l + ( r - l ) * 0.5 ) - stM );
+            kM = ((l + (r - l) * 0.5) - stM);
         }
     }
     kL.normalize();
@@ -302,17 +302,17 @@ void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animati
     kM.normalize();
     setModel( data );
     flammenM = new Textur2D();
-    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( zFStart->getThis() ) );
-    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( zFBurn->getThis() ) );
+    flammenM->addAnimationZ( dynamic_cast<Animation2DData*>(zFStart->getThis()) );
+    flammenM->addAnimationZ( dynamic_cast<Animation2DData*>(zFBurn->getThis()) );
     flammenL = new Textur2D();
-    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( zFStart->getThis() ) );
-    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( zFBurn->getThis() ) );
+    flammenL->addAnimationZ( dynamic_cast<Animation2DData*>(zFStart->getThis()) );
+    flammenL->addAnimationZ( dynamic_cast<Animation2DData*>(zFBurn->getThis()) );
     flammenR = new Textur2D();
-    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( zFStart->getThis() ) );
-    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( zFBurn->getThis() ) );
-    setTextur( dynamic_cast<Textur2D *>( flammenL->getThis() ), "engine_l" );
-    setTextur( dynamic_cast<Textur2D *>( flammenR->getThis() ), "engine_r" );
-    setTextur( dynamic_cast<Textur2D *>( flammenM->getThis() ), "engine_m" );
+    flammenR->addAnimationZ( dynamic_cast<Animation2DData*>(zFStart->getThis()) );
+    flammenR->addAnimationZ( dynamic_cast<Animation2DData*>(zFBurn->getThis()) );
+    setTextur( dynamic_cast<Textur2D*>(flammenL->getThis()), "engine_l" );
+    setTextur( dynamic_cast<Textur2D*>(flammenR->getThis()), "engine_r" );
+    setTextur( dynamic_cast<Textur2D*>(flammenM->getThis()), "engine_m" );
 }
 
 void Spieler::setAccountId( int accId )
@@ -323,21 +323,21 @@ void Spieler::setAccountId( int accId )
         nText->setText( *name );
 }
 
-void Spieler::setTeam( Team *zTeam )
+void Spieler::setTeam( Team* zTeam )
 {
     this->zteam = zTeam;
-    nText->setHintergrundFarbe( 0xA0000000 | ( zteam->farbe & 0x00FFFFFF ) );
+    nText->setHintergrundFarbe( 0xA0000000 | (zteam->farbe & 0x00FFFFFF) );
     nText->setRahmenFarbe( zteam->farbe );
 }
 
-void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
+void Spieler::setSpielerFarbe( int fc, Bild* zTextur )
 {
     farbe = fc;
     nText->setSchriftFarbe( fc );
-    Bild *shb = new Bild();
+    Bild* shb = new Bild();
     shb->neuBild( zTextur->getBreite(), zTextur->getHeight(), 0 );
     int maxP = shb->getBreite() * shb->getHeight();
-    int *buffer = zTextur->getBuffer();
+    int* buffer = zTextur->getBuffer();
     for( int i = 0; i < maxP; i++ )
     {
         if( buffer[ i ] )
@@ -346,7 +346,7 @@ void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
             shb->alphaPixelDP2D( i, buffer[ i ] );
         }
     }
-    Textur2D *textur = new Textur2D();
+    Textur2D* textur = new Textur2D();
     textur->setTexturZ( shb );
     setTextur( textur, "ship" );
 }
@@ -385,7 +385,7 @@ void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
     }
 }
 
-bool Spieler::tick( const WeltInfo &info, double tv )
+bool Spieler::tick( const WeltInfo& info, double tv )
 {
     bool ret = 0;
     if( !zteam )
@@ -399,7 +399,7 @@ bool Spieler::tick( const WeltInfo &info, double tv )
     flammenR->tick( tv );
     if( amLeben )
     {
-        for( auto s = activeSkills->getIterator(); s; s++ )
+        for( auto s : *activeSkills )
             s->tick( tv );
         schussAbk -= tv;
         energieAbk -= tv;
@@ -412,36 +412,36 @@ bool Spieler::tick( const WeltInfo &info, double tv )
             repAbk = 0;
         if( tastatur[ T_GAS ] )
         {
-            double treibstoff = 0.5 * ( calculateBeschleunigung() / 15 )
-                * tv * ( 100 / calculateAntriebEffizienz() );
+            double treibstoff = 0.5 * (calculateBeschleunigung() / 15)
+                * tv * (100 / calculateAntriebEffizienz());
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
-                factor = (float)( energie / treibstoff );
+                factor = (float)(energie / treibstoff);
             if( factor > 0 )
                 impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)tv * (float)calculateBeschleunigung() * factor );
             energie -= treibstoff * factor;
         }
         if( tastatur[ T_ROT_R ] )
         {
-            double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
-                * tv * ( 100 / calculateAntriebEffizienz() );
+            double treibstoff = 0.25 * (calculateWendigkeit() / 15)
+                * tv * (100 / calculateAntriebEffizienz());
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
-                factor = (float)( energie / treibstoff );
+                factor = (float)(energie / treibstoff);
             if( factor > 0 )
                 impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)tv * (float)calculateWendigkeit() * factor );
             energie -= treibstoff * factor;
         }
         if( tastatur[ T_ROT_L ] )
         {
-            double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
-                * tv * ( 100 / calculateAntriebEffizienz() );
+            double treibstoff = 0.25 * (calculateWendigkeit() / 15)
+                * tv * (100 / calculateAntriebEffizienz());
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
             if( treibstoff > energie )
-                factor = (float)( energie / treibstoff );
+                factor = (float)(energie / treibstoff);
             if( factor > 0 )
                 impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)tv * (float)calculateWendigkeit() * factor );
             energie -= treibstoff * factor;
@@ -470,7 +470,7 @@ bool Spieler::tick( const WeltInfo &info, double tv )
     return ret;
 }
 
-void Spieler::render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName )
+void Spieler::render( Mat3< float >& kamMat, Bild& zRObj, const char* kamName )
 {
     if( !amLeben )
         return;
@@ -480,25 +480,25 @@ void Spieler::render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName )
     renderLeben( kamMat, zRObj );
 }
 
-void Spieler::renderLeben( const Mat3< float > &kamMat, Bild &zRObj )
+void Spieler::renderLeben( const Mat3< float >& kamMat, Bild& zRObj )
 {
     if( !zteam || !amLeben )
         return;
-    nText->setPosition( (Punkt)( kamMat * getPosition() - Vertex( 76, ( zModel()->maxP.y * getSize() ) + 30 ) ) );
+    nText->setPosition( (Punkt)(kamMat * getPosition() - Vertex( 76, (zModel()->maxP.y * getSize()) + 30 )) );
     if( name )
         nText->setText( Text( name->getText() ) + " (" + level + ")" );
     nText->render( zRObj );
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, zteam->farbe );
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, zteam->farbe );
-    int l = (int)( stabilität * 100 / calculateMaxStabilität() * 1.5 + 0.5 );
+    int l = (int)(stabilität * 100 / calculateMaxStabilität() * 1.5 + 0.5);
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
-    int e = (int)( energie * 100 / calculateMaxEnergie() * 1.5 + 0.5 );
+    int e = (int)(energie * 100 / calculateMaxEnergie() * 1.5 + 0.5);
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFF0000FF );
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFF0000FF );
     zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFF0000FF );
-    int e2 = (int)( ( energie - calculateLaserCost() ) * 100 / calculateMaxEnergie() * 1.5 + 0.5 );
+    int e2 = (int)((energie - calculateLaserCost()) * 100 / calculateMaxEnergie() * 1.5 + 0.5);
     if( e2 > 0 )
     {
         zRObj.drawLinieV( nText->getX() + e2, nText->getY() + 26, 3, 0xFFFFFFFF );
@@ -578,15 +578,15 @@ void Spieler::setSkill( int art )
     }
 }
 
-void Spieler::nimmSchaden( double &intensität, int sLevel )
+void Spieler::nimmSchaden( double& intensität, int sLevel )
 {
     double originalIntens = intensität;
     double schieldVal = intensität - intensität / calculateEnergieSchild();
-    double schieldEVal = schieldVal / ( calculateEnergieSchildEffizienz() / 100 );
+    double schieldEVal = schieldVal / (calculateEnergieSchildEffizienz() / 100);
     if( schieldEVal > energie )
     {
         schieldEVal = energie;
-        schieldVal = schieldEVal * ( calculateEnergieSchildEffizienz() / 100 );
+        schieldVal = schieldEVal * (calculateEnergieSchildEffizienz() / 100);
     }
     intensität -= schieldVal;
     energie -= schieldEVal;
@@ -597,11 +597,11 @@ void Spieler::nimmSchaden( double &intensit
     if( stabilität > 0 )
     {
         float levelFactor = (float)sLevel / (float)level;
-        addEp( ( (float)originalIntens / 20 ) * levelFactor );
+        addEp( ((float)originalIntens / 20) * levelFactor );
     }
 }
 
-void Spieler::calcDeadPlayerObject( Laser *zSchuss )
+void Spieler::calcDeadPlayerObject( Laser* zSchuss )
 {
     Vertex hp;
     Polygon2D a;
@@ -610,25 +610,24 @@ void Spieler::calcDeadPlayerObject( Laser *zSchuss )
     Punkt pb;
     if( calcHitPoint( zSchuss->getPosition() - zSchuss->getSpeed(), zSchuss->getSpeed(), hp ) )
     {
-        if( zModel()->split( getObjectPos( hp ), getObjectDir( zSchuss->getSpeed() ) * 0.1f, "ship", a, b, pa, pb, []()
-        {
+        if( zModel()->split( getObjectPos( hp ), getObjectDir( zSchuss->getSpeed() ) * 0.1f, "ship", a, b, pa, pb, []() {
             return rand() / (double)RAND_MAX;
         } ) )
         {
-            hp = ( hp * getSize() ).rotation( getDrehung() ) + getPosition();
+            hp = (hp * getSize()).rotation( getDrehung() ) + getPosition();
             pa = pa.rotation( getDrehung() ) + getPosition();
             pb = pb.rotation( getDrehung() ) + getPosition();
-            Array< Polygon2D > *npaA = new Array< Polygon2D >();
+            Array< Polygon2D >* npaA = new Array< Polygon2D >();
             npaA->add( a );
-            Model2DData *npdA = new Model2DData();
+            Model2DData* npdA = new Model2DData();
             npdA->erstelleModell( npaA );
-            Array< Polygon2D > *npaB = new Array< Polygon2D >();
+            Array< Polygon2D >* npaB = new Array< Polygon2D >();
             npaB->add( b );
-            Model2DData *npdB = new Model2DData();
+            Model2DData* npdB = new Model2DData();
             npdB->erstelleModell( npaB );
             if( deadPlayer )
                 deadPlayer->release();
-            deadPlayer = new DeadPlayer( npdA, npdB, pa, pb, getSpeed() * ( rand() / (float)RAND_MAX ), getSpeed() * ( rand() / (float)RAND_MAX ), getDrehung(), getDrehung(), getDrehungSpeed() * ( rand() / (float)RAND_MAX ), getDrehungSpeed() * ( rand() / (float)RAND_MAX ), zTextur( "ship" ) );
+            deadPlayer = new DeadPlayer( npdA, npdB, pa, pb, getSpeed() * (rand() / (float)RAND_MAX), getSpeed() * (rand() / (float)RAND_MAX), getDrehung(), getDrehung(), getDrehungSpeed() * (rand() / (float)RAND_MAX), getDrehungSpeed() * (rand() / (float)RAND_MAX), zTextur( "ship" ) );
         }
     }
 }
@@ -651,7 +650,7 @@ void Spieler::addKill( int sLevel, bool erf )
         maxReinkAbk = 5;
 }
 
-DeadPlayer *Spieler::sterben()
+DeadPlayer* Spieler::sterben()
 {
     amLeben = 0;
     setCollision( 0 );
@@ -660,12 +659,12 @@ DeadPlayer *Spieler::sterben()
     reinkAbk += maxReinkAbk;
     maxReinkAbk++;
     punkte--;
-    return deadPlayer ? dynamic_cast<DeadPlayer *>( deadPlayer->getThis() ) : 0;
+    return deadPlayer ? dynamic_cast<DeadPlayer*>(deadPlayer->getThis()) : 0;
 }
 
 void Spieler::wiederbelebung()
 {
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
         s->reset();
     setPosition( startPos );
     reinkAbk = maxReinkAbk * 2;
@@ -699,7 +698,7 @@ void Spieler::addTreffer( float indens, int sLevel, bool erf )
     treffer++;
     float levelFactor = (float)sLevel / (float)level;
     if( erf )
-        addEp( ( indens / 10 ) * levelFactor );
+        addEp( (indens / 10) * levelFactor );
 }
 
 void Spieler::addEp( float ep )
@@ -754,7 +753,7 @@ void Spieler::save()
     last.kills = kills;
     last.tode = tode;
     last.level = level;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
         s->save();
 }
 
@@ -799,7 +798,7 @@ void Spieler::load()
     kills = last.kills;
     tode = last.tode;
     level = last.level;
-    for( auto s = activeSkills->getIterator(); s; s++ )
+    for( auto s : *activeSkills )
         s->load();
 }
 
@@ -819,12 +818,12 @@ int Spieler::getAccountId() const
     return accountId;
 }
 
-Text *Spieler::getName() const
+Text* Spieler::getName() const
 {
-    return name ? dynamic_cast<Text *>( name->getThis() ) : 0;
+    return name ? dynamic_cast<Text*>(name->getThis()) : 0;
 }
 
-Text *Spieler::zName() const
+Text* Spieler::zName() const
 {
     return name;
 }
@@ -845,7 +844,7 @@ int Spieler::getSpielerNummer() const
     return sNum;
 }
 
-Team *Spieler::zTeam() const
+Team* Spieler::zTeam() const
 {
     return zteam;
 }

Asteroids/Spiel/SpielerGUI/SpielerGUI.cpp

@@ -16,7 +16,7 @@ int getStellen( double d )
 
 // Inhalt der Ship Klasse aus Ship.h
 // Konstruktor
-SpielerGUI::SpielerGUI( UIInit &uiFactory )
+SpielerGUI::SpielerGUI( UIInit& uiFactory )
     : ReferenceCounter()
 {
     player = 0;
@@ -84,7 +84,7 @@ SpielerGUI::SpielerGUI( UIInit &uiFactory )
     netzwerkSkill->removeStyle( Knopf::Style::Erlaubt );
     skillPoints = initTextFeld( 5, 355, 180, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
     speed = initTextFeld( 5, 380, 180, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    renderer = new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
+    renderer = new TextRenderer( dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()) );
 }
 
 // Destruktor
@@ -127,10 +127,10 @@ SpielerGUI::~SpielerGUI()
 }
 
 // nicht constant
-void SpielerGUI::update( Spieler *zSpieler )
+void SpielerGUI::update( Spieler* zSpieler )
 {
     if( !player )
-        player = dynamic_cast<Spieler *>( zSpieler->getThis() );
+        player = dynamic_cast<Spieler*>(zSpieler->getThis());
     spieler->setText( zSpieler->name->getText() );
     spieler->setSchriftFarbe( zSpieler->farbe );
     Text txt;
@@ -147,8 +147,8 @@ void SpielerGUI::update( Spieler *zSpieler )
     stabilität->setText( txt );
     stabilität->setSchriftFarbe( pos, txt.getLength(), 0xFF00FF00 );
     stabilitätB->reset();
-    stabilitätB->setAktionAnzahl( (int)( zSpieler->maxStabilität + zSpieler->zteam->maxStabilität ) );
-    stabilitätB->aktionPlus( (int)( zSpieler->stabilität ) );
+    stabilitätB->setAktionAnzahl( (int)(zSpieler->maxStabilität + zSpieler->zteam->maxStabilität) );
+    stabilitätB->aktionPlus( (int)(zSpieler->stabilität) );
     txt.setPrecision( getStellen( zSpieler->energie ) + 2 );
     txt = zSpieler->energie;
     txt += "/";
@@ -162,8 +162,8 @@ void SpielerGUI::update( Spieler *zSpieler )
     energie->setText( txt );
     energie->setSchriftFarbe( pos, txt.getLength(), 0xFF00FF00 );
     energieB->reset();
-    energieB->setAktionAnzahl( (int)( zSpieler->maxEnergie + zSpieler->zteam->maxEnergie ) );
-    energieB->aktionPlus( (int)( zSpieler->energie ) );
+    energieB->setAktionAnzahl( (int)(zSpieler->maxEnergie + zSpieler->zteam->maxEnergie) );
+    energieB->aktionPlus( (int)(zSpieler->energie) );
     txt = "Reparatur:";
     txt.setPrecision( getStellen( zSpieler->reparatur ) + 2 );
     txt += zSpieler->reparatur;
@@ -284,7 +284,7 @@ void SpielerGUI::update( Spieler *zSpieler )
     skillPoints->setText( Text( zSpieler->skillPunkte ) += " Punkte" );
 }
 
-int SpielerGUI::doPublicMausEreignis( MausEreignis &me )
+int SpielerGUI::doPublicMausEreignis( MausEreignis& me )
 {
     me.mx -= ram->getX();
     me.my -= ram->getY();
@@ -359,7 +359,7 @@ bool SpielerGUI::tick( double tickVal )
     return ret;
 }
 
-void SpielerGUI::render( Bild &zRObj )
+void SpielerGUI::render( Bild& zRObj )
 {
     ram->setPosition( Punkt( zRObj.getBreite() - 210, 10 ) );
     zRObj.alphaRegion( ram->getX() + 1, ram->getY() + 1, ram->getBreite() - 2, ram->getHeight() - 2, 0xA0000000 );
@@ -409,7 +409,7 @@ void SpielerGUI::render( Bild &zRObj )
         zRObj.drawLinieH( 5, ram->getHeight() - 7, ram->getBreite() - 12, 0xFFFFFFFF );
         zRObj.drawLinieV( 5, ram->getHeight() - 12, 5, 0xFFFFFFFF );
         zRObj.drawLinieV( ram->getBreite() - 7, ram->getHeight() - 12, 5, 0xFFFFFFFF );
-        zRObj.fillRegion( 5, ram->getHeight() - 12, (int)( ( ram->getBreite() - 12 ) * ( player->getEp() / player->getMaxEp() ) ), 5, 0xFFFFFFFF );
+        zRObj.fillRegion( 5, ram->getHeight() - 12, (int)((ram->getBreite() - 12) * (player->getEp() / player->getMaxEp())), 5, 0xFFFFFFFF );
     }
     zRObj.releaseDrawOptions();
     if( player )
@@ -418,7 +418,7 @@ void SpielerGUI::render( Bild &zRObj )
         int x = zRObj.getBreite() - anz * 51 - 1 - 220;
         int y = zRObj.getHeight() - 56;
         int index = 0;
-        for( auto s = player->activeSkills->getIterator(); s; s++ )
+        for( auto s : *player->activeSkills )
         {
             s->render( x + 1, y + 1, zRObj );
             zRObj.drawLinieH( x, y, 51, 0xFFFFFFFF );

Asteroids/Spiel/Team/Team.cpp

@@ -3,7 +3,7 @@
 
 // Inhalt der Team Klasse aus Team.h
 // Konstruktor
-Team::Team( int f, char *n, TeamStr *zStr )
+Team::Team( int f, char* n, TeamStr* zStr )
     : ReferenceCounter()
 {
     id = zStr->id;
@@ -55,7 +55,7 @@ void Team::reset()
 double Team::getMaxEnergieBonus() const
 {
     double ret = maxEnergieS;
-    for( auto i = spieler->getIterator(); i && i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamMaxEnergieBonus();
     return ret;
 }
@@ -63,7 +63,7 @@ double Team::getMaxEnergieBonus() const
 double Team::getMaxStabilitätBonus() const
 {
     double ret = maxStabilitätS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamMaxStabilitätBonus();
     return ret;
 }
@@ -71,7 +71,7 @@ double Team::getMaxStabilit
 double Team::getReperaturBonus() const
 {
     double ret = reparaturS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamReparaturBonus();
     return ret;
 }
@@ -79,7 +79,7 @@ double Team::getReperaturBonus() const
 double Team::getLaserIntensitätBonus() const
 {
     double ret = laserIntensitätS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamLaserIntensitätBonus();
     return ret;
 }
@@ -87,7 +87,7 @@ double Team::getLaserIntensit
 double Team::getLaserEffizienzBonus() const
 {
     double ret = laserEffizienzS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamLaserEffizienzBonus();
     return ret;
 }
@@ -95,7 +95,7 @@ double Team::getLaserEffizienzBonus() const
 double Team::getAkkuLeistungBonus() const
 {
     double ret = akkuLeistungS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamAkkuLeistungBonus();
     return ret;
 }
@@ -103,7 +103,7 @@ double Team::getAkkuLeistungBonus() const
 double Team::getLaserTempoBonus() const
 {
     double ret = laserTempoS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamLaserTempoBonus();
     return ret;
 }
@@ -111,7 +111,7 @@ double Team::getLaserTempoBonus() const
 double Team::getBeschleunigungBonus() const
 {
     double ret = beschleunigungS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamBeschleunigungBonus();
     return ret;
 }
@@ -119,7 +119,7 @@ double Team::getBeschleunigungBonus() const
 double Team::getWendigkeitBonus() const
 {
     double ret = wendigkeitS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamWendigkeitBonus();
     return ret;
 }
@@ -127,7 +127,7 @@ double Team::getWendigkeitBonus() const
 double Team::getAntriebEffizienzBonus() const
 {
     double ret = antriebEffizienzS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamAntriebEffizienzBonus();
     return ret;
 }
@@ -135,7 +135,7 @@ double Team::getAntriebEffizienzBonus() const
 double Team::getEnergieSchildBonus() const
 {
     double ret = energieSchildS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamEnergieSchildBonus();
     return ret;
 }
@@ -143,7 +143,7 @@ double Team::getEnergieSchildBonus() const
 double Team::getEnergieSchildEffizienzBonus() const
 {
     double ret = energieSchildEffizienzS;
-    for( auto i = spieler->getIterator(); i; i++ )
+    for( auto i : *spieler )
         ret += i->getTeamEnergieSchildEffizienzBonus();
     return ret;
 }