use framework ui init and reference counting

Asteroids/Editor/Abstract/View.cpp

@@ -1,26 +1,14 @@
 #include "View.h"
 
+using namespace Framework;
+
 View::View()
-{
-    ref = 1;
-}
+    : ReferenceCounter()
+{}
 
 View::~View()
 {}
 
-View *View::getThis()
-{
-    ref++;
-    return this;
-}
-
-View *View::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
-}
-
 
 ActionView::ActionView( std::function< void( Model * ) > f )
     : View()

Asteroids/Editor/Abstract/View.h

@@ -1,20 +1,17 @@
 #pragma once
 
 #include <functional>
+#include <ReferenceCounter.h>
 
 class Model;
 
-class View
+class View : public virtual Framework::ReferenceCounter
 {
-protected:
-    int ref;
 
 public:
     View();
     virtual ~View();
     virtual void update( Model *m ) = 0;
-    View *getThis();
-    View *release();
 };
 
 class ActionView : public View

Asteroids/Editor/Editor.cpp

@@ -11,14 +11,15 @@ using namespace Editor;
 // Inhalt der Editor Klasse aus Editor.h
 // Konstruktor
 AsteroidsEditor::AsteroidsEditor()
+    : ReferenceCounter()
 {
+    uiFactory.initParam.schrift = 0;
     kamera = new Kamera2D();
     minimap = new Kamera2D();
     minimap->setSize( 200, 200 );
     minimap->setStyle( ZeichnungHintergrund::Style::Sichtbar | ZeichnungHintergrund::Style::Rahmen );
     minimap->setRahmenFarbe( 0xFFFFFFFF );
     minimap->setName( "minimap" );
-    schrift = 0;
     klient = 0;
     laden = 0;
     i = 0;
@@ -30,7 +31,6 @@ AsteroidsEditor::AsteroidsEditor()
     daten = 0;
     moveObj = 0;
     rotObj = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -38,8 +38,6 @@ AsteroidsEditor::~AsteroidsEditor()
 {
     if( sts )
         sts->release();
-    if( schrift )
-        schrift->release();
     if( klient )
         klient->release();
     if( laden )
@@ -47,7 +45,10 @@ AsteroidsEditor::~AsteroidsEditor()
     if( i )
         i->release();
     if( daten )
+    {
+        daten->stopWork();
         daten->release();
+    }
     dialogs->release();
     kamera->release();
     minimap->release();
@@ -60,17 +61,20 @@ void AsteroidsEditor::ladeKarte()
     sts = new SpielerTeamStruktur();
     klient->getSpielerTeamStruktur( sts );
     if( daten )
+    {
+        daten->stopWork();
         daten->release();
-    daten = new KarteDaten( (EditorKlient *)klient->getThis(), sts );
-    i->setDaten( (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( daten->zWelt()->getWorldInfo().size.x, daten->zWelt()->getWorldInfo().size.y );
+    minimap->lookAtWorldArea( (float)daten->zWelt()->getWorldInfo().size.x, (float)daten->zWelt()->getWorldInfo().size.y );
     kamera->setWelt( daten->getWelt(), 1 );
 }
 
 // nicht constant
-void AsteroidsEditor::addDialog( Dialog * d )
+void AsteroidsEditor::addDialog( Dialog *d )
 {
     c.lock();
     dialogs->add( d );
@@ -78,23 +82,21 @@ void AsteroidsEditor::addDialog( Dialog * d )
 }
 
 // nicht constant
-void AsteroidsEditor::setSchrift( Schrift * schrift )
+void AsteroidsEditor::setUIFactory( UIInit &uiFactory )
 {
-    if( this->schrift )
-        this->schrift->release();
-    this->schrift = schrift;
+    this->uiFactory = uiFactory;
     if( !i && windowSize != Punkt() )
-        i = new Interface( schrift, windowSize );
+        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();
@@ -107,32 +109,32 @@ void AsteroidsEditor::setSichtbar()
     Punkt mS = windowSize;
     if( windowSize != Punkt() )
     {
-        EditorKlient *k = klient->getThis();
-        TextRenderer *zS = new TextRenderer( 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( zS->getThis(), t, mS, 0 ) );
+                        this->addDialog( new Nachricht( dynamic_cast<TextRenderer *>( zS->getThis() ), uiFactory, t, mS, 0 ) );
                     }
                     ladeKarte();
                     this->status = INITIALIZED;
                 };
-                this->addDialog( new Frage( zS->getThis(), "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,7 +146,7 @@ void AsteroidsEditor::setSichtbar()
             {
                 Status *st = &status;
                 this->status = INITIALIZED;
-                this->addDialog( new Nachricht( zS->getThis(), 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();
@@ -153,7 +155,7 @@ 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++ )
@@ -167,14 +169,14 @@ void AsteroidsEditor::doPublicMausEreignis( MausEreignis & me )
         if( i->hatVerlassen() && status == INITIALIZED && !dialogActive && me.id == ME_RLinks )
         {
             status = WARTEND;
-            EditorKlient *k = klient->getThis();
-            TextRenderer *zS = new TextRenderer( 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( zS->getThis(), 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
@@ -258,7 +260,7 @@ 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++ )
@@ -294,7 +296,7 @@ bool AsteroidsEditor::tick( double z )
     }
     else if( alpha != 255 )
     {
-        if( laden &&laden->istSichtbar() )
+        if( laden && laden->istSichtbar() )
             laden->setSichtbar( 0 );
         if( alpha + 100 * z > 255 )
             alpha = 255;
@@ -316,15 +318,15 @@ bool AsteroidsEditor::tick( double z )
     return tmp;
 }
 
-void AsteroidsEditor::render( Bild & zRObj )
+void AsteroidsEditor::render( Bild &zRObj )
 {
     if( windowSize == Punkt() )
     {
         if( status != EXIT )
             windowSize = zRObj.getSize();
         setSichtbar();
-        if( !i && schrift )
-            i = new Interface( schrift, windowSize );
+        if( !i && uiFactory.initParam.schrift )
+            i = new Interface( uiFactory, windowSize );
     }
     zRObj.setAlpha( alpha );
     kamera->setSize( zRObj.getSize() );
@@ -352,19 +354,4 @@ void AsteroidsEditor::render( Bild & zRObj )
 bool AsteroidsEditor::hatVerlassen( bool jetzt ) const
 {
     return status == EXIT;
-}
-
-// Reference Counting
-EditorV *AsteroidsEditor::getThis()
-{
-    ref++;
-    return this;
-}
-
-EditorV *AsteroidsEditor::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Asteroids/Editor/Editor.h

@@ -22,11 +22,11 @@ namespace Editor
             EXIT
         };
         Status status;
-        Schrift *schrift;
+        UIInit uiFactory;
         EditorKlient *klient;
         Animation2D *laden;
         Interface *i;
-        Array< Dialog* > *dialogs;
+        Array< Dialog * > *dialogs;
         Critical c;
         Punkt windowSize;
         SpielerTeamStruktur *sts;
@@ -38,7 +38,6 @@ namespace Editor
         EditorObject *rotObj;
         unsigned char alpha;
         bool rend;
-        int ref;
 
         void ladeKarte();
 
@@ -49,7 +48,7 @@ namespace Editor
         ~AsteroidsEditor();
         // nicht constant
         void addDialog( Dialog *d );
-        void setSchrift( Schrift *schrift ) override;
+        void setUIFactory( UIInit &uiFactory ) override;
         void setKlient( KSGClient::EditorServerClient *ekv ) override;
         void setLadeAnimation( Animation2D *la ) override;
         void setSichtbar() override;
@@ -59,9 +58,6 @@ namespace Editor
         void render( Bild &zRObj ) override;
         // constant
         bool hatVerlassen( bool jetzt ) const override;
-        // Reference Counting
-        EditorV *getThis() override;
-        EditorV *release() override;
     };
 }
 

Asteroids/Editor/Interface/Dialogs/Dialog.h

@@ -2,6 +2,7 @@
 
 #include <Fenster.h>
 #include <Schrift.h>
+#include <UIInitialization.h>
 
 using namespace Framework;
 

Asteroids/Editor/Interface/Dialogs/Frage.cpp

@@ -12,7 +12,7 @@
 //  rightAk: Ein Zeiger auf eine Funktion die beim wählen der Rechten Antwort aufgerufen wird
 //  abbruchAk: Ein Zeiger auf eine Funktion die beim Schließen des Fensters aufgerufen wird
 //  maxSize: Die Bildschirmgröße in Pixeln
-Frage::Frage( TextRenderer *tr, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize )
+Frage::Frage( TextRenderer *tr, UIInit &uiFactory, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize )
     : Dialog( tr )
 {
     Text *tmp = new Text( frage );
@@ -22,18 +22,18 @@ Frage::Frage( TextRenderer *tr, char *frage, char *left, char *right, std::funct
     int hö = tr->getTextHeight( tmp->getText() );
     setSize( br + 12, hö + 63 );
     setPosition( maxSize / 2 - getSize() / 2 );
-    
-    TextFeld *text = initTextFeld( 5, 5, br, hö, tr->zSchrift(), TextFeld::Style::Text, tmp->getText() );
+
+    TextFeld *text = initTextFeld( 5, 5, br, hö, uiFactory, TextFeld::Style::Text, tmp->getText() );
     addMember( text );
     tmp->release();
-    Knopf *r = initKnopf( br - 94, hö + 22, 100, 20, tr->zSchrift(), Knopf::Style::Normal, right );
+    Knopf *r = initKnopf( br - 94, hö + 22, 100, 20, uiFactory, Knopf::Style::Normal, right );
     addMember( r );
-    Knopf *l = initKnopf( br - 199, hö + 22, 100, 20, tr->zSchrift(), Knopf::Style::Normal, left );
+    Knopf *l = initKnopf( br - 199, hö + 22, 100, 20, uiFactory, Knopf::Style::Normal, left );
     addMember( l );
 
     bool *verl = &verlassen;
 
-    r->setMausEreignis( [ verl, rightAk ]( void *param, void *obj, MausEreignis me ) -> bool
+    r->setMausEreignis( [verl, rightAk]( void *param, void *obj, MausEreignis me ) -> bool
     {
         if( me.id == ME_RLinks && !me.verarbeitet && !*verl )
         {
@@ -43,7 +43,7 @@ Frage::Frage( TextRenderer *tr, char *frage, char *left, char *right, std::funct
         }
         return 1;
     } );
-    l->setMausEreignis( [ verl, leftAk ]( void *param, void *obj, MausEreignis me ) -> bool
+    l->setMausEreignis( [verl, leftAk]( void *param, void *obj, MausEreignis me ) -> bool
     {
         if( me.id == ME_RLinks && !me.verarbeitet && !*verl )
         {
@@ -53,7 +53,7 @@ Frage::Frage( TextRenderer *tr, char *frage, char *left, char *right, std::funct
         }
         return 1;
     } );
-    setClosingMe( [ verl, abbruchAk ]( void *param, void *obj, MausEreignis me ) -> bool
+    setClosingMe( [verl, abbruchAk]( void *param, void *obj, MausEreignis me ) -> bool
     {
         if( me.id == ME_RLinks && !me.verarbeitet && !*verl )
         {

Asteroids/Editor/Interface/Dialogs/Frage.h

@@ -15,7 +15,7 @@ public:
     //  rightAk: Ein Zeiger auf eine Funktion die beim wählen der Rechten Antwort aufgerufen wird
     //  abbruchAk: Ein Zeiger auf eine Funktion die beim Schließen des Fensters aufgerufen wird
     //  maxSize: Die Bildschirmgröße in Pixeln
-    Frage( TextRenderer *tr, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize );
+    Frage( TextRenderer *tr, UIInit &uiFactory, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize );
     // Destruktor
     ~Frage();
 };

Asteroids/Editor/Interface/Dialogs/Nachricht.cpp

@@ -12,7 +12,7 @@
 //  tr: Die zu verwendende Schrift
 //  nachricht: Der Fehler, der angezeigt werden soll
 //  maxSize: Die Bildschirmgröße in Pixeln
-Nachricht::Nachricht( TextRenderer *tr, char *nachricht, Punkt maxSize, std::function< void() > onClose )
+Nachricht::Nachricht( TextRenderer *tr, UIInit &uiFactory, char *nachricht, Punkt maxSize, std::function< void() > onClose )
     : Dialog( tr )
 {
     Text *tmp = new Text( nachricht );
@@ -23,14 +23,14 @@ Nachricht::Nachricht( TextRenderer *tr, char *nachricht, Punkt maxSize, std::fun
     setSize( br + 12, hö + 63 );
     setPosition( maxSize / 2 - getSize() / 2 );
 
-    TextFeld *text = initTextFeld( 5, 5, br, hö, tr->zSchrift(), TextFeld::Style::Text, tmp->getText() );
+    TextFeld *text = initTextFeld( 5, 5, br, hö, uiFactory, TextFeld::Style::Text, tmp->getText() );
     addMember( text );
     tmp->release();
-    Knopf *ok = initKnopf( br - 94, hö + 12, 100, 20, tr->zSchrift(), Knopf::Style::Normal, "Ok" );
+    Knopf *ok = initKnopf( br - 94, hö + 12, 100, 20, uiFactory, Knopf::Style::Normal, "Ok" );
     addMember( ok );
     bool *verl = &verlassen;
 
-    auto me = [ verl, onClose ]( void *param, void *obj, MausEreignis me ) -> bool
+    auto me = [verl, onClose]( void *param, void *obj, MausEreignis me ) -> bool
     {
         if( me.id == ME_RLinks && !me.verarbeitet )
         {

Asteroids/Editor/Interface/Dialogs/Nachricht.h

@@ -12,7 +12,7 @@ public:
     //  tr: Die zu verwendende Schrift
     //  nachricht: Der Fehler, der angezeigt werden soll
     //  maxSize: Die Bildschirmgröße in Pixeln
-    Nachricht( TextRenderer *tr, char *nachricht, Punkt maxSize, std::function< void() > onClose );
+    Nachricht( TextRenderer *tr, UIInit &uiFactory, char *nachricht, Punkt maxSize, std::function< void() > onClose );
     // Destruktor
     ~Nachricht();
 };

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, 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" );
@@ -22,11 +22,11 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor
     m2v->setSize( 390, 390 );
     m2v->setPosition( 5, 30 );
 
-    bv = initBildZ( 5, 30, 390, 390, BildZ::Style::normal & ~Zeichnung::Style::Sichtbar, 0 );
-    addMember( bv->getThis() );
-    addMember( m2v->getThis() );
+    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() ) );
 
-    paths = initAuswahlBox( 5, 5, 390, 20, tr->zSchrift(), AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    paths = initAuswahlBox( 5, 5, 390, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     if( ( typ | ALLOW_RESOURCES ) == typ )
     {
         int anz = daten->getResourceAnzahl();
@@ -41,7 +41,7 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor
     }
     if( ( typ | ALLOW_NEW_RESOURCES ) == typ )
     {
-        daten->loadUnusedResourcePaths( [ this, typ ]( RCArray< Text > * unusedPaths )
+        daten->loadUnusedResourcePaths( [this, typ]( RCArray< Text > *unusedPaths )
         {
             for( auto p = unusedPaths->getIterator(); p; p++ )
             {
@@ -71,7 +71,7 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor
         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,9 +95,9 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor
         }
     } );
 
-    Knopf *ok = initKnopf( 295, 425, 100, 20, tr->zSchrift(), 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 )
         {
@@ -106,9 +106,9 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor
         }
         return 1;
     } );
-    Knopf *abbrechen = initKnopf( 5, 425, 100, 20, tr->zSchrift(), 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 )
         {
@@ -120,7 +120,7 @@ ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor
     abbrechen->setMausEreignis( abbruchAction );
     setClosingMe( abbruchAction );
     bool *verl = &verlassen;
-    addMember( paths->getThis() );
+    addMember( dynamic_cast<AuswahlBox *>( paths->getThis() ) );
     if( !paths->getEintragAnzahl() )
     {
         removeStyle( Zeichnung::Style::Sichtbar );

Asteroids/Editor/Interface/Dialogs/ResourceDialog.h

@@ -36,7 +36,7 @@ public:
     //  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( TextRenderer *tr, ResourceDialogType typ, Editor::KarteDaten *daten, std::function< void( const char *path ) > onClose, Punkt screenSize );
+    ResourceDialog( TextRenderer *tr, UIInit &uiFactory, ResourceDialogType typ, Editor::KarteDaten *daten, std::function< void( const char *path ) > onClose, Punkt screenSize );
     // Destruktor
     ~ResourceDialog();
 };

Asteroids/Editor/Interface/Interface.cpp

@@ -10,14 +10,14 @@ using namespace Editor;
 // Inhalt der Interface Klasse aus Interface.h
 // Konstruktor
 //  zS: Ein Zeiger auf die zu verwendende Schrift
-Interface::Interface( Schrift *zS, Punkt maxSize )
+Interface::Interface( UIInit &uiFactory, Punkt maxSize )
+    : ReferenceCounter()
 {
-    beenden = initKnopf( 10, 10, 100, 20, zS, Knopf::Style::Normal, "beenden" );
-    right = new RightTools( zS, maxSize );
+    beenden = initKnopf( 10, 10, 100, 20, uiFactory, Knopf::Style::Normal, "beenden" );
+    right = new RightTools( uiFactory, maxSize );
     verlassen = 0;
-    schrift = zS->getThis();
+    this->uiFactory = uiFactory;
     daten = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -25,24 +25,23 @@ Interface::~Interface()
 {
     if( daten )
         daten->release();
-    schrift->release();
     beenden->release();
     right->release();
 }
 
-void Interface::setDaten( KarteDaten * daten )
+void Interface::setDaten( KarteDaten *daten )
 {
     if( this->daten )
         this->daten->release();
     this->daten = daten;
-    right->addTool( new SpielerTool( schrift, (KarteDaten *)daten->getThis() ), "Spieler" );
-    right->addTool( new TeamTool( schrift, (KarteDaten *)daten->getThis() ), "Teams" );
-    right->addTool( new ObjektTool( schrift, (KarteDaten *)daten->getThis() ), "Objekte" );
+    right->addTool( new SpielerTool( uiFactory, dynamic_cast<KarteDaten *>( daten->getThis() ) ), "Spieler" );
+    right->addTool( new TeamTool( uiFactory, dynamic_cast<KarteDaten *>( daten->getThis() ) ), "Teams" );
+    right->addTool( new ObjektTool( uiFactory, dynamic_cast<KarteDaten *>( daten->getThis() ) ), "Objekte" );
 }
 
 // Verarbeitet eine Mausnachricht
 //  me: Die Nachricht die verarbeitet werden soll
-void Interface::doPublicMausEreignis( MausEreignis & me )
+void Interface::doPublicMausEreignis( MausEreignis &me )
 {
     bool vera = me.verarbeitet;
     beenden->doPublicMausEreignis( me );
@@ -55,7 +54,7 @@ void Interface::doPublicMausEreignis( MausEreignis & me )
 
 // Verarbeitet eine Tastaturnachricht
 //  te: Die Nachricht die verarbeitet werden soll
-void Interface::doTastaturEreignis( TastaturEreignis & te )
+void Interface::doTastaturEreignis( TastaturEreignis &te )
 {
     right->doTastaturEreignis( te );
 }
@@ -69,7 +68,7 @@ bool Interface::tick( double time )
 
 // Zeichnet das Interface nach uRObj
 //  zRObj: Das Bild in das gezeichnet werden soll
-void Interface::render( Bild & zRObj )
+void Interface::render( Bild &zRObj )
 {
     beenden->render( zRObj );
     right->render( zRObj );
@@ -85,21 +84,4 @@ void Interface::reset()
 bool Interface::hatVerlassen() const
 {
     return verlassen;
-}
-
-// erhöht den Reference Counter
-//  return: this
-Interface *Interface::getThis()
-{
-    ref++;
-    return this;
-}
-
-// verringert den Reference Counter und löscht das Objekt wenn es nicht mehr gebraucht wird.
-//  return: 0
-Interface *Interface::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
 }

Asteroids/Editor/Interface/Interface.h

@@ -12,17 +12,16 @@ namespace Editor
     class Interface : public ZeichnungHintergrund
     {
     private:
-        Knopf * beenden;
+        Knopf *beenden;
         RightTools *right;
         KarteDaten *daten;
-        Schrift *schrift;
+        UIInit uiFactory;
         bool verlassen;
-        int ref;
 
     public:
         // Konstruktor
         //  zS: Ein Zeiger auf die zu verwendende Schrift
-        Interface( Schrift *zS, Punkt maxSize );
+        Interface( UIInit &uiFactory, Punkt maxSize );
         // Destruktor
         ~Interface();
         void setDaten( KarteDaten *daten );
@@ -40,11 +39,5 @@ namespace Editor
         void reset();
         // Gibt zurück, ob der Benutzer den Editor verlassen möchte
         bool hatVerlassen() const;
-        // erhöht den Reference Counter
-        //  return: this
-        Interface *getThis();
-        // verringert den Reference Counter und löscht das Objekt wenn es nicht mehr gebraucht wird.
-        //  return: 0
-        Interface *release();
     };
 }

Asteroids/Editor/Interface/RightTools/ObjektOptionen/ObjektOptionen.cpp

@@ -4,23 +4,16 @@
 
 using namespace Editor;
 
-ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
+ObjektTool::ObjektTool( UIInit &uiFactory, KarteDaten *daten )
     : RightTool()
 {
     dialog = 0;
     dialog2 = 0;
+    this->uiFactory = uiFactory;
     this->daten = daten;
-    schrift = zSchrift->getThis();
-    objekte = new AuswahlListe();
+    objekte = uiFactory.createAuswahlListe( uiFactory.initParam );
     objekte->setStyle( ( AuswahlListe::Style::Normal & ~AuswahlListe::Style::FeldHAlpha ) | AuswahlBox::Style::VScroll );
-    objekte->setRahmenFarbe( 0xFFFFFFFF );
-    objekte->setRahmenBreite( 1 );
-    objekte->setSchriftZ( zSchrift->getThis() );
     objekte->setSize( 290, 200 );
-    objekte->setAAFFarbe( 0x5500FF00 );
-    objekte->setAAFStrength( -5 );
-    objekte->setALRFarbe( 0xFF00FF00 );
-    objekte->setALRBreite( 1 );
     objekte->setVertikalKlickScroll( 1 );
     int anz = daten->getObjektAnzahl();
     for( int i = 0; i < anz; i++ )
@@ -28,15 +21,15 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
         const ObjektDaten *o = daten->getObjekt( i );
         objekte->addEintrag( Text( o->id ) );
     }
-    neuesObjekt = initKnopf( 0, 205, 290, 20, zSchrift, Knopf::Style::Normal, "Neues Objekt erstellen" );
-    neuesObjekt->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    neuesObjekt = initKnopf( 0, 205, 290, 20, uiFactory, Knopf::Style::Normal, "Neues Objekt erstellen" );
+    neuesObjekt->setMausEreignis( [this, &uiFactory]( void *p, void *o, MausEreignis me )
     {
         if( me.id == ME_RLinks )
         {
             cs.lock();
             if( dialog )
                 dialog->release();
-            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_MODEL2D, (KarteDaten *)this->daten->getThis(), [ this ]( const char *modelPath )
+            dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this, &uiFactory]( const char *modelPath )
             {
                 if( !modelPath )
                     return;
@@ -44,13 +37,13 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
                 if( dialog2 )
                     dialog2->release();
                 dialog2 = dialog;
-                dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_TEXTUR, (KarteDaten *)this->daten->getThis(), [ this, modelPath ]( const char *texturPath )
+                dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this, modelPath]( const char *texturPath )
                 {
                     if( !texturPath )
                         return;
-                    this->daten->getResourceIdFromPath( modelPath, [ this, texturPath ]( int modelId )
+                    this->daten->getResourceIdFromPath( modelPath, [this, texturPath]( int modelId )
                     {
-                        this->daten->getResourceIdFromPath( texturPath, [ this, modelId ]( int texturId )
+                        this->daten->getResourceIdFromPath( texturPath, [this, modelId]( int texturId )
                         {
                             ObjektDaten o = ObjektDaten();
                             o.m2d = modelId;
@@ -66,7 +59,7 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
                             o.pos.y = 0;
                             o.rot = 0;
                             o.style = 0;
-                            this->daten->addObjekt( o, [ this ]( int id )
+                            this->daten->addObjekt( o, [this]( int id )
                             {
                                 objekte->addEintrag( Text( id ) );
                                 selectObject( id );
@@ -84,15 +77,15 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
     model->setStyle( M2DVorschau::Style::Rahmen | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrScale | M2DVorschau::Style::Erlaubt );
     model->setSize( 290, 290 );
     model->setPosition( 0, 230 );
-    changeModel = initKnopf( 0, 520, 142, 20, zSchrift, Knopf::Style::Normal, "Model ändern" );
-    changeModel->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    changeModel = initKnopf( 0, 520, 142, 20, uiFactory, Knopf::Style::Normal, "Model ändern" );
+    changeModel->setMausEreignis( [this, &uiFactory]( void *p, void *o, MausEreignis me )
     {
         if( me.id == ME_RLinks )
         {
             cs.lock();
             if( dialog )
                 dialog->release();
-            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_MODEL2D, (KarteDaten *)this->daten->getThis(), [ this ]( const char *path )
+            dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_MODEL2D, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this]( const char *path )
             {
                 if( !path )
                     return;
@@ -100,7 +93,7 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
                 Model2DData *data = this->daten->loadModelFromPath( modelPath );
                 Textur2D *textur = new Textur2D();
                 textur->setTexturZ( this->daten->loadBildFromPath( texturPath ) );
-                model->postAction( [ this, data, textur ]()
+                model->postAction( [this, data, textur]()
                 {
                     model->setModel2D( data );
                     model->zModel()->setTextur( textur );
@@ -110,22 +103,22 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
         }
         return 1;
     } );
-    changeTextur = initKnopf( 147, 520, 143, 20, zSchrift, Knopf::Style::Normal, "Textur ändern" );
-    changeTextur->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    changeTextur = initKnopf( 147, 520, 143, 20, uiFactory, Knopf::Style::Normal, "Textur ändern" );
+    changeTextur->setMausEreignis( [this, &uiFactory]( void *p, void *o, MausEreignis me )
     {
         if( me.id == ME_RLinks )
         {
             cs.lock();
             if( dialog )
                 dialog->release();
-            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_TEXTUR, (KarteDaten *)this->daten->getThis(), [ this ]( const char *path )
+            dialog = new ResourceDialog( new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) ), uiFactory, SELECT_TEXTUR, dynamic_cast<KarteDaten *>( this->daten->getThis() ), [this]( const char *path )
             {
                 if( !path )
                     return;
                 texturPath = path;
                 Textur2D *textur = new Textur2D();
                 textur->setTexturZ( this->daten->loadBildFromPath( texturPath ) );
-                model->postAction( [ this, textur ]()
+                model->postAction( [this, textur]()
                 {
                     model->zModel()->setTextur( textur );
                 } );
@@ -134,37 +127,37 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
         }
         return 1;
     } );
-    stabilitätT = initTextFeld( 0, 545, 100, 20, zSchrift, TextFeld::Style::Text, "Stabilität: " );
-    stabilität = initTextFeld( 100, 545, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
-    energieT = initTextFeld( 0, 570, 100, 20, zSchrift, TextFeld::Style::Text, "Energie: " );
-    energie = initTextFeld( 100, 570, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
-    energieRadiusT = initTextFeld( 0, 595, 100, 20, zSchrift, TextFeld::Style::Text, "Radius: " );
-    energieRadius = initTextFeld( 100, 595, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
-    reparaturT = initTextFeld( 0, 620, 100, 20, zSchrift, TextFeld::Style::Text, "Reparatur: " );
-    reparatur = initTextFeld( 100, 620, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
-    akkuLeistungT = initTextFeld( 0, 645, 100, 20, zSchrift, TextFeld::Style::Text, "Akku: " );
-    akkuLeistung = initTextFeld( 100, 645, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
-    team = initAuswahlBox( 0, 670, 150, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    stabilitätT = initTextFeld( 0, 545, 100, 20, uiFactory, TextFeld::Style::Text, "Stabilität: " );
+    stabilität = initTextFeld( 100, 545, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
+    energieT = initTextFeld( 0, 570, 100, 20, uiFactory, TextFeld::Style::Text, "Energie: " );
+    energie = initTextFeld( 100, 570, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
+    energieRadiusT = initTextFeld( 0, 595, 100, 20, uiFactory, TextFeld::Style::Text, "Radius: " );
+    energieRadius = initTextFeld( 100, 595, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
+    reparaturT = initTextFeld( 0, 620, 100, 20, uiFactory, TextFeld::Style::Text, "Reparatur: " );
+    reparatur = initTextFeld( 100, 620, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
+    akkuLeistungT = initTextFeld( 0, 645, 100, 20, uiFactory, TextFeld::Style::Text, "Akku: " );
+    akkuLeistung = initTextFeld( 100, 645, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
+    team = initAuswahlBox( 0, 670, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     anz = daten->getTeamAnzahl();
     for( int i = 0; i < anz; i++ )
         team->addEintrag( daten->getTeamName( i ) );
-    verwundbar = initKontrollKnopf( 0, 695, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Verwundbar" );
-    beweglich = initKontrollKnopf( 150, 695, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Beweglich" );
-    collision = initKontrollKnopf( 0, 720, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Kollision" );
-    laserCollision = initKontrollKnopf( 150, 720, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Laser Kollision" );
-    neutral = initKontrollKnopf( 0, 745, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Neutral" );
-    erfahrung = initKontrollKnopf( 150, 745, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Treffer Erfahrung" );
-    lebensAnzeige = initKontrollKnopf( 0, 770, 145, 20, zSchrift, KontrollKnopf::Style::Normal, "Lebensanzeige" );
-    speichern = initKnopf( 0, 795, 100, 20, zSchrift, Knopf::Style::Normal, "Speichern" );
-    speichern->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    verwundbar = initKontrollKnopf( 0, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Verwundbar" );
+    beweglich = initKontrollKnopf( 150, 695, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Beweglich" );
+    collision = initKontrollKnopf( 0, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Kollision" );
+    laserCollision = initKontrollKnopf( 150, 720, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Laser Kollision" );
+    neutral = initKontrollKnopf( 0, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Neutral" );
+    erfahrung = initKontrollKnopf( 150, 745, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Treffer Erfahrung" );
+    lebensAnzeige = initKontrollKnopf( 0, 770, 145, 20, uiFactory, KontrollKnopf::Style::Normal, "Lebensanzeige" );
+    speichern = initKnopf( 0, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern" );
+    speichern->setMausEreignis( [this]( void *p, void *o, MausEreignis me )
     {
         if( me.id == ME_RLinks )
         {
             ObjektDaten *o = this->daten->getObjekt( this->daten->getObjektIndexById( *objekte->zEintrag( objekte->getAuswahl() )->zText() ) );
-            this->daten->getResourceIdFromPath( modelPath, [ this, o ]( int id )
+            this->daten->getResourceIdFromPath( modelPath, [this, o]( int id )
             {
                 o->m2d = id;
-                this->daten->getResourceIdFromPath( texturPath, [ this, o ]( int id )
+                this->daten->getResourceIdFromPath( texturPath, [this, o]( int id )
                 {
                     o->bild = id;
                     o->maxStabilität = *stabilität->zText();
@@ -194,8 +187,8 @@ ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
         }
         return 1;
     } );
-    löschen = initKnopf( 105, 795, 100, 20, zSchrift, Knopf::Style::Normal, "Löschen" );
-    löschen->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    löschen = initKnopf( 105, 795, 100, 20, uiFactory, Knopf::Style::Normal, "Löschen" );
+    löschen->setMausEreignis( [this]( void *p, void *o, MausEreignis me )
     {
         if( me.id == ME_RLinks )
         {
@@ -243,10 +236,9 @@ ObjektTool::~ObjektTool()
     speichern->release();
     löschen->release();
     daten->release();
-    schrift->release();
 }
 
-void ObjektTool::doPublicMausEreignis( MausEreignis & me )
+void ObjektTool::doPublicMausEreignis( MausEreignis &me )
 {
     bool vera = me.verarbeitet;
     if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
@@ -293,7 +285,7 @@ void ObjektTool::doPublicMausEreignis( MausEreignis & me )
         me.verarbeitet = vera;
 }
 
-void ObjektTool::doTastaturEreignis( TastaturEreignis & te )
+void ObjektTool::doTastaturEreignis( TastaturEreignis &te )
 {
     if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
         return;
@@ -340,7 +332,7 @@ bool ObjektTool::tick( double tickVal )
     return RightTool::tick( tickVal );
 }
 
-void ObjektTool::render( Bild & rObj )
+void ObjektTool::render( Bild &rObj )
 {
     screenSize = rObj.getSize();
     if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
@@ -376,7 +368,7 @@ void ObjektTool::render( Bild & rObj )
     }
 }
 
-void ObjektTool::renderDialogs( Bild & rObj )
+void ObjektTool::renderDialogs( Bild &rObj )
 {
     cs.lock();
     if( dialog )
@@ -427,7 +419,7 @@ void ObjektTool::selectObject( int id )
         model->setModel2D( daten->loadModelFromRessource( o->m2d ) );
         model->zModel()->addStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Erlaubt );
         modelPath = daten->getResource( daten->getResourceIndexById( o->m2d ) )->path;
-        Textur2D * textur = new Textur2D();
+        Textur2D *textur = new Textur2D();
         textur->setTexturZ( daten->loadBildFromRessource( o->bild ) );
         texturPath = daten->getResource( daten->getResourceIndexById( o->bild ) )->path;
         model->zModel()->setTextur( textur );

Asteroids/Editor/Interface/RightTools/ObjektOptionen/ObjektOptionen.h

@@ -38,7 +38,7 @@ namespace Editor
         Knopf *speichern;
         Knopf *löschen;
         KarteDaten *daten;
-        Schrift *schrift;
+        UIInit uiFactory;
         Text modelPath;
         Text texturPath;
         ResourceDialog *dialog;
@@ -47,7 +47,7 @@ namespace Editor
         Critical cs;
 
     public:
-        ObjektTool( Schrift *zSchrift, KarteDaten *daten );
+        ObjektTool( UIInit &uiFactory, KarteDaten *daten );
         ~ObjektTool();
         void doPublicMausEreignis( MausEreignis &me ) override;
         void doTastaturEreignis( TastaturEreignis &te ) override;

Asteroids/Editor/Interface/RightTools/RightTools.cpp

@@ -4,9 +4,7 @@
 
 RightTool::RightTool()
     : Zeichnung()
-{
-    ref = 1;
-}
+{}
 
 RightTool::~RightTool()
 {}
@@ -14,27 +12,13 @@ RightTool::~RightTool()
 void RightTool::renderDialogs( Bild &rObj )
 {}
 
-RightTool *RightTool::getThis()
-{
-    ref++;
-    return this;
-}
-
-RightTool *RightTool::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
-}
 
-
-RightTools::RightTools( Schrift *zSchrift, Punkt maxSize )
+RightTools::RightTools( UIInit &uiFactory, Punkt maxSize )
     : ZeichnungHintergrund()
 {
-    ref = 1;
     this->maxSize = maxSize;
-    toolAuswahl = initAuswahlBox( 5, 5, 290, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
-    toolAuswahl->setEventAktion( [ this ]( void *, AuswahlBox *, int, int neu )
+    toolAuswahl = initAuswahlBox( 5, 5, 290, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    toolAuswahl->setEventAktion( [this]( void *, AuswahlBox *, int, int neu )
     {
         this->selectTool( neu );
     } );
@@ -123,17 +107,4 @@ void RightTools::selectTool( int index )
     int i = 0;
     for( auto e = tools->getIterator(); e; e++ )
         e->setStyle( Zeichnung::Style::Sichtbar, i++ == index );
-}
-
-RightTools *RightTools::getThis()
-{
-    ref++;
-    return this;
-}
-
-RightTools *RightTools::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
 }

Asteroids/Editor/Interface/RightTools/RightTools.h

@@ -1,21 +1,17 @@
 #pragma once
 
 #include <AuswahlBox.h>
+#include <UIInitialization.h>
 #include "../../Netzwerk/EditorKlient.h"
 
 using namespace Framework;
 
 class RightTool : public Zeichnung
 {
-private:
-    int ref;
-
 public:
     RightTool();
     virtual ~RightTool();
     virtual void renderDialogs( Bild &rObj );
-    RightTool *getThis();
-    RightTool *release();
 };
 
 class RightTools : public ZeichnungHintergrund
@@ -24,10 +20,9 @@ private:
     AuswahlBox *toolAuswahl;
     RCArray< RightTool > *tools;
     Punkt maxSize;
-    int ref;
 
 public:
-    RightTools( Schrift *zSchrift, Punkt maxSize );
+    RightTools( UIInit &uiFactory, Punkt maxSize );
     ~RightTools();
     void addTool( RightTool *tool, char *name );
     void doPublicMausEreignis( MausEreignis &me ) override;
@@ -35,6 +30,4 @@ public:
     bool tick( double tickVal ) override;
     void render( Bild &rObj ) override;
     void selectTool( int index );
-    RightTools *getThis();
-    RightTools *release();
 };

Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.cpp

@@ -4,50 +4,50 @@
 
 using namespace Editor;
 
-SpielerTool::SpielerTool( Schrift *zSchrift, KarteDaten *daten )
+SpielerTool::SpielerTool( UIInit &uiFactory, KarteDaten *daten )
     : RightTool()
 {
     int spielerAnzahl = daten->getSpielerAnzahl();
-    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         spielerAuswahl->addEintrag( new Text( Text( "Spieler " ) += ( i + 1 ) ) );
     }
-    spielerAuswahl->setEventAktion( [ this ]( void *p, AuswahlBox *a, int old, int auswahl )
+    spielerAuswahl->setEventAktion( [this]( void *p, AuswahlBox *a, int old, int auswahl )
     {
         this->selectPlayer( auswahl + 1 );
     } );
-    skillStartT = initTextFeld( 0, 30, 290, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
-    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, zSchrift, TextFeld::Style::Text, "Stabilität" );
-    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, zSchrift, TextFeld::Style::Text, "Energie" );
-    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, zSchrift, TextFeld::Style::Text, "Reparatur" );
-    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, zSchrift, TextFeld::Style::Text, "Akku" );
-    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, zSchrift, TextFeld::Style::Text, "Wendigkeit" );
-    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, zSchrift, TextFeld::Style::Text, "Beschleunigung" );
-    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, zSchrift, TextFeld::Style::Text, "Antrieb Effizienz" );
-    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Intensität" );
-    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Effizienz" );
-    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Tempo" );
-    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, zSchrift, TextFeld::Style::Text, "Energie Schild" );
-    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, zSchrift, TextFeld::Style::Text, "Schild Effizienz" );
-    skillStartNetzwerkT = initTextFeld( 0, 355, 200, 20, zSchrift, TextFeld::Style::Text, "Netzwerk" );
-    skillStartPunkteT = initTextFeld( 0, 380, 200, 20, zSchrift, TextFeld::Style::Text, "Punkte" );
+    skillStartT = initTextFeld( 0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
+    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität" );
+    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie" );
+    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur" );
+    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku" );
+    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit" );
+    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung" );
+    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz" );
+    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität" );
+    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz" );
+    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo" );
+    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild" );
+    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz" );
+    skillStartNetzwerkT = initTextFeld( 0, 355, 200, 20, uiFactory, TextFeld::Style::Text, "Netzwerk" );
+    skillStartPunkteT = initTextFeld( 0, 380, 200, 20, uiFactory, TextFeld::Style::Text, "Punkte" );
     SpielerDaten *spieler = daten->getSpieler( daten->getSpielerIndexById( 1 ) );
-    skillStartStabilität = initTextFeld( 200, 55, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->maxStabilität ) );
-    skillStartEnergie = initTextFeld( 200, 80, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->maxEnergie ) );
-    skillStartReparatur = initTextFeld( 200, 105, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->reparatur ) );
-    skillStartAkku = initTextFeld( 200, 130, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->akkuLeistung ) );
-    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->wendigkeit ) );
-    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->beschleunigung ) );
-    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->antriebEffizienz ) );
-    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserIntensität ) );
-    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserEffizienz ) );
-    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserTempo ) );
-    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->energieSchild ) );
-    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->energieSchildEffizienz ) );
-    skillStartNetzwerk = initTextFeld( 200, 355, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->netzwerk ) );
-    skillStartPunkte = initTextFeld( 200, 380, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->skillPunkte ) );
-    speichern = initKnopf( 0, 405, 100, 20, zSchrift, Knopf::Style::Normal, "Speichern" );
+    skillStartStabilität = initTextFeld( 200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->maxStabilität ) );
+    skillStartEnergie = initTextFeld( 200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->maxEnergie ) );
+    skillStartReparatur = initTextFeld( 200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->reparatur ) );
+    skillStartAkku = initTextFeld( 200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->akkuLeistung ) );
+    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->wendigkeit ) );
+    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->beschleunigung ) );
+    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->antriebEffizienz ) );
+    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->laserIntensität ) );
+    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->laserEffizienz ) );
+    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->laserTempo ) );
+    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->energieSchild ) );
+    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->energieSchildEffizienz ) );
+    skillStartNetzwerk = initTextFeld( 200, 355, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->netzwerk ) );
+    skillStartPunkte = initTextFeld( 200, 380, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( spieler->skillPunkte ) );
+    speichern = initKnopf( 0, 405, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern" );
     this->daten = daten;
 }
 

Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.h

@@ -4,12 +4,14 @@
 #include "../../../../Spiel/Karte/Strukturen.h"
 #include "../../../Karte/EditorKarte.h"
 
+#include <UIInitialization.h>
+
 namespace Editor
 {
     class SpielerTool : public RightTool
     {
     private:
-        AuswahlBox * spielerAuswahl;
+        AuswahlBox *spielerAuswahl;
         TextFeld *skillStartT;
         TextFeld *skillStartStabilitätT;
         TextFeld *skillStartEnergieT;
@@ -43,7 +45,7 @@ namespace Editor
         KarteDaten *daten;
 
     public:
-        SpielerTool( Schrift *zSchrift, KarteDaten *daten );
+        SpielerTool( UIInit &uiFactory, KarteDaten *daten );
         ~SpielerTool();
         void doPublicMausEreignis( MausEreignis &me ) override;
         void doTastaturEreignis( TastaturEreignis &te ) override;

Asteroids/Editor/Interface/RightTools/TeamOptionen/TeamOptionen.cpp

@@ -4,46 +4,46 @@
 
 using namespace Editor;
 
-TeamTool::TeamTool( Schrift *zSchrift, KarteDaten *daten )
+TeamTool::TeamTool( UIInit &uiFactory, KarteDaten *daten )
     : RightTool()
 {
     int teamAnzahl = daten->getTeamAnzahl();
-    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     for( int i = 0; i < teamAnzahl; i++ )
     {
         teamAuswahl->addEintrag( daten->getTeamName( i ) );
     }
-    teamAuswahl->setEventAktion( [ this ]( void *p, AuswahlBox *a, int old, int auswahl )
+    teamAuswahl->setEventAktion( [this]( void *p, AuswahlBox *a, int old, int auswahl )
     {
         this->selectTeam( auswahl + 1 );
     } );
-    skillStartT = initTextFeld( 0, 30, 290, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
-    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, zSchrift, TextFeld::Style::Text, "Stabilität" );
-    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, zSchrift, TextFeld::Style::Text, "Energie" );
-    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, zSchrift, TextFeld::Style::Text, "Reparatur" );
-    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, zSchrift, TextFeld::Style::Text, "Akku" );
-    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, zSchrift, TextFeld::Style::Text, "Wendigkeit" );
-    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, zSchrift, TextFeld::Style::Text, "Beschleunigung" );
-    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, zSchrift, TextFeld::Style::Text, "Antrieb Effizienz" );
-    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Intensität" );
-    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Effizienz" );
-    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Tempo" );
-    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, zSchrift, TextFeld::Style::Text, "Energie Schild" );
-    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, zSchrift, TextFeld::Style::Text, "Schild Effizienz" );
+    skillStartT = initTextFeld( 0, 30, 290, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
+    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, uiFactory, TextFeld::Style::Text, "Stabilität" );
+    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, uiFactory, TextFeld::Style::Text, "Energie" );
+    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, uiFactory, TextFeld::Style::Text, "Reparatur" );
+    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, uiFactory, TextFeld::Style::Text, "Akku" );
+    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, uiFactory, TextFeld::Style::Text, "Wendigkeit" );
+    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, uiFactory, TextFeld::Style::Text, "Beschleunigung" );
+    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, uiFactory, TextFeld::Style::Text, "Antrieb Effizienz" );
+    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Intensität" );
+    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Effizienz" );
+    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, uiFactory, TextFeld::Style::Text, "Laser Tempo" );
+    skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, uiFactory, TextFeld::Style::Text, "Energie Schild" );
+    skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, uiFactory, TextFeld::Style::Text, "Schild Effizienz" );
     TeamDaten *Team = daten->getTeam( daten->getTeamIndexById( 1 ) );
-    skillStartStabilität = initTextFeld( 200, 55, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->maxStabilität ) );
-    skillStartEnergie = initTextFeld( 200, 80, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->maxEnergie ) );
-    skillStartReparatur = initTextFeld( 200, 105, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->reparatur ) );
-    skillStartAkku = initTextFeld( 200, 130, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->akkuLeistung ) );
-    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->wendigkeit ) );
-    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->beschleunigung ) );
-    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->antriebEffizienz ) );
-    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserIntensität ) );
-    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserEffizienz ) );
-    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserTempo ) );
-    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->energieSchild ) );
-    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->energieSchildEffizienz ) );
-    speichern = initKnopf( 0, 380, 100, 20, zSchrift, Knopf::Style::Normal, "Speichern" );
+    skillStartStabilität = initTextFeld( 200, 55, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->maxStabilität ) );
+    skillStartEnergie = initTextFeld( 200, 80, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->maxEnergie ) );
+    skillStartReparatur = initTextFeld( 200, 105, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->reparatur ) );
+    skillStartAkku = initTextFeld( 200, 130, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->akkuLeistung ) );
+    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->wendigkeit ) );
+    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->beschleunigung ) );
+    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->antriebEffizienz ) );
+    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->laserIntensität ) );
+    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->laserEffizienz ) );
+    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->laserTempo ) );
+    skillStartEnergieSchild = initTextFeld( 200, 305, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->energieSchild ) );
+    skillStartEnergieSchildEffizienz = initTextFeld( 200, 330, 90, 20, uiFactory, TextFeld::Style::TextFeld, Text( Team->energieSchildEffizienz ) );
+    speichern = initKnopf( 0, 380, 100, 20, uiFactory, Knopf::Style::Normal, "Speichern" );
     this->daten = daten;
 }
 

Asteroids/Editor/Interface/RightTools/TeamOptionen/TeamOptionen.h

@@ -9,7 +9,7 @@ namespace Editor
     class TeamTool : public RightTool
     {
     private:
-        AuswahlBox * teamAuswahl;
+        AuswahlBox *teamAuswahl;
         TextFeld *skillStartT;
         TextFeld *skillStartStabilitätT;
         TextFeld *skillStartEnergieT;
@@ -39,7 +39,7 @@ namespace Editor
         KarteDaten *daten;
 
     public:
-        TeamTool( Schrift *zSchrift, KarteDaten *daten );
+        TeamTool( UIInit &uiFactory, KarteDaten *daten );
         ~TeamTool();
         void doPublicMausEreignis( MausEreignis &me ) override;
         void doTastaturEreignis( TastaturEreignis &te ) override;

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();
@@ -158,9 +158,9 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
         model->setCollision( 0 );
         welt->addObject( model );
         SpielerDaten *d = s._;
-        d->addView( new UpdateObserver( [ this, d ]()
+        d->addView( new UpdateObserver( [this, d]()
         {
-            aktionen.add( [ this, d ]()
+            aktionen.add( [this, d]()
             {
                 this->client->saveSpieler( d );
             } );
@@ -169,9 +169,9 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
     for( auto t = teams.getIterator(); t; t++ )
     {
         TeamDaten *d = t._;
-        d->addView( new UpdateObserver( [ this, d ]()
+        d->addView( new UpdateObserver( [this, d]()
         {
-            aktionen.add( [ this, d ]()
+            aktionen.add( [this, d]()
             {
                 this->client->saveTeam( d );
             } );
@@ -200,9 +200,9 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
         model->setCollision( 0 );
         welt->addObject( model );
         ObjektDaten *d = o._;
-        d->addView( new UpdateObserver( [ this, d, model ]()
+        d->addView( new UpdateObserver( [this, d, model]()
         {
-            aktionen.add( [ this, d, model ]()
+            aktionen.add( [this, d, model]()
             {
                 this->client->saveObjekt( d );
                 Bild *bild = 0;
@@ -218,7 +218,7 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
                 {
                     Textur2D *textur = new Textur2D();
                     textur->setTexturZ( bild );
-                    model->postAction( [ model, da, textur ]()
+                    model->postAction( [model, da, textur]()
                     {
                         model->setModel( da );
                         model->setTextur( textur );
@@ -256,7 +256,7 @@ 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 );
     cs.lock();
@@ -296,9 +296,9 @@ void KarteDaten::addObjekt( ObjektDaten & daten, std::function< void( int ) > ca
     model->setSize( nd->scale );
     model->setCollision( 0 );
     welt->addObject( model );
-    nd->addView( new UpdateObserver( [ this, nd, model ]()
+    nd->addView( new UpdateObserver( [this, nd, model]()
     {
-        aktionen.add( [ this, nd, model ]()
+        aktionen.add( [this, nd, model]()
         {
             this->client->saveObjekt( nd );
             Bild *bild = 0;
@@ -314,7 +314,7 @@ void KarteDaten::addObjekt( ObjektDaten & daten, std::function< void( int ) > ca
             {
                 Textur2D *textur = new Textur2D();
                 textur->setTexturZ( bild );
-                model->postAction( [ model, d, textur ]()
+                model->postAction( [model, d, textur]()
                 {
                     model->setModel( d );
                     model->setTextur( textur );
@@ -330,7 +330,7 @@ void KarteDaten::addObjekt( ObjektDaten & daten, std::function< void( int ) > ca
         } );
     } ) );
     EditorKlient *c = client;
-    aktionen.add( [ nd, c, callBack ]()
+    aktionen.add( [nd, c, callBack]()
     {
         if( c->saveObjekt( nd ) )
             callBack( nd->id );
@@ -355,7 +355,7 @@ void KarteDaten::removeObjekt( int index )
     delete objekte.get( index );
     objekte.remove( index );
     EditorKlient *c = client;
-    aktionen.add( [ id, c ]()
+    aktionen.add( [id, c]()
     {
         c->deleteObjekt( id );
     } );
@@ -514,7 +514,7 @@ bool KarteDaten::hasAktions() const
 
 Welt2D *KarteDaten::getWelt() const
 {
-    return welt->getThis();
+    return dynamic_cast<Welt2D *>( welt->getThis() );
 }
 
 Welt2D *KarteDaten::zWelt() const
@@ -532,7 +532,7 @@ 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 )
@@ -593,7 +593,7 @@ Bild *KarteDaten::loadBildFromPath( const char *path )
 void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text > * ) > callBack )
 {
     cs.lock();
-    aktionen.add( [ this, callBack ]()
+    aktionen.add( [this, callBack]()
     {
         RCArray< Text > *result = new RCArray< Text >();
         loadSpielResourcePathsFromFolder( "data/spiele/Asteroids", result );
@@ -601,7 +601,7 @@ void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text > *
         for( auto mp = mapPaths->getIterator(); mp; mp++ )
         {
             if( !doesResourceExist( mp->getText() ) )
-                result->add( mp->getThis() );
+                result->add( dynamic_cast<Text *>( mp->getThis() ) );
         }
         mapPaths->release();
         callBack( result );
@@ -609,7 +609,7 @@ 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 );
@@ -684,13 +684,12 @@ void KarteDaten::loadSpielResourcePathsFromFolder( const char *folderPath, RCArr
 }
 
 // löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
-Thread *KarteDaten::release()
+void KarteDaten::stopWork()
 {
-    if( Thread::ref == 2 && run )
+    if( run )
     {
         exit = 1;
         if( isRunning() )
             warteAufThread( INT_MAX );
     }
-    return Thread::release();
 }

Asteroids/Editor/Karte/EditorKarte.h

@@ -152,7 +152,6 @@ namespace Editor
         Array< std::function< void() > > aktionen;
         Critical cs;
         Welt2D *welt;
-        RCArray< View > views;
         Punkt size;
         GetGSLDatei getGSLDatei;
         bool exit;
@@ -190,7 +189,6 @@ namespace Editor
         Model2DData *loadModelFromPath( const char *path );
         Bild *loadBildFromPath( const char *path );
         void loadUnusedResourcePaths( std::function< void( RCArray< Text > * ) > callBack );
-        // löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
-        Thread *release() override;
+        void stopWork();
     };
 }

Asteroids/Editor/Netzwerk/EditorKlient.cpp

@@ -45,9 +45,9 @@ SpielerTeamStrukturV *SpielerTeamStruktur::release()
 // Konstruktor
 //  k: Der zu verwendende Klient
 EditorKlient::EditorKlient( KSGClient::EditorServerClient *k )
+    : ReferenceCounter()
 {
     klient = k;
-    ref = 1;
 }
 
 // Destruktor
@@ -77,7 +77,7 @@ int EditorKlient::init()
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)& l, 1 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -105,7 +105,7 @@ bool EditorKlient::sitzungVerwerfen()
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)& l, 1 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -133,7 +133,7 @@ bool EditorKlient::sitzungBeenden()
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)& l, 1 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -159,27 +159,27 @@ 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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -205,32 +205,32 @@ 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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -256,26 +256,26 @@ 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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -301,13 +301,13 @@ 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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -334,13 +334,13 @@ 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 );
+            k->getNachrichtEncrypted( (char *)&resource->id, 4 );
             char len = 0;
-            k->getNachrichtEncrypted( (char *)& len, 1 );
+            k->getNachrichtEncrypted( (char *)&len, 1 );
             char *path = new char[ len + 1 ];
             path[ len ] = 0;
             k->getNachrichtEncrypted( path, len );
@@ -352,7 +352,7 @@ bool EditorKlient::loadResources( Array< ResourceDaten * > &resources )
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)& l, 1 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -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,7 +393,7 @@ int EditorKlient::addResource( const char *path )
     if( ret == 3 )
     {
         unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)& l, 1 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -420,37 +420,37 @@ 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 );
+            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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -477,32 +477,32 @@ 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 );
+            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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -529,31 +529,31 @@ 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 );
+            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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -598,8 +598,8 @@ Bild *EditorKlient::loadBild( const char *templatePath )
                     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 *bild = pfad.getTeilText( pfad.positionVon( ".ltdb/" ) + 6 );
+                Bild *res = klient->deBildLaden( datei, bild, 0 );
                 datei->release();
                 bild->release();
                 cs.unlock();
@@ -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();
@@ -647,8 +647,8 @@ Model2DData *EditorKlient::loadModel( const char *templatePath )
                     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 *model = pfad.getTeilText( pfad.positionVon( ".m2/" ) + 4 );
+                Model2DData *res = klient->deModelLaden( datei, model, 0 );
                 datei->release();
                 model->release();
                 cs.unlock();
@@ -715,12 +715,12 @@ 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();
     if( !k )
@@ -734,13 +734,13 @@ 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 );
+        k->getNachrichtEncrypted( (char *)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -756,18 +756,4 @@ bool EditorKlient::loadMapSize( Punkt & size )
 char *EditorKlient::getLastError() const
 {
     return error;
-}
-
-// Reference Counting
-EditorKlient *EditorKlient::getThis()
-{
-    ref++;
-    return this;
-}
-
-EditorKlient *EditorKlient::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
 }

Asteroids/Editor/Netzwerk/EditorKlient.h

@@ -20,12 +20,11 @@ namespace Editor
         SpielerTeamStrukturV *release() override;
     };
 
-    class EditorKlient
+    class EditorKlient : public virtual ReferenceCounter
     {
     private:
         KSGClient::EditorServerClient *klient;
         Text error;
-        int ref;
         Critical cs;
 
         void loadMapResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths );
@@ -54,16 +53,13 @@ namespace Editor
         bool deleteObjekt( int id );
         bool loadResources( Array< ResourceDaten * > &resources );
         int addResource( const char *path );
-        bool loadSpieler( Array< SpielerDaten* > &spieler );
-        bool loadTeams( Array< TeamDaten* > &teams );
-        bool loadObjekte( Array< ObjektDaten* > &Objekte );
+        bool loadSpieler( Array< SpielerDaten * > &spieler );
+        bool loadTeams( Array< TeamDaten * > &teams );
+        bool loadObjekte( Array< ObjektDaten * > &Objekte );
         Bild *loadBild( const char *templatePath );
         Model2DData *loadModel( const char *templatePath );
         RCArray< Text > *getAllMapResourcePaths();
         // Gibt den Letzten Fehler zurück
         char *getLastError() const;
-        // Reference Counting
-        EditorKlient *getThis();
-        EditorKlient *release();
     };
 }

Asteroids/HistorieStatistik/HistorieStatistik.cpp

@@ -10,168 +10,142 @@
 // Inhalt der HistorieStatistik Klasse aus HistorieStatistik.h
 // Konstruktor
 HistorieStatistik::HistorieStatistik()
+    : ReferenceCounter()
 {
-	schrift = 0;
-	screen = 0;
-	gss = new Array< SSDSpieler* >();
-	gts = new Array< SSDTeam* >();
-	tabelle = 0;
-	fertig = 0;
-	geladen = 0;
-	geschlossen = 0;
-	alpha = 0;
-	sichtbar = 0;
-	tickVal = 0;
-	rend = 0;
-	ref = 1;
+    screen = 0;
+    gss = new Array< SSDSpieler * >();
+    gts = new Array< SSDTeam * >();
+    tabelle = 0;
+    fertig = 0;
+    geladen = 0;
+    geschlossen = 0;
+    alpha = 0;
+    sichtbar = 0;
+    tickVal = 0;
+    rend = 0;
 }
 
 // Destruktor
 HistorieStatistik::~HistorieStatistik()
 {
-	if( schrift )
-		schrift->release();
-	if( !geladen )
-	{
-		gss->release();
-		gts->release();
-	}
-	else
-	{
-		int anz = gss->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( gss->hat( i ) )
-				delete gss->get( i );
-		}
-		gss->release();
-		anz = gts->getEintragAnzahl();
-		for( int i = 0; i < anz; i++ )
-		{
-			if( gts->hat( i ) )
-				delete gts->get( i );
-		}
-		gts->release();
-	}
-	if( tabelle )
-		tabelle->release();
-	if( fertig )
-		fertig->release();
+    if( !geladen )
+    {
+        gss->release();
+        gts->release();
+    }
+    else
+    {
+        int anz = gss->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( gss->hat( i ) )
+                delete gss->get( i );
+        }
+        gss->release();
+        anz = gts->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( gts->hat( i ) )
+                delete gts->get( i );
+        }
+        gts->release();
+    }
+    if( tabelle )
+        tabelle->release();
+    if( fertig )
+        fertig->release();
 }
 
 // nicht constant
-void HistorieStatistik::setSchrift( Schrift *schrift )
+void HistorieStatistik::setUIFactory( UIInit &uiFactory )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
-}
-
-void HistorieStatistik::setBildschirm( Bildschirm *zScreen )
-{
-	screen = zScreen;
+    this->uiFactory = uiFactory;
 }
 
 void HistorieStatistik::ladeDaten( int spielId )
 {
-	if( geladen )
-		return;
-	//StatistikLeser *reader = new StatistikLeser( spielId );
-	//for( int i = 0; i < reader->getSpielerAnzahl(); i++ )
-	//	gss->set( reader->getSSDGS( i ), i );
-	//for( int i = 0; i < reader->getTeamAnzahl(); i++ )
-	//	gts->set( reader->getSSDGT( i ), i );
-	//reader->release();
-	tabelle = new StatistikTabelle( gss->getThis(), gts->getThis(), schrift, screen, 1 );
-	fertig = initKnopf( 600, 390, 100, 20, schrift, Knopf::Style::Sichtbar, "Zurück" );
-	geladen = 1;
+    if( geladen )
+        return;
+    //StatistikLeser *reader = new StatistikLeser( spielId );
+    //for( int i = 0; i < reader->getSpielerAnzahl(); i++ )
+    //	gss->set( reader->getSSDGS( i ), i );
+    //for( int i = 0; i < reader->getTeamAnzahl(); i++ )
+    //	gts->set( reader->getSSDGT( i ), i );
+    //reader->release();
+    tabelle = new StatistikTabelle( dynamic_cast<Array<SSDSpieler *> *>( gss->getThis() ), dynamic_cast<Array<SSDTeam *> *>( gts->getThis() ), uiFactory, 1 );
+    fertig = initKnopf( 600, 390, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurück" );
+    geladen = 1;
 }
 
 void HistorieStatistik::setSichtbar( bool sichtbar )
 {
-	this->sichtbar = sichtbar;
+    this->sichtbar = sichtbar;
 }
 
 void HistorieStatistik::doPublicMausEreignis( MausEreignis &me )
 {
-	if( !geladen )
-		return;
+    if( !geladen )
+        return;
     bool vera = me.verarbeitet;
     fertig->doPublicMausEreignis( me );
     if( !vera && me.verarbeitet && me.id == ME_RLinks )
         geschlossen = 1;
-	tabelle->doPublicMausEreignis( me );
+    tabelle->doPublicMausEreignis( me );
 }
 
 void HistorieStatistik::doTastaturEreignis( TastaturEreignis &te )
-{
-}
+{}
 
 bool HistorieStatistik::tick( double tickVal )
 {
-	if( !geladen )
-		return 0;
-	rend |= tabelle->tick( tickVal );
-	rend |= fertig->tick( tickVal );
-	this->tickVal += tickVal * 150;
-	int val = ( int )this->tickVal;
-	this->tickVal -= val;
-	if( val )
-	{
-		if( sichtbar && alpha != 255 )
-		{
-			if( alpha + val > 255 )
-				alpha = 255;
-			else
-				alpha += val;
-			rend = 1;
-		}
-		if( !sichtbar && alpha )
-		{
-			if( alpha - val < 0 )
-				alpha = 0;
-			else
-				alpha -= val;
-			rend = 1;
-		}
-	}
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    if( !geladen )
+        return 0;
+    rend |= tabelle->tick( tickVal );
+    rend |= fertig->tick( tickVal );
+    this->tickVal += tickVal * 150;
+    int val = (int)this->tickVal;
+    this->tickVal -= val;
+    if( val )
+    {
+        if( sichtbar && alpha != 255 )
+        {
+            if( alpha + val > 255 )
+                alpha = 255;
+            else
+                alpha += val;
+            rend = 1;
+        }
+        if( !sichtbar && alpha )
+        {
+            if( alpha - val < 0 )
+                alpha = 0;
+            else
+                alpha -= val;
+            rend = 1;
+        }
+    }
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void HistorieStatistik::render( Bild &zRObj )
 {
-	if( !geladen )
-		return;
-	zRObj.setAlpha( alpha );
-	tabelle->render( zRObj );
-	fertig->render( zRObj );
-	zRObj.releaseAlpha();
+    if( !geladen )
+        return;
+    zRObj.setAlpha( alpha );
+    tabelle->render( zRObj );
+    fertig->render( zRObj );
+    zRObj.releaseAlpha();
 }
 
 // constant
 bool HistorieStatistik::istNochSichtbar() const
 {
-	return alpha != 0 || sichtbar;
+    return alpha != 0 || sichtbar;
 }
 
 bool HistorieStatistik::wurdeGeschlossen() const
 {
-	return geschlossen;
-}
-
-// Reference Counting
-AccountHistorieStatistikV *HistorieStatistik::getThis()
-{
-	ref++;
-	return this;
-}
-
-AccountHistorieStatistikV *HistorieStatistik::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return geschlossen;
 }

Asteroids/HistorieStatistik/HistorieStatistik.h

@@ -8,40 +8,35 @@
 class HistorieStatistik : public AccountHistorieStatistikV
 {
 private:
-	Schrift *schrift;
-	Bildschirm *screen;
-	Array< SSDSpieler* > *gss;
-	Array< SSDTeam* > *gts;
-	StatistikTabelle *tabelle;
-	Knopf *fertig;
-	bool geladen;
-	bool geschlossen;
-	unsigned char alpha;
-	bool sichtbar;
-	double tickVal;
-	bool rend;
-	int ref;
+    UIInit uiFactory;
+    Bildschirm *screen;
+    Array< SSDSpieler * > *gss;
+    Array< SSDTeam * > *gts;
+    StatistikTabelle *tabelle;
+    Knopf *fertig;
+    bool geladen;
+    bool geschlossen;
+    unsigned char alpha;
+    bool sichtbar;
+    double tickVal;
+    bool rend;
 
 public:
-	// Konstruktor
-	HistorieStatistik();
-	// Destruktor
-	~HistorieStatistik();
-	// nicht constant
-	virtual void setSchrift( Schrift *schrift );
-	virtual void setBildschirm( Bildschirm *zScreen );
-	virtual void ladeDaten( int spielId );
-	virtual void setSichtbar( bool sichtbar );
-	virtual void doPublicMausEreignis( MausEreignis &me );
-	virtual void doTastaturEreignis( TastaturEreignis &te );
-	virtual bool tick( double tickVal );
-	virtual void render( Bild &zRObj );
-	// constant
-	virtual bool istNochSichtbar() const;
-	virtual bool wurdeGeschlossen() const;
-	// Reference Counting
-	virtual AccountHistorieStatistikV *getThis();
-	virtual AccountHistorieStatistikV *release();
+    // Konstruktor
+    HistorieStatistik();
+    // Destruktor
+    ~HistorieStatistik();
+    // nicht constant
+    virtual void setUIFactory( UIInit &uiFactory );
+    virtual void ladeDaten( int spielId );
+    virtual void setSichtbar( bool sichtbar );
+    virtual void doPublicMausEreignis( MausEreignis &me );
+    virtual void doTastaturEreignis( TastaturEreignis &te );
+    virtual bool tick( double tickVal );
+    virtual void render( Bild &zRObj );
+    // constant
+    virtual bool istNochSichtbar() const;
+    virtual bool wurdeGeschlossen() const;
 };
 
 #endif

Asteroids/Initialisierung/Initialisierung.cpp

@@ -3,214 +3,103 @@
 #include <Bildschirm.h>
 #include <MausEreignis.h>
 
-Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel )
+Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel )
 {
-	Knopf *ret = new Knopf();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( titel )
-		ret->setText( titel );
-	return ret;
+    Knopf *ret = uiFactory.createKnopf( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( titel )
+        ret->setText( titel );
+    return ret;
 }
 
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt )
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt )
 {
-	KontrollKnopf *ret = new KontrollKnopf();
-	ret->addStyle( style );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( txt )
-	{
-		ret->setText( txt );
-		ret->setSText( txt );
-	}
-	ret->setSFarbe( 0xFFFFFFFF );
-	ret->setSSize( 12 );
-	if( ret->hatStyle( TextFeld::Style::Buffered ) )
-	{
-		ret->setAlphaFeldFarbe( 0x5500FF00 );
-		ret->setAlphaFeldStrength( -5 );
-	}
-	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFF00FF00 );
-	}
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	ret->loadData( "data/bilder/system.ltdb" );
-    ret->setMausEreignis( _ret1ME );
-	return ret;
+    KontrollKnopf *ret = uiFactory.createKontrollKnopf( uiFactory.initParam );
+    ret->addStyle( style );
+    if( txt )
+    {
+        ret->setText( txt );
+        ret->setSText( txt );
+    }
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    return ret;
 }
 
-Fenster *initFenster( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel )
+Fenster *initFenster( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel )
 {
-	Fenster *ret = new Fenster();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ret->hatStyle( Fenster::Style::Rahmen ) )
-	{
-		ret->setRBreite( 1 );
-		ret->setRFarbe( 0xFFFFFFFF );
-	}
-	if( ret->hatStyle( Fenster::Style::Titel ) )
-	{
-		if( titel )
-			ret->setTitel( titel );
-		if( zSchrift )
-			ret->setTSchriftZ( zSchrift->getThis() );
-		ret->setTSFarbe( 0xFFFFFFFF );
-		ret->zTTextFeld()->setSize( 0, 20 );
-		ret->zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );
-		ret->setTRFarbe( 0xFF00FF00 );
-		ret->setTRBreite( 1 );
-		if( ret->hatStyle( Fenster::Style::TitelBuffered ) )
-		{
-			ret->setTAfFarbe( 0x1000FF00 );
-			ret->setTAfStrength( -15 );
-		}
-	}
-	return ret;
+    Fenster *ret = uiFactory.createFenster( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( ret->hatStyle( Fenster::Style::Titel ) )
+    {
+        if( titel )
+            ret->setTitel( titel );
+    }
+    return ret;
 }
 
-TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt )
+TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt )
 {
-	TextFeld *ret = new TextFeld();
-	ret->setStyle( style );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( txt )
-		ret->setText( txt );
-	ret->setSchriftFarbe( 0xFFFFFFFF );
-	ret->setSchriftSize( 12 );
-	if( ret->hatStyle( TextFeld::Style::Buffered ) )
-	{
-		ret->setAlphaFeldFarbe( 0x5500FF00 );
-		ret->setAlphaFeldStrength( -5 );
-	}
-	if( ret->hatStyle( TextFeld::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFF00FF00 );
-	}
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	return ret;
+    TextFeld *ret = uiFactory.createTextFeld( uiFactory.initParam );
+    ret->setStyle( style );
+    if( txt )
+        ret->setText( txt );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    return ret;
 }
 
-BildZ *initBildZ( int x, int y, int br, int hö, int style, Bild *b )
+BildZ *initBildZ( int x, int y, int br, int hö, UIInit &uiFactory, int style, Bild *b )
 {
-	BildZ *ret = new BildZ();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( b )
-		ret->setBildZ( b );
-	if( ( style | BildZ::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	return ret;
+    BildZ *ret = uiFactory.createBildZ( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( b )
+        ret->setBildZ( b );
+    return ret;
 }
 
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< char * > values )
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values )
 {
-	AuswahlBox *ret = new AuswahlBox();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ( style | AuswahlBox::Style::Hintergrund ) == style )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	if( ( style | AuswahlBox::Style::Erlaubt ) == style )
-		ret->setMausEreignis( _ret1ME );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	if( ( style | AuswahlBox::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | AuswahlBox::Style::MaxHeight ) == style )
-		ret->setMaxAuskappHeight( 100 );
-	if( ( style | AuswahlBox::Style::MausRahmen ) == style )
-	{
-		ret->setMausRahmenBreite( 1 );
-		ret->setMausRahmenFarbe( 0xFF005500 );
-	}
-	if( ( style | AuswahlBox::Style::MausBuffer ) == style )
-	{
-		ret->setMausAlphaFeldFarbe( 0x00008700 );
-		ret->setMausAlphaFeldStrength( -8 );
-	}
-	if( ( style | AuswahlBox::Style::AuswahlRahmen ) == style )
-	{
-		ret->setAuswRahmenBreite( 1 );
-		ret->setAuswRahmenFarbe( 0xFF00FF00 );
-	}
-	if( ( style | AuswahlBox::Style::AuswahlBuffer ) == style )
-	{
-		ret->setAuswAlphaFeldFarbe( 0x0000FF00 );
-		ret->setAuswAlphaFeldStrength( -8 );
-	}
-	for( auto i = values.begin(); i != values.end(); i++ )
-	{
-		ret->addEintrag( *i );
-	}
-	return ret;
+    AuswahlBox *ret = uiFactory.createAuswahlBox( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    for( auto i = values.begin(); i != values.end(); i++ )
+    {
+        ret->addEintrag( *i );
+    }
+    return ret;
 }
 
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
 {
-	ObjTabelle *ret = new ObjTabelle();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( ( style | ObjTabelle::Style::Erlaubt ) == style )
-		ret->setMausEreignis( _ret1ME );
-	if( ( style | ObjTabelle::Style::Rahmen ) == style )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | ObjTabelle::Style::Raster ) == style )
-	{
-		ret->setRasterBreite( 1 );
-		ret->setRasterFarbe( 0xFFFFFFFF );
-	}
-	if( ( style | ObjTabelle::Style::VScroll ) == style )
-		ret->setVertikalKlickScroll( 5 );
-	if( ( style | ObjTabelle::Style::HScroll ) == style )
-		ret->setHorizontalKlickScroll( 5 );
-	for( auto i = spalten.begin(); i != spalten.end(); i++ )
-	{
-		ret->addSpalte( i->name );
-		ret->setSpaltenBreite( i->name, i->breite );
-		if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
-			ret->setMinSpaltenBreite( i->name, i->minBreite );
-		if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
-			ret->setMaxSpaltenBreite( i->name, i->maxBreite );
-		if( überschriftHöhe )
-		{
-			if( ret->getZeilenNummer( "Überschrift" ) < 0 )
-			{
-				ret->addZeile( 0, "Überschrift" );
-				ret->setZeilenHeight( 0, 20 );
-			}
-			ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, zSchrift, TextFeld::Style::Text, i->name ) );
-		}
-	}
-	return ret;
-}
-
-void initToolTip( Zeichnung *obj, const char *txt, Schrift *zSchrift, Bildschirm *zBs )
-{
-	obj->setToolTipText( txt, zBs, zSchrift );
-	obj->zToolTip()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha | TextFeld::Style::Mehrzeilig );
-	obj->zToolTip()->setHintergrundFarbe( 0xA0000000 );
-	obj->zToolTip()->setRahmenFarbe( 0xFFFFFFFF );
+    ObjTabelle *ret = uiFactory.createObjTabelle( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    for( auto i = spalten.begin(); i != spalten.end(); i++ )
+    {
+        ret->addSpalte( i->name );
+        ret->setSpaltenBreite( i->name, i->breite );
+        if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
+            ret->setMinSpaltenBreite( i->name, i->minBreite );
+        if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
+            ret->setMaxSpaltenBreite( i->name, i->maxBreite );
+        if( überschriftHöhe )
+        {
+            if( ret->getZeilenNummer( "Überschrift" ) < 0 )
+            {
+                ret->addZeile( 0, "Überschrift" );
+                ret->setZeilenHeight( 0, 20 );
+            }
+            ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, uiFactory, TextFeld::Style::Text, i->name ) );
+        }
+    }
+    return ret;
 }

Asteroids/Initialisierung/Initialisierung.h

@@ -9,24 +9,24 @@
 #include <AuswahlBox.h>
 #include <Tabelle.h>
 #include <initializer_list>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
 struct OBJTabelleSpalteIni
 {
-	char *name;
-	int breite;
-	int minBreite;
-	int maxBreite;
+    char *name;
+    int breite;
+    int minBreite;
+    int maxBreite;
 };
 
-Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel );
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt );
-Fenster *initFenster( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel );
-TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt );
-BildZ *initBildZ( int x, int y, int br, int hö, int style, Bild *b );
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< char * > values );
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
-void initToolTip( Zeichnung *obj, const char *txt, Schrift *zSchrift, Bildschirm *zBs );
+Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel );
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt );
+Fenster *initFenster( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *titel );
+TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, int style, char *txt );
+BildZ *initBildZ( int x, int y, int br, int hö, UIInit &uiFactory, int style, Bild *b );
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values );
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
 
 #endif

Asteroids/Netzwerk/STKNachricht.cpp

@@ -3,60 +3,45 @@
 // Inhalt der STKNachricht Klasse aus STKNachricht.h
 // Konstruktor
 STKNachricht::STKNachricht( int län, char *nachricht )
+    : ReferenceCounter()
 {
-	verarbeitet = 0;
-	spielZeit = *(int*)nachricht;
-	this->län = län - 4;
-	this->nachricht = new char[ this->län ];
-	for( int i = 0; i < this->län; i++ )
-		this->nachricht[ i ] = nachricht[ i + 4 ];
-	ref = 1;
+    verarbeitet = 0;
+    spielZeit = *(int *)nachricht;
+    this->län = län - 4;
+    this->nachricht = new char[ this->län ];
+    for( int i = 0; i < this->län; i++ )
+        this->nachricht[ i ] = nachricht[ i + 4 ];
 }
 
 // Destruktor
 STKNachricht::~STKNachricht()
 {
-	delete[] nachricht;
+    delete[] nachricht;
 }
 
 // nicht constant
 void STKNachricht::setVerarbeitet()
 {
-	verarbeitet = 1;
+    verarbeitet = 1;
 }
 
 // constant
 bool STKNachricht::istVerarbeitet() const
 {
-	return verarbeitet;
+    return verarbeitet;
 }
 
 int STKNachricht::getSpielZeit() const
 {
-	return spielZeit;
+    return spielZeit;
 }
 
 int STKNachricht::getLength() const
 {
-	return län;
+    return län;
 }
 
 char *STKNachricht::getNachricht() const
 {
-	return nachricht;
-}
-
-// Reference Counting
-STKNachricht *STKNachricht::getThis()
-{
-	ref++;
-	return this;
-}
-
-STKNachricht *STKNachricht::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return nachricht;
 }

Asteroids/Netzwerk/STKNachricht.h

@@ -1,30 +1,28 @@
 #ifndef STKNachricht_H
 #define STKNachricht_H
 
-class STKNachricht
+#include <ReferenceCounter.h>
+
+class STKNachricht : public virtual Framework::ReferenceCounter
 {
 private:
-	int spielZeit;
-	int län;
-	char *nachricht;
-	bool verarbeitet;
-	int ref;
+    int spielZeit;
+    int län;
+    char *nachricht;
+    bool verarbeitet;
 
 public:
-	// Konstruktor
-	STKNachricht( int län, char *nachricht );
-	// Destruktor
-	~STKNachricht();
-	// nicht constant
-	void setVerarbeitet();
-	// constant
-	bool istVerarbeitet() const;
-	int getSpielZeit() const;
-	int getLength() const;
-	char *getNachricht() const;
-	// Reference Counting
-	STKNachricht *getThis();
-	STKNachricht *release();
+    // Konstruktor
+    STKNachricht( int län, char *nachricht );
+    // Destruktor
+    ~STKNachricht();
+    // nicht constant
+    void setVerarbeitet();
+    // constant
+    bool istVerarbeitet() const;
+    int getSpielZeit() const;
+    int getLength() const;
+    char *getNachricht() const;
 };
 
 #endif

Asteroids/Spiel/Bestenliste/Bestenliste.cpp

@@ -11,479 +11,409 @@ int getStellen( double d );
 
 // Inhalt der BLSpieler Klasse aus Bestenliste.h
 // Konstruktor
-BLSpieler::BLSpieler( int sNum, Schrift *zS )
+BLSpieler::BLSpieler( int sNum, UIInit &uiFactory )
+    : ReferenceCounter()
 {
-	this->sNum = sNum;
-
-	rahmen = new LRahmen();
-	rahmen->setRamenBreite( 1 );
-	rahmen->setSize( 420, 20 );
-	name = initTextFeld( 0, 0, 100, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	punkte = initTextFeld( 100, 0, 50, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	kills = initTextFeld( 150, 0, 40, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	tode = initTextFeld( 190, 0, 40, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	schadenGemacht = initTextFeld( 230, 0, 60, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	schadenGenommen = initTextFeld( 290, 0, 60, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	präzision = initTextFeld( 350, 0, 70, 20, zS, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-
-	ref = 1;
+    this->sNum = sNum;
+
+    rahmen = new LRahmen();
+    rahmen->setRamenBreite( 1 );
+    rahmen->setSize( 420, 20 );
+    name = initTextFeld( 0, 0, 100, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    punkte = initTextFeld( 100, 0, 50, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    kills = initTextFeld( 150, 0, 40, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    tode = initTextFeld( 190, 0, 40, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    schadenGemacht = initTextFeld( 230, 0, 60, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    schadenGenommen = initTextFeld( 290, 0, 60, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    präzision = initTextFeld( 350, 0, 70, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
 }
 
 // Destruktor
 BLSpieler::~BLSpieler()
 {
-	rahmen->release();
-	name->release();
-	punkte->release();
-	kills->release();
-	tode->release();
-	schadenGemacht->release();
-	schadenGenommen->release();
-	präzision->release();
+    rahmen->release();
+    name->release();
+    punkte->release();
+    kills->release();
+    tode->release();
+    schadenGemacht->release();
+    schadenGenommen->release();
+    präzision->release();
 }
 
 // nicht constant
 bool BLSpieler::update( Spieler *zSpieler )
 {
-	if( sNum != zSpieler->getSpielerNummer() )
-		return 0;
-	rahmen->setFarbe( zSpieler->getSpielerFarbe() );
-	name->setText( zSpieler->zName()->getText() );
-	name->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	punkte->setText( Text() += zSpieler->getPunkte() );
-	punkte->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	kills->setText( Text() += zSpieler->getKills() );
-	kills->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	tode->setText( Text() += zSpieler->getTode() );
-	tode->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	schadenGemacht->setText( Text() += zSpieler->getSchadenGemacht() );
-	schadenGemacht->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	schadenGenommen->setText( Text() += zSpieler->getSchadenBekommen() );
-	schadenGenommen->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	Text txt;
-	double d = 100 * ( (double)zSpieler->getTreffer() / zSpieler->getSchüsse() );
-	if( !zSpieler->getSchüsse() )
-		d = 0;
-	txt.setPrecision( getStellen( d ) + 2 );
-	txt += d;
-	präzision->setText( txt );
-	präzision->setSchriftFarbe( zSpieler->getSpielerFarbe() );
-	return 1;
+    if( sNum != zSpieler->getSpielerNummer() )
+        return 0;
+    rahmen->setFarbe( zSpieler->getSpielerFarbe() );
+    name->setText( zSpieler->zName()->getText() );
+    name->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    punkte->setText( Text() += zSpieler->getPunkte() );
+    punkte->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    kills->setText( Text() += zSpieler->getKills() );
+    kills->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    tode->setText( Text() += zSpieler->getTode() );
+    tode->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    schadenGemacht->setText( Text() += zSpieler->getSchadenGemacht() );
+    schadenGemacht->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    schadenGenommen->setText( Text() += zSpieler->getSchadenBekommen() );
+    schadenGenommen->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    Text txt;
+    double d = 100 * ( (double)zSpieler->getTreffer() / zSpieler->getSchüsse() );
+    if( !zSpieler->getSchüsse() )
+        d = 0;
+    txt.setPrecision( getStellen( d ) + 2 );
+    txt += d;
+    präzision->setText( txt );
+    präzision->setSchriftFarbe( zSpieler->getSpielerFarbe() );
+    return 1;
 }
 
 void BLSpieler::render( int y, Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	rahmen->render( zRObj );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	kills->render( zRObj );
-	tode->render( zRObj );
-	schadenGemacht->render( zRObj );
-	schadenGenommen->render( zRObj );
-	präzision->render( zRObj );
-	zRObj.releaseDrawOptions();
+    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    rahmen->render( zRObj );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    kills->render( zRObj );
+    tode->render( zRObj );
+    schadenGemacht->render( zRObj );
+    schadenGenommen->render( zRObj );
+    präzision->render( zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int BLSpieler::getSpielerNummer() const
 {
-	return sNum;
+    return sNum;
 }
 
 int BLSpieler::getPunkte() const
 {
-	return *punkte->zText();
-}
-
-// Reference Counting
-BLSpieler *BLSpieler::getThis()
-{
-	ref++;
-	return this;
-}
-
-BLSpieler *BLSpieler::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return *punkte->zText();
 }
 
 // Inhalt der BLTeam Klasse aus Bestenliste.h
 // Konstruktor
-BLTeam::BLTeam( int id, Schrift *s )
+BLTeam::BLTeam( int id, UIInit &uiFactory )
+    : ReferenceCounter()
 {
-	teamId = id;
-	spielerAnzahl = 0;
-	schrift = s;
-	spieler = new RCArray< BLSpieler >();
-
-	rahmen = new LRahmen();
-	rahmen->setRamenBreite( 1 );
-	name = initTextFeld( 0, 0, 100, 20, s, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
-	punkte = initTextFeld( 100, 0, 50, 20, s, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    teamId = id;
+    spielerAnzahl = 0;
+    this->uiFactory = uiFactory;
+    spieler = new RCArray< BLSpieler >();
 
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setRamenBreite( 1 );
+    name = initTextFeld( 0, 0, 100, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
+    punkte = initTextFeld( 100, 0, 50, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Center, "" );
 }
 
 // Destruktor
 BLTeam::~BLTeam()
 {
-	schrift->release();
-	rahmen->release();
-	spieler->release();
-	name->release();
-	punkte->release();
+    rahmen->release();
+    spieler->release();
+    name->release();
+    punkte->release();
 }
 
 // nicht constant
 bool BLTeam::addSpieler( Spieler *zSpieler )
 {
-	bool gefunden = 0;
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-		{
-			gefunden = 1;
-			break;
-		}
-	}
-	if( gefunden )
-		return 0;
-	BLSpieler *tmp = new BLSpieler( zSpieler->getSpielerNummer(), schrift );
-	tmp->update( zSpieler );
-	spieler->set( tmp, spielerAnzahl );
-	spielerAnzahl++;
-	return 1;
+    bool gefunden = 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+        {
+            gefunden = 1;
+            break;
+        }
+    }
+    if( gefunden )
+        return 0;
+    BLSpieler *tmp = new BLSpieler( zSpieler->getSpielerNummer(), uiFactory );
+    tmp->update( zSpieler );
+    spieler->set( tmp, spielerAnzahl );
+    spielerAnzahl++;
+    return 1;
 }
 
 bool BLTeam::updateSpieler( Spieler *zSpieler )
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
-		{
-			spieler->z( i )->update( zSpieler );
-			return 1;
-		}
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == zSpieler->getSpielerNummer() )
+        {
+            spieler->z( i )->update( zSpieler );
+            return 1;
+        }
+    }
+    return 0;
 }
 
 void BLTeam::update( Team *zTeam )
 {
-	rahmen->setFarbe( zTeam->farbe );
-	name->setSchriftFarbe( zTeam->farbe );
-	name->setText( zTeam->name );
-	punkte->setSchriftFarbe( zTeam->farbe );
-	Text pt;
-	pt += zTeam->punkte;
-	pt += "/";
-	pt += zTeam->maxPunkte;
-	punkte->setText( pt );
+    rahmen->setFarbe( zTeam->farbe );
+    name->setSchriftFarbe( zTeam->farbe );
+    name->setText( zTeam->name );
+    punkte->setSchriftFarbe( zTeam->farbe );
+    Text pt;
+    pt += zTeam->punkte;
+    pt += "/";
+    pt += zTeam->maxPunkte;
+    punkte->setText( pt );
 }
 
 void BLTeam::render( int y, Bild &zRObj )
 {
-	rahmen->setSize( 422, 21 + 20 * spielerAnzahl );
-	if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	rahmen->render( zRObj );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	Array< bool > *gemahlt = new Array< bool >();
-	for( int i = 0; i < spielerAnzahl; i++ )
-		gemahlt->set( 0, i );
-	int min = -1;
-	int tmp = -1;
-	for( int h = 0; h < spielerAnzahl; h++ )
-	{
-		min = 0x80000000;
-		tmp = 0x80000000;
-		for( int i = 0; i < spielerAnzahl; i++ )
-		{
-			if( !spieler->z( i ) )
-				continue;
-			if( gemahlt->hat( i ) && gemahlt->get( i ) )
-				continue;
-			int p = spieler->z( i )->getPunkte();
-			if( p > min )
-			{
-				min = p;
-				tmp = i;
-			}
-		}
-		if( tmp != 0x80000000 )
-		{
-			gemahlt->set( 1, tmp );
-			spieler->z( tmp )->render( 20 + 20 * h, zRObj );
-		}
-		else
-			break;
-	}
-	gemahlt->release();
-	zRObj.releaseDrawOptions();
+    rahmen->setSize( 422, 21 + 20 * spielerAnzahl );
+    if( !zRObj.setDrawOptions( 1, y, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    rahmen->render( zRObj );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    Array< bool > *gemahlt = new Array< bool >();
+    for( int i = 0; i < spielerAnzahl; i++ )
+        gemahlt->set( 0, i );
+    int min = -1;
+    int tmp = -1;
+    for( int h = 0; h < spielerAnzahl; h++ )
+    {
+        min = 0x80000000;
+        tmp = 0x80000000;
+        for( int i = 0; i < spielerAnzahl; i++ )
+        {
+            if( !spieler->z( i ) )
+                continue;
+            if( gemahlt->hat( i ) && gemahlt->get( i ) )
+                continue;
+            int p = spieler->z( i )->getPunkte();
+            if( p > min )
+            {
+                min = p;
+                tmp = i;
+            }
+        }
+        if( tmp != 0x80000000 )
+        {
+            gemahlt->set( 1, tmp );
+            spieler->z( tmp )->render( 20 + 20 * h, zRObj );
+        }
+        else
+            break;
+    }
+    gemahlt->release();
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int BLTeam::getSpielerAnzahl() const
 {
-	return spielerAnzahl;
+    return spielerAnzahl;
 }
 
 int BLTeam::getPunkte() const
 {
-	Text *tmp = punkte->zText()->getTeilText( 0, punkte->zText()->positionVon( '/' ) );
-	int ret = *tmp;
-	tmp->release();
-	return ret;
+    Text *tmp = punkte->zText()->getTeilText( 0, punkte->zText()->positionVon( '/' ) );
+    int ret = *tmp;
+    tmp->release();
+    return ret;
 }
 
 int BLTeam::getHeight() const
 {
-	return 21 + spielerAnzahl * 20;
-}
-
-// Reference Counting
-BLTeam *BLTeam::getThis()
-{
-	ref++;
-	return this;
-}
-
-BLTeam *BLTeam::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return 21 + spielerAnzahl * 20;
 }
 
 // Inhalt der Bestenliste Klasse aus Bestenliste.h
 // Konstruktor
-Bestenliste::Bestenliste( Schrift *s )
-{
-	rahmen = new LRahmen();
-	rahmen->setRamenBreite( 1 );
-	rahmen->setFarbe( 0xFFFFFFFF );
-	rahmen->setSize( 440, 200 );
-
-	teams = new RCArray< BLTeam >();
-
-	name = new TextFeld();
-	name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	name->setSchriftZ( s->getThis() );
-	name->setSchriftFarbe( 0xFFFFFFFF );
-	name->setSchriftSize( 12 );
-	name->setText( "Name" );
-	name->setSize( 100, 30 );
-	name->setPosition( 0, 0 );
-
-	punkte = new TextFeld();
-	punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	punkte->setSchriftZ( s->getThis() );
-	punkte->setSchriftFarbe( 0xFFFFFFFF );
-	punkte->setSchriftSize( 12 );
-	punkte->setText( "Punkte" );
-	punkte->setSize( 50, 30 );
-	punkte->setPosition( 100, 0 );
-
-	kills = new TextFeld();
-	kills->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	kills->setSchriftZ( s->getThis() );
-	kills->setSchriftFarbe( 0xFFFFFFFF );
-	kills->setSchriftSize( 12 );
-	kills->setText( "Kills" );
-	kills->setSize( 40, 30 );
-	kills->setPosition( 150, 0 );
-
-	tode = new TextFeld();
-	tode->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
-	tode->setSchriftZ( s->getThis() );
-	tode->setSchriftFarbe( 0xFFFFFFFF );
-	tode->setSchriftSize( 12 );
-	tode->setText( "Tode" );
-	tode->setSize( 40, 30 );
-	tode->setPosition( 190, 0 );
-
-	schadenGemacht = new TextFeld();
-	schadenGemacht->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
-	schadenGemacht->setSchriftZ( s->getThis() );
-	schadenGemacht->setSchriftFarbe( 0xFFFFFFFF );
-	schadenGemacht->setSchriftSize( 12 );
-	schadenGemacht->setText( "Schaden\ngemacht" );
-	schadenGemacht->setSize( 60, 30 );
-	schadenGemacht->setPosition( 230, 0 );
-
-	schadenGenommen = new TextFeld();
-	schadenGenommen->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
-	schadenGenommen->setSchriftZ( s->getThis() );
-	schadenGenommen->setSchriftFarbe( 0xFFFFFFFF );
-	schadenGenommen->setSchriftSize( 12 );
-	schadenGenommen->setText( "Schaden\ngenommen" );
-	schadenGenommen->setSize( 60, 30 );
-	schadenGenommen->setPosition( 290, 0 );
-
-	präzision = new TextFeld();
-	präzision->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
-	präzision->setSchriftZ( s->getThis() );
-	präzision->setSchriftFarbe( 0xFFFFFFFF );
-	präzision->setSchriftSize( 12 );
-	präzision->setText( "präzision" );
-	präzision->setSize( 70, 30 );
-	präzision->setPosition( 350, 0 );
-
-	scroll = new VScrollBar();
-	scroll->setKlickScroll( 7 );
-
-	sichtbar = 0;
-	schrift = s;
-	teamAnzahl = 0;
-	ref = 1;
+Bestenliste::Bestenliste( UIInit &uiFactory )
+    : ReferenceCounter()
+{
+    this->uiFactory = uiFactory;
+    rahmen = new LRahmen();
+    rahmen->setRamenBreite( 1 );
+    rahmen->setFarbe( 0xFFFFFFFF );
+    rahmen->setSize( 440, 200 );
+
+    teams = new RCArray< BLTeam >();
+
+    name = uiFactory.createTextFeld( uiFactory.initParam );
+    name->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    name->setText( "Name" );
+    name->setSize( 100, 30 );
+    name->setPosition( 0, 0 );
+
+    punkte = uiFactory.createTextFeld( uiFactory.initParam );
+    punkte->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    punkte->setText( "Punkte" );
+    punkte->setSize( 50, 30 );
+    punkte->setPosition( 100, 0 );
+
+    kills = uiFactory.createTextFeld( uiFactory.initParam );
+    kills->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    kills->setText( "Kills" );
+    kills->setSize( 40, 30 );
+    kills->setPosition( 150, 0 );
+
+    tode = uiFactory.createTextFeld( uiFactory.initParam );
+    tode->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center );
+    tode->setText( "Tode" );
+    tode->setSize( 40, 30 );
+    tode->setPosition( 190, 0 );
+
+    schadenGemacht = uiFactory.createTextFeld( uiFactory.initParam );
+    schadenGemacht->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
+    schadenGemacht->setText( "Schaden\ngemacht" );
+    schadenGemacht->setSize( 60, 30 );
+    schadenGemacht->setPosition( 230, 0 );
+
+    schadenGenommen = uiFactory.createTextFeld( uiFactory.initParam );
+    schadenGenommen->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
+    schadenGenommen->setText( "Schaden\ngenommen" );
+    schadenGenommen->setSize( 60, 30 );
+    schadenGenommen->setPosition( 290, 0 );
+
+    präzision = uiFactory.createTextFeld( uiFactory.initParam );
+    präzision->setStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Mehrzeilig );
+    präzision->setText( "präzision" );
+    präzision->setSize( 70, 30 );
+    präzision->setPosition( 350, 0 );
+
+    scroll = new VScrollBar();
+    scroll->setKlickScroll( 7 );
+
+    sichtbar = 0;
+    teamAnzahl = 0;
 }
 
 // Destruktor
 Bestenliste::~Bestenliste()
 {
-	rahmen->release();
-	teams->release();
-	name->release();
-	punkte->release();
-	kills->release();
-	tode->release();
-	schadenGemacht->release();
-	schadenGenommen->release();
-	präzision->release();
-	scroll->release();
-	schrift->release();
+    rahmen->release();
+    teams->release();
+    name->release();
+    punkte->release();
+    kills->release();
+    tode->release();
+    schadenGemacht->release();
+    schadenGenommen->release();
+    präzision->release();
+    scroll->release();
 }
 
 // nicht constant
 void Bestenliste::setTeamAnzahl( int anz )
 {
-	teamAnzahl = anz;
+    teamAnzahl = anz;
 }
 
 void Bestenliste::addSpieler( Spieler *zSpieler )
 {
-	int team = zSpieler->zTeam()->id;
-	if( team < 0 )
-		return;
-	if( !teams->z( team ) )
-		teams->set( new BLTeam( team, schrift->getThis() ), team );
-	teams->z( team )->addSpieler( zSpieler );
+    int team = zSpieler->zTeam()->id;
+    if( team < 0 )
+        return;
+    if( !teams->z( team ) )
+        teams->set( new BLTeam( team, uiFactory ), team );
+    teams->z( team )->addSpieler( zSpieler );
 }
 
 void Bestenliste::updateSpieler( Spieler *zSpieler )
 {
-	if( teams->z( zSpieler->zTeam()->id ) )
-		teams->z( zSpieler->zTeam()->id )->updateSpieler( zSpieler );
+    if( teams->z( zSpieler->zTeam()->id ) )
+        teams->z( zSpieler->zTeam()->id )->updateSpieler( zSpieler );
 }
 
 void Bestenliste::updateTeam( Team *zTeam )
 {
-	if( teams->z( zTeam->id ) )
-		teams->z( zTeam->id )->update( zTeam );
+    if( teams->z( zTeam->id ) )
+        teams->z( zTeam->id )->update( zTeam );
 }
 
 void Bestenliste::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( te.id == TE_Press && te.taste == T_Tab )
-		sichtbar = !sichtbar;
+    if( te.id == TE_Press && te.taste == T_Tab )
+        sichtbar = !sichtbar;
 }
 
 void Bestenliste::doPublicMausEreignis( MausEreignis &me )
 {
-	if( !sichtbar )
-		return;
-	scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
+    if( !sichtbar )
+        return;
+    scroll->doMausMessage( rahmen->getBreite() - 15, 1, 15, rahmen->getHeight() - 2, me );
 }
 
 void Bestenliste::render( Bild &zRObj )
 {
-	if( !sichtbar )
-		return;
-	if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
-		return;
-	rahmen->render( zRObj );
-	zRObj.alphaRegion( 1, 1, rahmen->getBreite() - 2, rahmen->getHeight() - 2, 0xA0000000 );
-	zRObj.addScrollOffset( 0, scroll->getScroll() );
-	name->render( zRObj );
-	punkte->render( zRObj );
-	kills->render( zRObj );
-	tode->render( zRObj );
-	schadenGemacht->render( zRObj );
-	schadenGenommen->render( zRObj );
-	präzision->render( zRObj );
-	int yOff = 30;
-	Array< bool > *gemahlt = new Array< bool >();
-	for( int i = 1; i <= teamAnzahl; i++ )
-		gemahlt->set( 0, i );
-	int min = -1;
-	int tmp = -1;
-	for( int h = 0; h < teamAnzahl; h++ )
-	{
-		min = -1;
-		tmp = -1;
-		for( int i = 0; i < teamAnzahl; i++ )
-		{
-			if( !teams->z( i + 1 ) )
-				continue;
-			if( gemahlt->hat( i + 1 ) && gemahlt->get( i + 1 ) )
-				continue;
-			int p = teams->z( i + 1 )->getPunkte();
-			if( p > min )
-			{
-				min = p;
-				tmp = i + 1;
-			}
-		}
-		if( tmp >= 0 )
-		{
-			gemahlt->set( 1, tmp );
-			teams->z( tmp )->render( yOff, zRObj );
-			yOff += teams->z( tmp )->getHeight();
-		}
-		else
-			break;
-	}
-	gemahlt->release();
-	zRObj.addScrollOffset( 0, -scroll->getScroll() );
-	scroll->update( yOff, rahmen->getHeight() - 2 );
-	scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
-	zRObj.releaseDrawOptions();
+    if( !sichtbar )
+        return;
+    if( !zRObj.setDrawOptions( 0, 0, rahmen->getBreite(), rahmen->getHeight() ) )
+        return;
+    rahmen->render( zRObj );
+    zRObj.alphaRegion( 1, 1, rahmen->getBreite() - 2, rahmen->getHeight() - 2, 0xA0000000 );
+    zRObj.addScrollOffset( 0, scroll->getScroll() );
+    name->render( zRObj );
+    punkte->render( zRObj );
+    kills->render( zRObj );
+    tode->render( zRObj );
+    schadenGemacht->render( zRObj );
+    schadenGenommen->render( zRObj );
+    präzision->render( zRObj );
+    int yOff = 30;
+    Array< bool > *gemahlt = new Array< bool >();
+    for( int i = 1; i <= teamAnzahl; i++ )
+        gemahlt->set( 0, i );
+    int min = -1;
+    int tmp = -1;
+    for( int h = 0; h < teamAnzahl; h++ )
+    {
+        min = -1;
+        tmp = -1;
+        for( int i = 0; i < teamAnzahl; i++ )
+        {
+            if( !teams->z( i + 1 ) )
+                continue;
+            if( gemahlt->hat( i + 1 ) && gemahlt->get( i + 1 ) )
+                continue;
+            int p = teams->z( i + 1 )->getPunkte();
+            if( p > min )
+            {
+                min = p;
+                tmp = i + 1;
+            }
+        }
+        if( tmp >= 0 )
+        {
+            gemahlt->set( 1, tmp );
+            teams->z( tmp )->render( yOff, zRObj );
+            yOff += teams->z( tmp )->getHeight();
+        }
+        else
+            break;
+    }
+    gemahlt->release();
+    zRObj.addScrollOffset( 0, -scroll->getScroll() );
+    scroll->update( yOff, rahmen->getHeight() - 2 );
+    scroll->render( rahmen->getBreite() - 16, 1, 15, rahmen->getHeight() - 2, zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int Bestenliste::getTeamAnzahl() const
 {
-	return teamAnzahl;
+    return teamAnzahl;
 }
 
 bool Bestenliste::teamExistiert( int team ) const
 {
-	return teams->z( team ) != 0;
+    return teams->z( team ) != 0;
 }
 
 int Bestenliste::getTeamPunkte( int team ) const
 {
-	return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
-}
-
-// Reference Counting
-Bestenliste *Bestenliste::getThis()
-{
-	ref++;
-	return this;
-}
-
-Bestenliste *Bestenliste::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return teams->z( team ) ? teams->z( team )->getPunkte() : 0;
 }

Asteroids/Spiel/Bestenliste/Bestenliste.h

@@ -4,111 +4,100 @@
 #include <TextFeld.h>
 #include <Array.h>
 #include <Rahmen.h>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
 class Spieler; // Spieler.h
 class Team; // Team.h
 
-class BLSpieler
+class BLSpieler : public virtual ReferenceCounter
 {
 private:
-	int sNum;
-	LRahmen *rahmen;
-	TextFeld *name;
-	TextFeld *punkte;
-	TextFeld *kills;
-	TextFeld *tode;
-	TextFeld *schadenGemacht;
-	TextFeld *schadenGenommen;
-	TextFeld *präzision;
-	int ref;
+    int sNum;
+    LRahmen *rahmen;
+    TextFeld *name;
+    TextFeld *punkte;
+    TextFeld *kills;
+    TextFeld *tode;
+    TextFeld *schadenGemacht;
+    TextFeld *schadenGenommen;
+    TextFeld *präzision;
 
 public:
-	// Konstruktor
-	BLSpieler( int sNum, Schrift *zS );
-	// Destruktor
-	~BLSpieler();
-	// nicht constant
-	bool update( Spieler *zSpieler );
-	void render( int y, Bild &zRObj );
-	// constant
-	int getSpielerNummer() const;
-	int getPunkte() const;
-	// Reference Counting
-	BLSpieler *getThis();
-	BLSpieler *release();
+    // Konstruktor
+    BLSpieler( int sNum, UIInit &uiFactory );
+    // Destruktor
+    ~BLSpieler();
+    // nicht constant
+    bool update( Spieler *zSpieler );
+    void render( int y, Bild &zRObj );
+    // constant
+    int getSpielerNummer() const;
+    int getPunkte() const;
 };
 
-class BLTeam
+class BLTeam : public virtual ReferenceCounter
 {
 private:
-	int teamId;
-	int spielerAnzahl;
-	Schrift *schrift;
-	LRahmen *rahmen;
-	RCArray< BLSpieler > *spieler;
-	TextFeld *name;
-	TextFeld *punkte;
-	int ref;
+    int teamId;
+    int spielerAnzahl;
+    UIInit uiFactory;
+    LRahmen *rahmen;
+    RCArray< BLSpieler > *spieler;
+    TextFeld *name;
+    TextFeld *punkte;
 
 public:
-	// Konstruktor
-	BLTeam( int id, Schrift *s );
-	// Destruktor
-	~BLTeam();
-	// nicht constant
-	bool addSpieler( Spieler *zSpieler );
-	void update( Team *zTeam );
-	bool updateSpieler( Spieler *zSpieler );
-	void render( int y, Bild &zRObj );
-	// constant
-	int getSpielerAnzahl() const;
-	int getPunkte() const;
-	int getHeight() const;
-	// Reference Counting
-	BLTeam *getThis();
-	BLTeam *release();
+    // Konstruktor
+    BLTeam( int id, UIInit &uiFactory );
+    // Destruktor
+    ~BLTeam();
+    // nicht constant
+    bool addSpieler( Spieler *zSpieler );
+    void update( Team *zTeam );
+    bool updateSpieler( Spieler *zSpieler );
+    void render( int y, Bild &zRObj );
+    // constant
+    int getSpielerAnzahl() const;
+    int getPunkte() const;
+    int getHeight() const;
 };
 
-class Bestenliste
+class Bestenliste : public virtual ReferenceCounter
 {
 private:
-	LRahmen *rahmen;
-	RCArray< BLTeam > *teams;
-	TextFeld *name;
-	TextFeld *punkte;
-	TextFeld *kills;
-	TextFeld *tode;
-	TextFeld *schadenGemacht;
-	TextFeld *schadenGenommen;
-	TextFeld *präzision;
-	VScrollBar *scroll;
-	Schrift *schrift;
-	bool sichtbar;
-	int teamAnzahl;
-	int ref;
+    LRahmen *rahmen;
+    RCArray< BLTeam > *teams;
+    TextFeld *name;
+    TextFeld *punkte;
+    TextFeld *kills;
+    TextFeld *tode;
+    TextFeld *schadenGemacht;
+    TextFeld *schadenGenommen;
+    TextFeld *präzision;
+    VScrollBar *scroll;
+    UIInit uiFactory;
+    bool sichtbar;
+    int teamAnzahl;
 
 public:
-	// Konstruktor
-	Bestenliste( Schrift *s );
-	// Destruktor
-	~Bestenliste();
-	// nicht constant
-	void setTeamAnzahl( int anz );
-	void addSpieler( Spieler *zSpieler );
-	void updateSpieler( Spieler *zSpieler );
-	void updateTeam( Team *zTeam );
-	void doTastaturEreignis( TastaturEreignis &te );
-	void doPublicMausEreignis( MausEreignis &me );
-	void render( Bild &zRObj );
-	// constant
-	int getTeamAnzahl() const;
-	bool teamExistiert( int team ) const;
-	int getTeamPunkte( int team ) const;
-	// Reference Counting
-	Bestenliste *getThis();
-	Bestenliste *release();
+    // Konstruktor
+    Bestenliste( UIInit &uiFactory );
+    // Destruktor
+    ~Bestenliste();
+    // nicht constant
+    void setTeamAnzahl( int anz );
+    void addSpieler( Spieler *zSpieler );
+    void updateSpieler( Spieler *zSpieler );
+    void updateTeam( Team *zTeam );
+    void doTastaturEreignis( TastaturEreignis &te );
+    void doPublicMausEreignis( MausEreignis &me );
+    void render( Bild &zRObj );
+    // constant
+    int getTeamAnzahl() const;
+    bool teamExistiert( int team ) const;
+    int getTeamPunkte( int team ) const;
 };
 
 #endif

Asteroids/Spiel/Chat/Chat.cpp

@@ -9,128 +9,119 @@
 
 // Inhalt der SpielChat Klasse aus Chat.h
 // Konstruktor
-SpielChat::SpielChat()
+SpielChat::SpielChat( UIInit &uiFactory )
+    : ReferenceCounter()
 {
-	rahmen = new LRahmen();
-	rahmen->setFarbe( 0xFF909090 );
-	rahmen->setRamenBreite( 1 );
-	rahmen->setSize( 450, 200 );
-	verlauf = new TextFeld();
-	verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund ) );
-	verlauf->setText( "" );
-	verlauf->setSchriftFarbe( 0xFFFFFFFF );
-	verlauf->setSchriftSize( 12 );
-	verlauf->setSize( 446, 174 );
-	nachricht = new TextFeld();
-	nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
-	nachricht->setText( "Drücke TAB um die Bestenliste anzuzeigen.\n" );
-	nachricht->setSchriftFarbe( 0xFF909090 );
-	nachricht->setSchriftSize( 12 );
-	nachricht->setRahmenBreite( 1 );
-	nachricht->setRahmenFarbe( 0xFF909090 );
-	nachricht->setSize( 446, 20 );
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setFarbe( 0xFF909090 );
+    rahmen->setRamenBreite( 1 );
+    rahmen->setSize( 450, 200 );
+    verlauf = uiFactory.createTextFeld( uiFactory.initParam );
+    verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund ) );
+    verlauf->setText( "" );
+    verlauf->setSize( 446, 174 );
+    nachricht = uiFactory.createTextFeld( uiFactory.initParam );
+    nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
+    nachricht->setText( "Drücke TAB um die Bestenliste anzuzeigen.\n" );
+    nachricht->setSchriftFarbe( 0xFF909090 );
+    nachricht->setRahmenBreite( 1 );
+    nachricht->setRahmenFarbe( 0xFF909090 );
+    nachricht->setSize( 446, 20 );
 }
 
 // Destruktor
 SpielChat::~SpielChat()
 {
-	rahmen->release();
-	verlauf->release();
-	nachricht->release();
+    rahmen->release();
+    verlauf->release();
+    nachricht->release();
 }
 
 // nicht constant
-void SpielChat::setSchrift( Schrift *zSchrift )
-{
-	verlauf->setSchriftZ( zSchrift->getThis() );
-	nachricht->setSchriftZ( zSchrift->getThis() );
-}
-
 void SpielChat::addNachricht( char *nachricht )
 {
-	verlauf->addZeile( nachricht, 0xFFFFFFFF );
-	verlauf->updateVScroll();
+    verlauf->addZeile( nachricht, 0xFFFFFFFF );
+    verlauf->updateVScroll();
 }
 
 void SpielChat::addNachricht( char *nachricht, int farbe )
 {
-	verlauf->addZeile( nachricht, farbe );
-	verlauf->updateVScroll();
+    verlauf->addZeile( nachricht, farbe );
+    verlauf->updateVScroll();
 }
 
 void SpielChat::doPublicMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	verlauf->doPublicMausEreignis( me );
-	nachricht->doPublicMausEreignis( me );
-	if( !vera && me.verarbeitet )
-	{
-		nachricht->setRahmenFarbe( 0xFFFFFFFF );
-		nachricht->setSchriftFarbe( 0xFFFFFFFF );
-		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
-		rahmen->setFarbe( 0xFFFFFFFF );
-	}
-	else
-	{
-		nachricht->setRahmenFarbe( 0xFF909090 );
-		nachricht->setSchriftFarbe( 0xFF909090 );
-		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
-		rahmen->setFarbe( 0xFF909090 );
-	}
+    bool vera = me.verarbeitet;
+    verlauf->doPublicMausEreignis( me );
+    nachricht->doPublicMausEreignis( me );
+    if( !vera && me.verarbeitet )
+    {
+        nachricht->setRahmenFarbe( 0xFFFFFFFF );
+        nachricht->setSchriftFarbe( 0xFFFFFFFF );
+        verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+        rahmen->setFarbe( 0xFFFFFFFF );
+    }
+    else
+    {
+        nachricht->setRahmenFarbe( 0xFF909090 );
+        nachricht->setSchriftFarbe( 0xFF909090 );
+        verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+        rahmen->setFarbe( 0xFF909090 );
+    }
 }
 
 void SpielChat::doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient )
 {
-	if( te.taste == T_Esc )
-		nachricht->removeStyle( TextFeld::Style::Fokus );
-	if( te.id == TE_Release && te.taste == T_Enter && !te.verarbeitet )
-	{
-		if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
-		{
-			if( nachricht->zText()->getLength() )
-			{
-				short län = 1 + nachricht->zText()->getLength();
-				char *bytes = new char[ län + 1 ];
-				*bytes = 8;
-				for( int i = 1; i <= län; i++ )
-					bytes[ i ] = nachricht->zText()->getText()[ i - 1 ];
-				nachricht->setText( "" );
-				nachricht->setAuswahl( 0, 0 );
-				nachricht->removeStyle( TextFeld::Style::Fokus );
-				zKlient->spielNachricht( län, bytes );
-				delete[] bytes;
-				te.verarbeitet = 1;
-			}
-		}
-		else
-		{
-			nachricht->addStyle( TextFeld::Style::Fokus );
-			nachricht->setAuswahl( 0, nachricht->zText()->getLength() );
-			te.verarbeitet = 1;
-		}
-	}
-	if( !te.verarbeitet )
-		nachricht->doTastaturEreignis( te );
-	if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
-	{
-		nachricht->setRahmenFarbe( 0xFFFFFFFF );
-		nachricht->setSchriftFarbe( 0xFFFFFFFF );
-		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
-		rahmen->setFarbe( 0xFFFFFFFF );
-	}
-	else
-	{
-		nachricht->setRahmenFarbe( 0xFF909090 );
-		nachricht->setSchriftFarbe( 0xFF909090 );
-		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
-		rahmen->setFarbe( 0xFF909090 );
-	}
+    if( te.taste == T_Esc )
+        nachricht->removeStyle( TextFeld::Style::Fokus );
+    if( te.id == TE_Release && te.taste == T_Enter && !te.verarbeitet )
+    {
+        if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+        {
+            if( nachricht->zText()->getLength() )
+            {
+                short län = 1 + nachricht->zText()->getLength();
+                char *bytes = new char[ län + 1 ];
+                *bytes = 8;
+                for( int i = 1; i <= län; i++ )
+                    bytes[ i ] = nachricht->zText()->getText()[ i - 1 ];
+                nachricht->setText( "" );
+                nachricht->setAuswahl( 0, 0 );
+                nachricht->removeStyle( TextFeld::Style::Fokus );
+                zKlient->spielNachricht( län, bytes );
+                delete[] bytes;
+                te.verarbeitet = 1;
+            }
+        }
+        else
+        {
+            nachricht->addStyle( TextFeld::Style::Fokus );
+            nachricht->setAuswahl( 0, nachricht->zText()->getLength() );
+            te.verarbeitet = 1;
+        }
+    }
+    if( !te.verarbeitet )
+        nachricht->doTastaturEreignis( te );
+    if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+    {
+        nachricht->setRahmenFarbe( 0xFFFFFFFF );
+        nachricht->setSchriftFarbe( 0xFFFFFFFF );
+        verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+        rahmen->setFarbe( 0xFFFFFFFF );
+    }
+    else
+    {
+        nachricht->setRahmenFarbe( 0xFF909090 );
+        nachricht->setSchriftFarbe( 0xFF909090 );
+        verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+        rahmen->setFarbe( 0xFF909090 );
+    }
 }
 
 void SpielChat::tick( double z )
 {
-	nachricht->tick( z );
+    nachricht->tick( z );
 }
 
 void SpielChat::render( Bild &zRObj )
@@ -138,28 +129,13 @@ void SpielChat::render( Bild &zRObj )
     rahmen->setPosition( Punkt( 10, zRObj.getHeight() - 210 ) );
     verlauf->setPosition( rahmen->getX() + 2, rahmen->getY() + 2 );
     nachricht->setPosition( rahmen->getX() + 2, rahmen->getY() + 178 );
-	rahmen->render( zRObj );
-	verlauf->render( zRObj );
-	nachricht->render( zRObj );
+    rahmen->render( zRObj );
+    verlauf->render( zRObj );
+    nachricht->render( zRObj );
 }
 
 // constant
 bool SpielChat::istAktiv() const
 {
-	return nachricht->hatStyle( TextFeld::Style::Fokus );
-}
-
-// Reference Counting
-SpielChat *SpielChat::getThis()
-{
-	ref++;
-	return this;
-}
-
-SpielChat *SpielChat::relese()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return nachricht->hatStyle( TextFeld::Style::Fokus );
 }

Asteroids/Spiel/Chat/Chat.h

@@ -4,35 +4,31 @@
 #include <KSGNetwork.h>
 #include <TextFeld.h>
 #include <Rahmen.h>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
-class SpielChat
+class SpielChat : public virtual ReferenceCounter
 {
 private:
-	LRahmen *rahmen = 0;
-	TextFeld *verlauf;
-	TextFeld *nachricht;
-	int ref;
+    LRahmen *rahmen = 0;
+    TextFeld *verlauf;
+    TextFeld *nachricht;
 
 public:
-	// Konstruktor
-	SpielChat();
-	// Destruktor
-	~SpielChat();
-	// nicht constant
-	void setSchrift( Schrift *zSchrift );
-	void addNachricht( char *nachricht );
-	void addNachricht( char *nachricht, int farbe );
-	void doPublicMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient );
-	void tick( double z );
-	void render( Bild &zRObj );
-	// constant
-	bool istAktiv() const;
-	// Reference Counting
-	SpielChat *getThis();
-	SpielChat *relese();
+    // Konstruktor
+    SpielChat( UIInit &uiFactory );
+    // Destruktor
+    ~SpielChat();
+    // nicht constant
+    void addNachricht( char *nachricht );
+    void addNachricht( char *nachricht, int farbe );
+    void doPublicMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient );
+    void tick( double z );
+    void render( Bild &zRObj );
+    // constant
+    bool istAktiv() const;
 };
 
 #endif

Asteroids/Spiel/Ende/Ende.cpp

@@ -7,60 +7,55 @@
 
 // Inhalt der Ende Klasse aus Ende.h
 // Konstruktor
-Ende::Ende( Schrift *zSchrift )
+Ende::Ende( UIInit &uiFactory )
+    : ReferenceCounter()
 {
-	rahmen = new LRahmen();
-	rahmen->setSize( 200, 100 );
-	rahmen->setRamenBreite( 2 );
-	rahmen->setFarbe( 0xFFFFFFFF );
-	text = new TextFeld();
-	text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
-	text->setSchriftZ( zSchrift->getThis() );
-	text->setText( "" );
-	text->setSchriftFarbe( 0xFFFFFFFF );
-	text->setSize( 200, 50 );
-	warten = new TextFeld();
-	warten->setStyle( ( TextFeld::Style::Text | TextFeld::Style::Center ) & ~TextFeld::Style::Sichtbar );
-	warten->setSchriftZ( zSchrift->getThis() );
-	warten->setText( "Bitte warten..." );
-	warten->setSchriftFarbe( 0xFFFFFFFF );
-	warten->setSize( 200, 50 );
-	ok = new Knopf();
-	ok->setStyle( Knopf::Style::Normal );
-	ok->setSize( 100, 20 );
-	ok->setText( "Weiter" );
-	ok->setSchriftZ( zSchrift->getThis() );
-	weiter = 0;
-	ref = 1;
+    rahmen = new LRahmen();
+    rahmen->setSize( 200, 100 );
+    rahmen->setRamenBreite( 2 );
+    rahmen->setFarbe( 0xFFFFFFFF );
+    text = uiFactory.createTextFeld( uiFactory.initParam );
+    text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
+    text->setText( "" );
+    text->setSize( 200, 50 );
+    warten = uiFactory.createTextFeld( uiFactory.initParam );
+    warten->setStyle( ( TextFeld::Style::Text | TextFeld::Style::Center ) & ~TextFeld::Style::Sichtbar );
+    warten->setText( "Bitte warten..." );
+    warten->setSize( 200, 50 );
+    ok = uiFactory.createKnopf( uiFactory.initParam );
+    ok->setStyle( Knopf::Style::Normal );
+    ok->setSize( 100, 20 );
+    ok->setText( "Weiter" );
+    weiter = 0;
 }
 
 // Destruktor
 Ende::~Ende()
 {
-	rahmen->release();
-	text->release();
-	warten->release();
-	ok->release();
+    rahmen->release();
+    text->release();
+    warten->release();
+    ok->release();
 }
 
 // nicht constant
 void Ende::setGewonnen( char gewonnen )
 {
-	if( gewonnen == 1 )
-	{
-		text->setText( "Du hast gewonnen." );
-		text->setSchriftFarbe( 0xFF00FF00 );
-	}
-	else if( !gewonnen )
-	{
-		text->setText( "Du hast verloren." );
-		text->setSchriftFarbe( 0xFFFF0000 );
-	}
-	else
-	{
-		text->setText( "Unentschieden." );
-		text->setSchriftFarbe( 0xFFFFFFFF );
-	}
+    if( gewonnen == 1 )
+    {
+        text->setText( "Du hast gewonnen." );
+        text->setSchriftFarbe( 0xFF00FF00 );
+    }
+    else if( !gewonnen )
+    {
+        text->setText( "Du hast verloren." );
+        text->setSchriftFarbe( 0xFFFF0000 );
+    }
+    else
+    {
+        text->setText( "Unentschieden." );
+        text->setSchriftFarbe( 0xFFFFFFFF );
+    }
 }
 
 void Ende::doTastaturEreignis( TastaturEreignis &te )
@@ -75,47 +70,32 @@ void Ende::doTastaturEreignis( TastaturEreignis &te )
 
 void Ende::doPublicMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	ok->doPublicMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-	{
-		ok->removeStyle( Knopf::Style::Sichtbar );
-		warten->addStyle( TextFeld::Style::Sichtbar );
-		weiter = 1;
-	}
-	me.verarbeitet = 1;
+    bool vera = me.verarbeitet;
+    ok->doPublicMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+    {
+        ok->removeStyle( Knopf::Style::Sichtbar );
+        warten->addStyle( TextFeld::Style::Sichtbar );
+        weiter = 1;
+    }
+    me.verarbeitet = 1;
 }
 
 void Ende::render( Bild &zRObj )
 {
-	rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
-	zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
-	rahmen->render( zRObj );
-	text->setPosition( rahmen->getX(), rahmen->getY() );
-	text->render( zRObj );
-	warten->setPosition( rahmen->getX(), rahmen->getY() + 50 );
-	warten->render( zRObj );
-	ok->setPosition( rahmen->getX() + rahmen->getBreite() / 2 - ok->getBreite() / 2, rahmen->getY() + 65 );
-	ok->render( zRObj );
+    rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
+    zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
+    rahmen->render( zRObj );
+    text->setPosition( rahmen->getX(), rahmen->getY() );
+    text->render( zRObj );
+    warten->setPosition( rahmen->getX(), rahmen->getY() + 50 );
+    warten->render( zRObj );
+    ok->setPosition( rahmen->getX() + rahmen->getBreite() / 2 - ok->getBreite() / 2, rahmen->getY() + 65 );
+    ok->render( zRObj );
 }
 
 // constant
 bool Ende::getWeiter() const
 {
-	return weiter;
-}
-
-// Reference Counting
-Ende *Ende::getThis()
-{
-	ref++;
-	return this;
-}
-
-Ende *Ende::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return weiter;
 }

Asteroids/Spiel/Ende/Ende.h

@@ -3,34 +3,31 @@
 
 #include <Knopf.h>
 #include <Rahmen.h>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
-class Ende
+class Ende : public virtual ReferenceCounter
 {
 private:
-	LRahmen *rahmen;
-	TextFeld *text;
-	TextFeld *warten;
-	Knopf *ok;
-	bool weiter;
-	int ref;
+    LRahmen *rahmen;
+    TextFeld *text;
+    TextFeld *warten;
+    Knopf *ok;
+    bool weiter;
 
 public:
-	// Konstruktor
-	Ende( Schrift *zSchrift );
-	// Destruktor
-	~Ende();
-	// nicht constant
-	void setGewonnen( char gewonnen );
+    // Konstruktor
+    Ende( UIInit &uiFactory );
+    // Destruktor
+    ~Ende();
+    // nicht constant
+    void setGewonnen( char gewonnen );
     void doTastaturEreignis( TastaturEreignis &te );
-	void doPublicMausEreignis( MausEreignis &me );
-	void render( Bild &zRObj );
-	// constant
-	bool getWeiter() const;
-	// Reference Counting
-	Ende *getThis();
-	Ende *release();
+    void doPublicMausEreignis( MausEreignis &me );
+    void render( Bild &zRObj );
+    // constant
+    bool getWeiter() const;
 };
 
 #endif

Asteroids/Spiel/Karte/Karte.cpp

@@ -4,6 +4,7 @@
 // Inhalt der Karte Klasse aus Karte.h
 // Konstruktor
 Karte::Karte()
+    : ReferenceCounter()
 {
     größe = Vec2< int >( 0, 0 );
     spielerAnzahl = 0;
@@ -16,7 +17,6 @@ Karte::Karte()
     objekte = new RCArray< ObjektStr >();
     spieler = new RCArray< SpielerStr >();
     teams = new RCArray< TeamStr >();
-    ref = 1;
 }
 
 // Destruktor
@@ -35,20 +35,20 @@ Karte::~Karte()
 // nicht constant
 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();
@@ -67,7 +67,7 @@ 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 );
     }
 }
@@ -75,16 +75,16 @@ void Karte::ladeSts( Datei *zDatei )
 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 ) );
     }
-    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 ) );
@@ -108,7 +108,7 @@ Vec2< int > Karte::getSize() const
     return größe;
 }
 
-Spieler *Karte::createSpieler( int sNum, Schrift *zSchrift, 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;
@@ -120,11 +120,11 @@ Spieler *Karte::createSpieler( int sNum, Schrift *zSchrift, KSGClient::Informati
     }
     if( !player )
         return 0;
-    Spieler *ret = new Spieler( zInfoK, zSchrift, player );
+    Spieler *ret = new Spieler( zInfoK, uiFactory, player );
     for( auto i = ressources->getIterator(); i && i && i._; i++ )
     {
         if( i->getId() == player->m2d )
-            ret->setModelData( 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() );
     }
@@ -147,7 +147,7 @@ Team *Karte::createTeam( int tNum ) const
     return ret;
 }
 
-SpielObjekt *Karte::createObjekt( int oNum, Schrift *zSchrift ) const
+SpielObjekt *Karte::createObjekt( int oNum, UIInit &uiFactory ) const
 {
     if( oNum <= 0 )
         return 0;
@@ -159,14 +159,14 @@ SpielObjekt *Karte::createObjekt( int oNum, Schrift *zSchrift ) const
     }
     if( !obj )
         return 0;
-    SpielObjekt *ret = new SpielObjekt( obj, zSchrift );
+    SpielObjekt *ret = new SpielObjekt( obj, uiFactory );
     Bild *bild = 0;
     for( auto i = ressources->getIterator(); i && i._; i++ )
     {
         if( i->getId() == obj->m2d )
-            ret->setModel( i->zReccourceM2()->getThis() );
+            ret->setModel( dynamic_cast<Model2DData *>( i->zReccourceM2()->getThis() ) );
         if( i->getId() == obj->bild )
-            bild = i->zReccourceTxt()->getThis();
+            bild = dynamic_cast<Bild *>( i->zReccourceTxt()->getThis() );
     }
     if( bild )
         ret->setTextur( bild );
@@ -203,19 +203,4 @@ int Karte::getTeamNummer( int sNum ) const
         min += teamGröße->hat( i ) ? teamGröße->get( i ) : 0;
     }
     return -1;
-}
-
-// Reference Counting
-Karte *Karte::getThis()
-{
-    ref++;
-    return this;
-}
-
-Karte *Karte::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Asteroids/Spiel/Karte/Karte.h

@@ -3,6 +3,7 @@
 
 #include <Datei.h>
 #include <Vec2.h>
+#include <UIInitialization.h>
 #include "../Team/Team.h"
 #include "../Spieler/Spieler.h"
 #include "../Objekt/SpielObjekt.h"
@@ -11,43 +12,39 @@
 
 using namespace Framework;
 
-class Karte
+class Karte : public virtual ReferenceCounter
 {
 private:
-	Vec2< int > größe;
-	int spielerAnzahl;
-	int teamAnzahl;
-	Array< int > *spielerFarbe;
-	Array< int > *teamFarbe;
-	RCArray< Text > *teamName;
-	Array< int > *teamGröße;
-	RCArray< RessourceStr > *ressources;
-	RCArray< ObjektStr > *objekte;
-	RCArray< SpielerStr > *spieler;
-	RCArray< TeamStr > *teams;
-	int ref;
+    Vec2< int > größe;
+    int spielerAnzahl;
+    int teamAnzahl;
+    Array< int > *spielerFarbe;
+    Array< int > *teamFarbe;
+    RCArray< Text > *teamName;
+    Array< int > *teamGröße;
+    RCArray< RessourceStr > *ressources;
+    RCArray< ObjektStr > *objekte;
+    RCArray< SpielerStr > *spieler;
+    RCArray< TeamStr > *teams;
 
 public:
-	// Konstruktor
-	Karte();
-	// Destruktor
-	~Karte();
-	// nicht constant
-	void ladeSts( Datei *zDatei ); // call 1
-	void ladeMap( Datei *zDatei, int mapId, KSGClient::SpielServerClient *zSpielKlient, Text *zGamePath ); // call 2
-	// constant
-	Vec2< int > getSize() const;
-	Spieler *createSpieler( int sNum, Schrift *zSchrift, KSGClient::InformationServerClient *zInfoK, Animation2DData *zFStart, Animation2DData *zFBurn ) const;
-	Team *createTeam( int tNum ) const;
-	SpielObjekt *createObjekt( int oNum, Schrift *zSchrift ) const;
+    // Konstruktor
+    Karte();
+    // Destruktor
+    ~Karte();
+    // nicht constant
+    void ladeSts( Datei *zDatei ); // call 1
+    void ladeMap( Datei *zDatei, int mapId, KSGClient::SpielServerClient *zSpielKlient, Text *zGamePath ); // call 2
+    // constant
+    Vec2< int > getSize() const;
+    Spieler *createSpieler( int sNum, UIInit &uiFactory, KSGClient::InformationServerClient *zInfoK, Animation2DData *zFStart, Animation2DData *zFBurn ) const;
+    Team *createTeam( int tNum ) const;
+    SpielObjekt *createObjekt( int oNum, UIInit &uiFactory ) const;
     Iterator< ObjektStr * > getObjekte() const;
-	int getMaxTeamAnzahl() const;
-	int getMaxSpielerAnzahl() const;
-	int getObjektAnzahl() const;
-	int getTeamNummer( int sNum ) const;
-	// Reference Counting
-	Karte *getThis();
-	Karte *release();
+    int getMaxTeamAnzahl() const;
+    int getMaxSpielerAnzahl() const;
+    int getObjektAnzahl() const;
+    int getTeamNummer( int sNum ) const;
 };
 
 #endif

Asteroids/Spiel/Karte/Strukturen.cpp

@@ -5,8 +5,9 @@
 // Inhalt der RessourceStr Klasse aus Strukturen.h
 // Konstruktor
 RessourceStr::RessourceStr( Datei *zDatei, int karteId, Text *zGamePath )
+    : ReferenceCounter()
 {
-    zDatei->lese( (char *)& id, 4 );
+    zDatei->lese( (char *)&id, 4 );
     char län = 0;
     zDatei->lese( &län, 1 );
     Text txt;
@@ -32,7 +33,7 @@ RessourceStr::RessourceStr( Datei *zDatei, int karteId, Text *zGamePath )
     if( pfad && pfad->hat( ".m2/" ) )
     {
         int pos = pfad->positionVon( ".m2/", pfad->anzahlVon( ".m2/" ) - 1 );
-        M2Datei * datei = new M2Datei( pfad->getTeilText( 0, pos + 3 ) );
+        M2Datei *datei = new M2Datei( pfad->getTeilText( 0, pos + 3 ) );
         datei->leseDaten();
         m2d = datei->ladeModel( pfad->getTeilText( pos + 4 ) );
         datei->release();
@@ -40,13 +41,12 @@ RessourceStr::RessourceStr( Datei *zDatei, int karteId, Text *zGamePath )
     if( pfad && pfad->hat( ".ltdb/" ) )
     {
         int pos = pfad->positionVon( ".ltdb/", pfad->anzahlVon( ".ltdb/" ) - 1 );
-        LTDBDatei * datei = new LTDBDatei();
+        LTDBDatei *datei = new LTDBDatei();
         datei->setDatei( pfad->getTeilText( 0, pos + 5 ) );
         datei->leseDaten( 0 );
         bild = datei->laden( 0, pfad->getTeilText( pos + 6 ) );
         datei->release();
     }
-    ref = 1;
 }
 
 // Destruktor
@@ -76,134 +76,74 @@ Bild *RessourceStr::zReccourceTxt() const
     return bild;
 }
 
-// Reference Counting
-RessourceStr *RessourceStr::getThis()
-{
-    ref++;
-    return this;
-}
-
-RessourceStr *RessourceStr::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der ZeichnungStr Klasse aus Strukturen.h
 // Konstruktor
-ObjektStr::ObjektStr( Datei * zDatei )
-{
-    zDatei->lese( (char *)& pos.x, 4 );
-    zDatei->lese( (char *)& pos.y, 4 );
-    zDatei->lese( (char *)& rot, 4 );
-    zDatei->lese( (char *)& scale, 4 );
-    zDatei->lese( (char *)& id, 4 );
-    zDatei->lese( (char *)& m2d, 4 );
-    zDatei->lese( (char *)& bild, 4 );
-    zDatei->lese( (char *)& style, 4 );
-    zDatei->lese( (char *)& maxStabilität, 4 );
-    zDatei->lese( (char *)& maxEnergie, 4 );
-    zDatei->lese( (char *)& energieRadius, 4 );
-    zDatei->lese( (char *)& reparatur, 8 );
-    zDatei->lese( (char *)& akkuLeistung, 8 );
+ObjektStr::ObjektStr( Datei *zDatei )
+    : ReferenceCounter()
+{
+    zDatei->lese( (char *)&pos.x, 4 );
+    zDatei->lese( (char *)&pos.y, 4 );
+    zDatei->lese( (char *)&rot, 4 );
+    zDatei->lese( (char *)&scale, 4 );
+    zDatei->lese( (char *)&id, 4 );
+    zDatei->lese( (char *)&m2d, 4 );
+    zDatei->lese( (char *)&bild, 4 );
+    zDatei->lese( (char *)&style, 4 );
+    zDatei->lese( (char *)&maxStabilität, 4 );
+    zDatei->lese( (char *)&maxEnergie, 4 );
+    zDatei->lese( (char *)&energieRadius, 4 );
+    zDatei->lese( (char *)&reparatur, 8 );
+    zDatei->lese( (char *)&akkuLeistung, 8 );
     zDatei->lese( &team, 1 );
-    ref = 1;
-}
-
-// Reference Counting
-ObjektStr *ObjektStr::getThis()
-{
-    ref++;
-    return this;
-}
-
-ObjektStr *ObjektStr::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }
 
 
 // Inhalt der SpielerStr Klasse aus Strukturen.h
 // Konstruktor
-SpielerStr::SpielerStr( Datei * zDatei )
-{
-    zDatei->lese( (char *)& id, 4 );
-    zDatei->lese( (char *)& pos.x, 4 );
-    zDatei->lese( (char *)& pos.y, 4 );
-    zDatei->lese( (char *)& rot, 8 );
-    zDatei->lese( (char *)& beschleunigung, 8 );
-    zDatei->lese( (char *)& maxStabilität, 4 );
-    zDatei->lese( (char *)& maxEnergie, 4 );
-    zDatei->lese( (char *)& reparatur, 8 );
-    zDatei->lese( (char *)& akkuLeistung, 8 );
-    zDatei->lese( (char *)& laserIntensität, 4 );
-    zDatei->lese( (char *)& laserEffizienz, 4 );
-    zDatei->lese( (char *)& laserTempo, 4 );
-    zDatei->lese( (char *)& wendigkeit, 8 );
-    zDatei->lese( (char *)& antriebEffizienz, 8 );
-    zDatei->lese( (char *)& energieSchild, 8 );
-    zDatei->lese( (char *)& energieSchildEffizienz, 8 );
-    zDatei->lese( (char *)& netzwerk, 4 );
-    zDatei->lese( (char *)& skillPunkte, 4 );
-    zDatei->lese( (char *)& m2d, 4 );
-    zDatei->lese( (char *)& bild, 4 );
-    ref = 1;
-}
-
-// Reference Counting
-SpielerStr *SpielerStr::getThis()
-{
-    ref++;
-    return this;
-}
-
-SpielerStr *SpielerStr::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
+SpielerStr::SpielerStr( Datei *zDatei )
+    : ReferenceCounter()
+{
+    zDatei->lese( (char *)&id, 4 );
+    zDatei->lese( (char *)&pos.x, 4 );
+    zDatei->lese( (char *)&pos.y, 4 );
+    zDatei->lese( (char *)&rot, 8 );
+    zDatei->lese( (char *)&beschleunigung, 8 );
+    zDatei->lese( (char *)&maxStabilität, 4 );
+    zDatei->lese( (char *)&maxEnergie, 4 );
+    zDatei->lese( (char *)&reparatur, 8 );
+    zDatei->lese( (char *)&akkuLeistung, 8 );
+    zDatei->lese( (char *)&laserIntensität, 4 );
+    zDatei->lese( (char *)&laserEffizienz, 4 );
+    zDatei->lese( (char *)&laserTempo, 4 );
+    zDatei->lese( (char *)&wendigkeit, 8 );
+    zDatei->lese( (char *)&antriebEffizienz, 8 );
+    zDatei->lese( (char *)&energieSchild, 8 );
+    zDatei->lese( (char *)&energieSchildEffizienz, 8 );
+    zDatei->lese( (char *)&netzwerk, 4 );
+    zDatei->lese( (char *)&skillPunkte, 4 );
+    zDatei->lese( (char *)&m2d, 4 );
+    zDatei->lese( (char *)&bild, 4 );
 }
 
 // Inhalt der TeamStr Klasse aus Strukturen.h
 // Konstruktor
-TeamStr::TeamStr( Datei * zDatei )
-{
-    zDatei->lese( (char *)& id, 4 );
-    zDatei->lese( (char *)& maxPunkte, 4 );
-    zDatei->lese( (char *)& beschleunigung, 8 );
-    zDatei->lese( (char *)& maxStabilität, 4 );
-    zDatei->lese( (char *)& maxEnergie, 4 );
-    zDatei->lese( (char *)& reparatur, 8 );
-    zDatei->lese( (char *)& akkuLeistung, 8 );
-    zDatei->lese( (char *)& laserIntensität, 4 );
-    zDatei->lese( (char *)& laserEffizienz, 4 );
-    zDatei->lese( (char *)& laserTempo, 4 );
-    zDatei->lese( (char *)& wendigkeit, 8 );
-    zDatei->lese( (char *)& antriebEffizienz, 8 );
-    zDatei->lese( (char *)& energieSchild, 8 );
-    zDatei->lese( (char *)& energieSchildEffizienz, 8 );
-    zDatei->lese( (char *)& punkte, 4 );
-    ref = 1;
-}
-
-// Reference Counting
-TeamStr *TeamStr::getThis()
-{
-    ref++;
-    return this;
-}
-
-TeamStr *TeamStr::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
+TeamStr::TeamStr( Datei *zDatei )
+    : ReferenceCounter()
+{
+    zDatei->lese( (char *)&id, 4 );
+    zDatei->lese( (char *)&maxPunkte, 4 );
+    zDatei->lese( (char *)&beschleunigung, 8 );
+    zDatei->lese( (char *)&maxStabilität, 4 );
+    zDatei->lese( (char *)&maxEnergie, 4 );
+    zDatei->lese( (char *)&reparatur, 8 );
+    zDatei->lese( (char *)&akkuLeistung, 8 );
+    zDatei->lese( (char *)&laserIntensität, 4 );
+    zDatei->lese( (char *)&laserEffizienz, 4 );
+    zDatei->lese( (char *)&laserTempo, 4 );
+    zDatei->lese( (char *)&wendigkeit, 8 );
+    zDatei->lese( (char *)&antriebEffizienz, 8 );
+    zDatei->lese( (char *)&energieSchild, 8 );
+    zDatei->lese( (char *)&energieSchildEffizienz, 8 );
+    zDatei->lese( (char *)&punkte, 4 );
 }

Asteroids/Spiel/Karte/Strukturen.h

@@ -8,116 +8,95 @@
 
 using namespace Framework;
 
-class RessourceStr
+class RessourceStr : public virtual ReferenceCounter
 {
 private:
-	int id;
-	int ref;
-	Model2DData *m2d;
-	Bild *bild;
-	Text *pfad;
+    int id;
+    Model2DData *m2d;
+    Bild *bild;
+    Text *pfad;
 
 public:
-	// Konstruktor
-	RessourceStr( Datei *zDatei, int karteId, Text *zGamePath );
-	// Destruktor
-	~RessourceStr();
-	// constant
-	int getId() const;
-	Model2DData *zReccourceM2() const;
-	Bild *zReccourceTxt() const;
-	// Reference Counting
-	RessourceStr *getThis();
-	RessourceStr *release();
+    // Konstruktor
+    RessourceStr( Datei *zDatei, int karteId, Text *zGamePath );
+    // Destruktor
+    ~RessourceStr();
+    // constant
+    int getId() const;
+    Model2DData *zReccourceM2() const;
+    Bild *zReccourceTxt() const;
 };
 
-class ObjektStr
+class ObjektStr : public virtual ReferenceCounter
 {
-private:
-	int ref;
-
 public:
-	Punkt pos;
+    Punkt pos;
     float rot;
     float scale;
-	int id;
-	int m2d;
-	int bild;
-	int style;
-	int maxStabilität;
-	int maxEnergie;
-	int energieRadius;
-	double reparatur;
-	double akkuLeistung;
-	char team;
+    int id;
+    int m2d;
+    int bild;
+    int style;
+    int maxStabilität;
+    int maxEnergie;
+    int energieRadius;
+    double reparatur;
+    double akkuLeistung;
+    char team;
 
-	// Konstruktor
-	ObjektStr( Datei *zDatei );
-	// Reference Counting
-    ObjektStr *getThis();
-    ObjektStr *release();
+    // Konstruktor
+    ObjektStr( Datei *zDatei );
 };
 
-class SpielerStr
+class SpielerStr : public virtual ReferenceCounter
 {
-private:
-	int ref;
 
 public:
-	int id;
-	Punkt pos;
-	double rot;
-	double beschleunigung;
-	int maxStabilität;
-	int maxEnergie;
-	double reparatur;
-	double akkuLeistung;
-	int laserIntensität;
-	int laserEffizienz;
-	int laserTempo;
-	double wendigkeit;
+    int id;
+    Punkt pos;
+    double rot;
+    double beschleunigung;
+    int maxStabilität;
+    int maxEnergie;
+    double reparatur;
+    double akkuLeistung;
+    int laserIntensität;
+    int laserEffizienz;
+    int laserTempo;
+    double wendigkeit;
     double antriebEffizienz;
     double energieSchild;
     double energieSchildEffizienz;
-	int netzwerk;
-	int skillPunkte;
-	int m2d;
-	int bild;
+    int netzwerk;
+    int skillPunkte;
+    int m2d;
+    int bild;
 
-	// Konstruktor
-	SpielerStr( Datei *zDatei );
-	// Reference Counting
-	SpielerStr *getThis();
-	SpielerStr *release();
+    // Konstruktor
+    SpielerStr( Datei *zDatei );
 };
 
-class TeamStr
+class TeamStr : public virtual ReferenceCounter
 {
-private:
-	int ref;
-
 public:
-	int id;
-	int maxPunkte;
-	double beschleunigung;
-	int maxStabilität;
-	int maxEnergie;
-	double reparatur;
-	double akkuLeistung;
-	int laserIntensität;
-	int laserEffizienz;
-	int laserTempo;
-	double wendigkeit;
+    int id;
+    int maxPunkte;
+    double beschleunigung;
+    int maxStabilität;
+    int maxEnergie;
+    double reparatur;
+    double akkuLeistung;
+    int laserIntensität;
+    int laserEffizienz;
+    int laserTempo;
+    double wendigkeit;
     double antriebEffizienz;
     double energieSchild;
     double energieSchildEffizienz;
-	int punkte;
+    int punkte;
 
-	// Konstruktor
-	TeamStr( Datei *zDatei );
-	// Reference Counting
-	TeamStr *getThis();
-	TeamStr *release();
+    // Konstruktor
+    TeamStr( Datei *zDatei );
 };
 
 #endif

Asteroids/Spiel/Objekt/SpielObjekt.cpp

@@ -5,7 +5,7 @@
 
 // Inhalt der SpielObjekt Klasse aus SpielObjekt.h
 // Konstruktor
-SpielObjekt::SpielObjekt( ObjektStr *zStr, Schrift *zSchrift )
+SpielObjekt::SpielObjekt( ObjektStr *zStr, UIInit &uiFactory )
     : Model2DObject()
 {
     id = zStr->id;
@@ -27,7 +27,7 @@ SpielObjekt::SpielObjekt( ObjektStr *zStr, Schrift *zSchrift )
     nextSkillEp = 80;
     setCollision( ( style | 0x4 ) == style );
     deadPlayer = 0;
-    nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
+    nText = initTextFeld( 0, 0, 152, 30, uiFactory, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
                           TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
     save();
 }
@@ -77,21 +77,21 @@ void SpielObjekt::load()
     level = last.level;
 }
 
-void SpielObjekt::setTextur( Bild * textur )
+void SpielObjekt::setTextur( Bild *textur )
 {
     Textur2D *t = new Textur2D();
     t->setTexturZ( textur );
     __super::setTextur( t );
 }
 
-void SpielObjekt::setTeam( Team * team )
+void SpielObjekt::setTeam( Team *team )
 {
     this->zteam = team;
     nText->setHintergrundFarbe( 0xA0000000 | ( zteam->farbe & 0x00FFFFFF ) );
     nText->setRahmenFarbe( zteam->farbe );
 }
 
-bool SpielObjekt::tick( const WeltInfo & info, double zeit )
+bool SpielObjekt::tick( const WeltInfo &info, double zeit )
 {
     if( !amLeben )
         return 0;
@@ -131,7 +131,7 @@ bool SpielObjekt::tick( const WeltInfo & info, double zeit )
     return Model2DObject::tick( info, zeit );
 }
 
-void SpielObjekt::render( Mat3<float> & kamMat, Bild & zRObj, const char *kamName )
+void SpielObjekt::render( Mat3<float> &kamMat, Bild &zRObj, const char *kamName )
 {
     if( !amLeben )
         return;
@@ -194,7 +194,7 @@ void SpielObjekt::addEp( float ep )
     }
 }
 
-void SpielObjekt::calcDeadPlayerObject( Laser * zSchuss )
+void SpielObjekt::calcDeadPlayerObject( Laser *zSchuss )
 {
     Vertex hp;
     Polygon2D a;
@@ -226,12 +226,12 @@ void SpielObjekt::calcDeadPlayerObject( Laser * zSchuss )
     }
 }
 
-DeadPlayer * SpielObjekt::sterben()
+DeadPlayer *SpielObjekt::sterben()
 {
     amLeben = 0;
     setCollision( 0 );
     stabilität = 0;
-    return deadPlayer ? (DeadPlayer *)deadPlayer->getThis() : 0;
+    return deadPlayer ? dynamic_cast<DeadPlayer *>( deadPlayer->getThis() ) : 0;
 }
 
 // constant

Asteroids/Spiel/Objekt/SpielObjekt.h

@@ -9,6 +9,7 @@
 #include <Welt2D.h>
 #include "../Schuss/Laser.h"
 #include "../Spieler/DeadPlayer.h"
+#include <UIInitialization.h>
 
 using namespace Framework;
 
@@ -32,43 +33,43 @@ private:
         double maxStabilität;
         int level;
     } last;
-	int id;
-	int style;
-	double stabilität;
-	double energie;
+    int id;
+    int style;
+    double stabilität;
+    double energie;
     double maxStabilität;
     double maxEnergie;
-	int energieRadius;
-	double reparatur;
-	double akkuLeistung;
-	double repAbk;
-	double akkuAbk;
+    int energieRadius;
+    double reparatur;
+    double akkuLeistung;
+    double repAbk;
+    double akkuAbk;
     bool amLeben;
     int level;
     float ep;
     float nextSkillEp;
-	Team *zteam;
-	TextFeld *nText;
+    Team *zteam;
+    TextFeld *nText;
     DeadPlayer *deadPlayer;
 
 public:
-	// Konstruktor
-	SpielObjekt( ObjektStr *zStr, Schrift *zSchrift );
-	// Destruktor
-	~SpielObjekt();
-	// nicht constant
-	void setTextur( Bild *textur );
-	void setTeam( Team *zTeam );
-	bool tick( const WeltInfo &info, double zeit ) override;
-	void render( Mat3<float> &kamMat, Bild &zRObj, const char *kamName ) override;
+    // Konstruktor
+    SpielObjekt( ObjektStr *zStr, UIInit &uiFactory );
+    // Destruktor
+    ~SpielObjekt();
+    // nicht constant
+    void setTextur( Bild *textur );
+    void setTeam( Team *zTeam );
+    bool tick( const WeltInfo &info, double zeit ) override;
+    void render( Mat3<float> &kamMat, Bild &zRObj, const char *kamName ) override;
     void nimmSchaden( double &intensity, int sLevel );
     void addEp( float ep );
     DeadPlayer *sterben();
     void calcDeadPlayerObject( Laser *zSchuss );
     void save();
     void load();
-	// constant
-	Team *zTeam() const;
+    // constant
+    Team *zTeam() const;
     bool doesShotAddEp() const;
     int getLevel() const;
     int getObjektId() const;

Asteroids/Spiel/Skill/Skill.cpp

@@ -1,6 +1,7 @@
 #include "Skill.h"
 
 ActiveSkill::ActiveSkill( Bild *bild )
+    : ReferenceCounter()
 {
     current.active = 0;
     current.time = 0;
@@ -34,7 +35,6 @@ ActiveSkill::ActiveSkill( Bild *bild )
     energieSchildFactor = 1;
     energieSchildEffizienzFactor = 1;
 
-    ref = 1;
     save();
 }
 
@@ -217,19 +217,6 @@ double ActiveSkill::getEnergieSchildEffizienzFactor()
     return current.active ? energieSchildEffizienzFactor : 1;
 }
 
-ActiveSkill *ActiveSkill::getThis()
-{
-    ref++;
-    return this;
-}
-
-ActiveSkill *ActiveSkill::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
-}
-
 
 SpeedBoost::SpeedBoost( Bild *bild )
     : ActiveSkill( bild )

Asteroids/Spiel/Skill/Skill.h

@@ -4,7 +4,7 @@
 
 using namespace Framework;
 
-class ActiveSkill
+class ActiveSkill : public virtual ReferenceCounter
 {
 protected:
     struct SkillDataSave
@@ -13,7 +13,6 @@ protected:
         double time;
     } current, last;
     double maxTime;
-    int ref;
     double reloadTimeFactor;
     Bild *bild;
 
@@ -81,9 +80,6 @@ public:
     double getAntriebEffizienzFactor();
     double getEnergieSchildFactor();
     double getEnergieSchildEffizienzFactor();
-
-    ActiveSkill *getThis();
-    ActiveSkill *release();
 };
 
 class SpeedBoost : public ActiveSkill

Asteroids/Spiel/SpielKlasse.cpp

@@ -13,7 +13,9 @@
 // Inhalt der SpielKlasse Klasse aus SpielKlasse.h
 // Konstruktor
 SpielKlasse::SpielKlasse()
+    : ReferenceCounter()
 {
+    this->uiFactory.initParam.schrift = 0;
     shieldBoost = 0;
     speedBoost = 0;
     spielZeit = -1;
@@ -21,7 +23,6 @@ SpielKlasse::SpielKlasse()
     rendern = 0;
     stkn = new RCArray< STKNachricht >();
     stkna = 0;
-    schrift = 0;
     time_t t;
     time( &t );
     srand( (unsigned int)t );
@@ -32,15 +33,14 @@ SpielKlasse::SpielKlasse()
     teams = new RCArray< Team >();
     objekte = new RCArray< SpielObjekt >();
     deads = new RCArray< DeadPlayer >();
-    screen = 0;
     welt = new Welt2D();
     welt->setCircular( 1 );
     welt->setAirResistance( 0.001f );
     kam = new Kamera2D();
-    kam->setWelt( welt->getThis(), 1 );
+    kam->setWelt( dynamic_cast<Welt2D *>( welt->getThis() ), 1 );
     minimap = new Kamera2D();
     minimap->setSize( 200, 200 );
-    minimap->setWelt( 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" );
@@ -50,7 +50,7 @@ SpielKlasse::SpielKlasse()
     spielerNummer = 0;
     map = 0;
     end = 0;
-    chat = new SpielChat();
+    chat = 0;
     tasten = new char[ 256 ];
     for( int i = 0; i < 256; i++ )
         tasten[ i ] = 0;
@@ -62,7 +62,6 @@ SpielKlasse::SpielKlasse()
     asteroidModels = new RCArray< Model2DData >();
     asteroidTextures = new RCArray< Textur2D >();
     pixel = new RCArray< Pixel >();
-    ref = 1;
     save();
 }
 
@@ -79,8 +78,6 @@ SpielKlasse::~SpielKlasse()
     welt->release();
     deads->release();
     stkn->release();
-    if( schrift )
-        schrift->release();
     if( infoKlient )
         infoKlient->release();
     if( spielKlient )
@@ -93,7 +90,8 @@ SpielKlasse::~SpielKlasse()
         bestenliste->release();
     if( shipGUI )
         shipGUI->release();
-    chat->relese();
+    if( chat )
+        chat->release();
     spieler->release();
     asteroids->release();
     asteroidModels->release();
@@ -190,31 +188,24 @@ void SpielKlasse::tick()
 // nicht constant
 void SpielKlasse::lock()
 {
-    if( screen )
-        screen->lock();
+    if( uiFactory.initParam.bildschirm )
+        uiFactory.initParam.bildschirm->lock();
 }
 
 void SpielKlasse::unlock()
 {
-    if( screen )
-        screen->unlock();
+    if( uiFactory.initParam.bildschirm )
+        uiFactory.initParam.bildschirm->unlock();
 }
 
-void SpielKlasse::setSchrift( Schrift * schrift )
+void SpielKlasse::setUIFactory( UIInit &uiFactory )
 {
-    if( this->schrift )
-        this->schrift->release();
-    this->schrift = schrift;
-    chat->setSchrift( schrift );
+    this->uiFactory = uiFactory;
+    chat = new SpielChat( uiFactory );
     if( !bestenliste )
-        bestenliste = new Bestenliste( schrift->getThis() );
+        bestenliste = new Bestenliste( uiFactory );
     if( !shipGUI )
-        shipGUI = new SpielerGUI( schrift );
-}
-
-void SpielKlasse::setBildschirm( Bildschirm * zScreen )
-{
-    screen = zScreen;
+        shipGUI = new SpielerGUI( uiFactory );
 }
 
 void SpielKlasse::nachricht( int län, char *bytes )
@@ -227,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();
@@ -263,7 +254,7 @@ void SpielKlasse::ladeDaten()
     flammenStartLTDB.setDatei( f_start );
     flammenStartLTDB.leseDaten( 0 );
     Animation2DData *flammenStart = new Animation2DData();
-    flammenStart->ladeAnimation( flammenStartLTDB.getThis() );
+    flammenStart->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenStartLTDB.getThis() ) );
     flammenStart->setFPS( 75 );
     flammenStart->setWiederhohlend( 0 );
     spielKlient->setLadenProzent( 7 );
@@ -272,7 +263,7 @@ void SpielKlasse::ladeDaten()
     f_burn->append( "/bilder/f_burn.ltdb" );
     flammenLTDB.setDatei( f_burn );
     Animation2DData *flammenBurn = new Animation2DData();
-    flammenBurn->ladeAnimation( flammenLTDB.getThis() );
+    flammenBurn->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenLTDB.getThis() ) );
     flammenBurn->setFPS( 60 );
     flammenBurn->setWiederhohlend( 1 );
     map = new Karte();
@@ -296,7 +287,7 @@ void SpielKlasse::ladeDaten()
     mapPf->release();
     for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
     {
-        Spieler *s = map->createSpieler( i, schrift, infoKlient, flammenStart, flammenBurn );
+        Spieler *s = map->createSpieler( i, uiFactory, infoKlient, flammenStart, flammenBurn );
         spieler->set( s, i );
     }
     flammenStart->release();
@@ -307,9 +298,9 @@ void SpielKlasse::ladeDaten()
         teams->add( map->createTeam( i ) );
     for( auto o = map->getObjekte(); o; o++ )
     {
-        SpielObjekt *obj = map->createObjekt( o->id, schrift );
+        SpielObjekt *obj = map->createObjekt( o->id, uiFactory );
         obj->setTeam( teams->get( o->team - 1 ) );
-        welt->addObject( obj->getThis() );
+        welt->addObject( dynamic_cast<SpielObjekt *>( obj->getThis() ) );
         objekte->add( obj );
     }
     bestenliste->setTeamAnzahl( map->getMaxTeamAnzahl() );
@@ -330,7 +321,7 @@ void SpielKlasse::ladeDaten()
     LTDBDatei asteroidTexturD;
     Text aTexturPfad = gamePath->getText();
     aTexturPfad += "/bilder/asteroids.ltdb";
-    asteroidTexturD.setDatei( aTexturPfad.getThis() );
+    asteroidTexturD.setDatei( dynamic_cast<Text *>( aTexturPfad.getThis() ) );
     asteroidTexturD.leseDaten( 0 );
     for( int i = 0; i < anz; i++ )
     {
@@ -353,7 +344,7 @@ void SpielKlasse::ladeDaten()
     gamePath->release();
 }
 
-void SpielKlasse::doPublicMausEreignis( MausEreignis & me )
+void SpielKlasse::doPublicMausEreignis( MausEreignis &me )
 {
     if( end )
     {
@@ -375,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 )
@@ -690,26 +681,26 @@ void SpielKlasse::stknVerarbeitung()
             if( 1 )
             {
                 bytes++;
-                spielerAnzahl = (int)* bytes;
+                spielerAnzahl = (int)*bytes;
                 bytes++;
                 län--;
                 for( int i = 0; i < spielerAnzahl; i++ )
                 {
                     int sNum = *(int *)bytes;
                     Spieler *tmp = spieler->z( sNum - 1 );
-                    tmp->addSkill( new ShieldBoost( shieldBoost->getThis() ) );
-                    tmp->addSkill( new SpeedBoost( speedBoost->getThis() ) );
+                    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 );
                     bytes += 4;
                     län -= 4;
                     tmp->setTeam( teams->z( map->getTeamNummer( sNum ) ) );
-                    tmp->zTeam()->spieler->add( (Spieler *)tmp->getThis() );
+                    tmp->zTeam()->spieler->add( dynamic_cast<Spieler *>( tmp->getThis() ) );
                     bestenliste->addSpieler( tmp );
                     bestenliste->updateSpieler( tmp );
                     bestenliste->updateTeam( tmp->zTeam() );
-                    welt->addObject( tmp->getThis() );
+                    welt->addObject( dynamic_cast<Spieler *>( tmp->getThis() ) );
                 }
                 int max = map->getMaxSpielerAnzahl();
                 for( int i = 0; i < max; i++ )
@@ -774,7 +765,7 @@ void SpielKlasse::stknVerarbeitung()
                 csv.schreibe( line, line.getLength() );
             }
             csv.close();
-            end = new Ende( schrift );
+            end = new Ende( uiFactory );
             bytes++;
             län--;
             end->setGewonnen( *bytes );
@@ -865,7 +856,7 @@ void SpielKlasse::stknVerarbeitung()
                     }
                 }
                 Laser *l = new Laser( id, Vertex( xPos, yPos ), Vertex( xSpeed, ySpeed ), sNum, intensität, farbe );
-                welt->addObject( l->getThis() );
+                welt->addObject( dynamic_cast<Laser *>( l->getThis() ) );
                 schüsse->add( l );
                 goToPresence( presence );
                 if( sNum == spielerNummer )
@@ -1004,7 +995,7 @@ void SpielKlasse::stknVerarbeitung()
                     DeadPlayer *dp = dead->sterben();
                     if( dp )
                     {
-                        welt->addObject( dp->getThis() );
+                        welt->addObject( dynamic_cast<DeadPlayer *>( dp->getThis() ) );
                         deads->add( dp );
                     }
                     bestenliste->updateSpieler( dead );
@@ -1060,7 +1051,7 @@ void SpielKlasse::stknVerarbeitung()
             län -= 4;
             goBackInTime( zeit );
             Asteroid *na = new Asteroid( id, pos, speed, rot, rotS, asteroidModels->get( index ), asteroidTextures->get( index ) );
-            welt->addObject( na->getThis() );
+            welt->addObject( dynamic_cast<Asteroid *>( na->getThis() ) );
             asteroids->add( na );
             goToPresence( presence );
             break;
@@ -1117,8 +1108,8 @@ void SpielKlasse::stknVerarbeitung()
                                     break;
                                 }
                             }
-                            Asteroid * na = a->split( pos, tmp->getSpeed(), seed, newAsteroid );
-                            welt->addObject( 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 );
@@ -1144,7 +1135,7 @@ void SpielKlasse::stknVerarbeitung()
                 if( a->getId() == asteroid )
                 {
                     Pixel *p = new Pixel( a->getPosition(), a->getSpeed(), a->getMasse() / 50, pixelId );
-                    welt->addObject( p->getThis() );
+                    welt->addObject( dynamic_cast<Pixel *>( p->getThis() ) );
                     pixel->add( p );
                     a->setDead();
                     break;
@@ -1302,7 +1293,7 @@ void SpielKlasse::stknVerarbeitung()
                 DeadPlayer *dp = dead->sterben();
                 if( dp )
                 {
-                    welt->addObject( dp->getThis() );
+                    welt->addObject( dynamic_cast<DeadPlayer *>( dp->getThis() ) );
                     deads->add( dp );
                 }
             }
@@ -1430,17 +1421,17 @@ bool SpielKlasse::tick( double zeit )
     return 1;
 }
 
-void SpielKlasse::render( Bild & zRObj )
+void SpielKlasse::render( Bild &zRObj )
 {
     if( !rendern )
         return;
     lock();
-    kam->lookAtWorldArea( zRObj.getBreite(), zRObj.getHeight() );
+    kam->lookAtWorldArea( (float)zRObj.getBreite(), (float)zRObj.getHeight() );
     kam->setSize( zRObj.getSize() );
     kam->render( zRObj );
     minimap->setPosition( zRObj.getSize() - Punkt( 210, 210 ) );
-    minimap->lookAtWorldPos( welt->getWorldInfo().size.x / 2, welt->getWorldInfo().size.y / 2 );
-    minimap->lookAtWorldArea( welt->getWorldInfo().size.x, welt->getWorldInfo().size.y );
+    minimap->lookAtWorldPos( (float)welt->getWorldInfo().size.x / 2, (float)welt->getWorldInfo().size.y / 2 );
+    minimap->lookAtWorldArea( (float)welt->getWorldInfo().size.x, (float)welt->getWorldInfo().size.y );
     minimap->render( zRObj );
     chat->render( zRObj );
     if( bestenliste )
@@ -1464,19 +1455,4 @@ int SpielKlasse::l
     if( end && end->getWeiter() )
         return 0;
     return 0;
-}
-
-// Reference Counting
-SpielV *SpielKlasse::getThis()
-{
-    ref++;
-    return this;
-}
-
-SpielV *SpielKlasse::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Asteroids/Spiel/SpielKlasse.h

@@ -23,25 +23,24 @@ private:
         int spielZeit;
     };
 
-	RCArray< STKNachricht > *stkn;
-	int stkna;
-	Bestenliste *bestenliste;
-	Schrift *schrift;
+    RCArray< STKNachricht > *stkn;
+    int stkna;
+    Bestenliste *bestenliste;
+    UIInit uiFactory;
     KSGClient::InformationServerClient *infoKlient;
     KSGClient::SpielServerClient *spielKlient;
-	RCArray< Spieler > *spieler;
+    RCArray< Spieler > *spieler;
     RCArray< Asteroid > *asteroids;
-	RCArray< Team > *teams;
-	RCArray< SpielObjekt > *objekte;
+    RCArray< Team > *teams;
+    RCArray< SpielObjekt > *objekte;
     RCArray< Laser > *schüsse;
-	Bildschirm *screen;
-	Karte *map;
-	Kamera2D *kam;
+    Karte *map;
+    Kamera2D *kam;
     Kamera2D *minimap;
     Welt2D *welt;
-	SpielChat *chat;                                                                                                   
-	Ende *end;
-	SpielerGUI *shipGUI;
+    SpielChat *chat;
+    Ende *end;
+    SpielerGUI *shipGUI;
     Datei csv;
     RCArray< DeadPlayer > *deads;
     RCArray< Model2DData > *asteroidModels;
@@ -49,20 +48,19 @@ private:
     RCArray< Pixel > *pixel;
     Bild *speedBoost;
     Bild *shieldBoost;
-	bool rendern;
-	int spielZeit;
-	double rZeit;
-	int spielerAnzahl;
-	int karteId;
-	int ladenProzent;
-	int spielerNummer;
-	char *tasten;
-	bool spielPause;
+    bool rendern;
+    int spielZeit;
+    double rZeit;
+    int spielerAnzahl;
+    int karteId;
+    int ladenProzent;
+    int spielerNummer;
+    char *tasten;
+    bool spielPause;
     SaveData last;
     bool setKam;
-	int ref;
 
-	bool istAmLeben() const;
+    bool istAmLeben() const;
     void goBackInTime( int zeit );
     void goToPresence( int zeit );
     void load();
@@ -70,29 +68,25 @@ private:
     void tick();
 
 public:
-	// Konstruktor
-	SpielKlasse();
-	// Destruktor
-	~SpielKlasse();
-	// nicht constant
-	void lock();
-	void unlock();
-	void setSchrift( Schrift *schrift ) override; // call 4
-	void setBildschirm( Bildschirm *zScreen ) override; // call 3
-	void nachricht( int län, char *bytes ) override;
-	void setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient ) override; // call 2
-	void setKarteId( int karteId ) override; // call 1
-	void ladeDaten() override; // call 5
-	void doPublicMausEreignis( MausEreignis &me ) override;
-	void doTastaturEreignis( TastaturEreignis &te ) override;
-	void stknVerarbeitung();
-	bool tick( double zeit ) override;
-	void render( Bild &zRObj ) override;
-	// constant
-	int läuft() const override;
-	// Reference Counting
-	SpielV *getThis() override;
-	SpielV *release() override;
+    // Konstruktor
+    SpielKlasse();
+    // Destruktor
+    ~SpielKlasse();
+    // nicht constant
+    void lock();
+    void unlock();
+    void setUIFactory( UIInit &factory ) override; // call 3
+    void nachricht( int län, char *bytes ) override;
+    void setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient ) override; // call 2
+    void setKarteId( int karteId ) override; // call 1
+    void ladeDaten() override; // call 4
+    void doPublicMausEreignis( MausEreignis &me ) override;
+    void doTastaturEreignis( TastaturEreignis &te ) override;
+    void stknVerarbeitung();
+    bool tick( double zeit ) override;
+    void render( Bild &zRObj ) override;
+    // constant
+    int läuft() const override;
 };
 
 #endif

Asteroids/Spiel/Spieler/DeadPlayer.cpp

@@ -9,14 +9,14 @@ DeadPlayer::DeadPlayer( Model2DData *mda, Model2DData *mdb, Vertex posa, Vertex
     m2a = new Model2DObject();
     m2a->setModel( mda );
     m2a->setPosition( posa );
-    m2a->setTextur( zTextur->getThis() );
+    m2a->setTextur( dynamic_cast<Textur2D *>( zTextur->getThis() ) );
     m2a->setDrehung( curRotA );
     m2a->setSpeed( speedA );
     m2a->setDrehungSpeed( rotA );
     m2b = new Model2DObject();
     m2b->setModel( mdb );
     m2b->setPosition( posb );
-    m2b->setTextur( zTextur->getThis() );
+    m2b->setTextur( dynamic_cast<Textur2D *>( zTextur->getThis() ) );
     m2b->setDrehung( curRotB );
     m2b->setSpeed( speedB );
     m2b->setDrehungSpeed( rotB );

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -7,7 +7,7 @@
 
 // Inhalt der Spieler Klasse aus Spieler.h
 // Konstruktor
-Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift, SpielerStr *zStr )
+Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, UIInit &uiFactory, SpielerStr *zStr )
     : Model2DObject()
 {
     activeSkills = new RCArray< ActiveSkill >();
@@ -56,7 +56,7 @@ Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift,
     tode = 0;
     zeitAmLeben = 0;
     zeitTod = 0;
-    nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
+    nText = initTextFeld( 0, 0, 152, 30, uiFactory, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
                           TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
     ep = 0;
     nextSkillEp = 80;
@@ -225,8 +225,8 @@ double Spieler::calculateEnergieSchildEffizienz()
 double Spieler::calculateLaserCost()
 {
     double kosten = ( calculateLaserIntensität() / 2 +
-        calculateLaserTempo() / 9 ) *
-                      ( 1 / ( calculateLaserEffizienz() / 25 ) );
+                      calculateLaserTempo() / 9 ) *
+        ( 1 / ( calculateLaserEffizienz() / 25 ) );
     if( kosten < 1 )
         kosten = 1;
     return kosten;
@@ -244,7 +244,7 @@ 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++ )
     {
@@ -302,17 +302,17 @@ void Spieler::setModelData( Model2DData * data, Animation2DData * zFStart, Anima
     kM.normalize();
     setModel( data );
     flammenM = new Textur2D();
-    flammenM->addAnimationZ( zFStart->getThis() );
-    flammenM->addAnimationZ( zFBurn->getThis() );
+    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( zFStart->getThis() ) );
+    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( zFBurn->getThis() ) );
     flammenL = new Textur2D();
-    flammenL->addAnimationZ( zFStart->getThis() );
-    flammenL->addAnimationZ( zFBurn->getThis() );
+    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( zFStart->getThis() ) );
+    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( zFBurn->getThis() ) );
     flammenR = new Textur2D();
-    flammenR->addAnimationZ( zFStart->getThis() );
-    flammenR->addAnimationZ( zFBurn->getThis() );
-    setTextur( flammenL->getThis(), "engine_l" );
-    setTextur( flammenR->getThis(), "engine_r" );
-    setTextur( 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,14 +323,14 @@ 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->setRahmenFarbe( zteam->farbe );
 }
 
-void Spieler::setSpielerFarbe( int fc, Bild * zTextur )
+void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
 {
     farbe = fc;
     nText->setSchriftFarbe( fc );
@@ -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 )
@@ -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,7 +480,7 @@ 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;
@@ -601,7 +601,7 @@ void Spieler::nimmSchaden( double &intensit
     }
 }
 
-void Spieler::calcDeadPlayerObject( Laser * zSchuss )
+void Spieler::calcDeadPlayerObject( Laser *zSchuss )
 {
     Vertex hp;
     Polygon2D a;
@@ -660,7 +660,7 @@ DeadPlayer *Spieler::sterben()
     reinkAbk += maxReinkAbk;
     maxReinkAbk++;
     punkte--;
-    return deadPlayer ? (DeadPlayer *)deadPlayer->getThis() : 0;
+    return deadPlayer ? dynamic_cast<DeadPlayer *>( deadPlayer->getThis() ) : 0;
 }
 
 void Spieler::wiederbelebung()
@@ -821,7 +821,7 @@ int Spieler::getAccountId() const
 
 Text *Spieler::getName() const
 {
-    return name ? name->getThis() : 0;
+    return name ? dynamic_cast<Text *>( name->getThis() ) : 0;
 }
 
 Text *Spieler::zName() const

Asteroids/Spiel/Spieler/Spieler.h

@@ -9,6 +9,7 @@
 #include "../Karte/Strukturen.h"
 #include "DeadPlayer.h"
 #include "../Skill/Skill.h"
+#include <UIInitialization.h>
 
 class Team;
 class Laser;
@@ -17,16 +18,16 @@ class SpielerGUI;
 
 enum TastaturStatus
 {
-	T_GAS,
-	T_ROT_L,
-	T_ROT_R,
-	T_FEUER,
-	T_MAX
+    T_GAS,
+    T_ROT_L,
+    T_ROT_R,
+    T_FEUER,
+    T_MAX
 };
 
 class Spieler : public Model2DObject
 {
-	friend class SpielerGUI;
+    friend class SpielerGUI;
 private:
     int accountId;
     int sNum;
@@ -117,7 +118,7 @@ private:
     int kills;
     int tode;
     SpielerDataSave last;
-	int skillPunkte;
+    int skillPunkte;
     Textur2D *flammenM;
     Textur2D *flammenL;
     Textur2D *flammenR;
@@ -141,64 +142,64 @@ private:
     double calculateLaserCost();
 
 public:
-	// Konstruktor
-	Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift, SpielerStr *zStr );
-	// Destruktor
-	~Spieler();
-	// nicht constant
+    // Konstruktor
+    Spieler( KSGClient::InformationServerClient *zInfoK, UIInit &uiFactory, SpielerStr *zStr );
+    // Destruktor
+    ~Spieler();
+    // nicht constant
     void addSkill( ActiveSkill *skill );
     void useSkill( int id );
-	void setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn );
-	void setAccountId( int accId );
-	void setTeam( Team *zTeam );
-	void setSpielerFarbe( int fc, Bild *zTextur );
-	void setTastataturStatus( TastaturStatus ts, bool aktiv );
-	bool tick( const WeltInfo &info, double zeit ) override;
-	void render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName ) override;
-	void renderLeben( const Mat3< float > &kamMat, Bild &zRObj );
-	void setSkill( int art );
-	void nimmSchaden( double &intensität, int sLevel );
+    void setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn );
+    void setAccountId( int accId );
+    void setTeam( Team *zTeam );
+    void setSpielerFarbe( int fc, Bild *zTextur );
+    void setTastataturStatus( TastaturStatus ts, bool aktiv );
+    bool tick( const WeltInfo &info, double zeit ) override;
+    void render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName ) override;
+    void renderLeben( const Mat3< float > &kamMat, Bild &zRObj );
+    void setSkill( int art );
+    void nimmSchaden( double &intensität, int sLevel );
     void calcDeadPlayerObject( Laser *zSchuss );
-	void machSchaden( double intensität, int sLevel, bool erf = 1 );
-	void addKill( int sLevel, bool erf = 1 );
+    void machSchaden( double intensität, int sLevel, bool erf = 1 );
+    void addKill( int sLevel, bool erf = 1 );
     DeadPlayer *sterben();
-	void wiederbelebung();
-	void hatGeschossen();
+    void wiederbelebung();
+    void hatGeschossen();
     void addTreffer( float indens, int sLevel, bool erf = 1 );
     void addEp( float ep );
     void save();
     void load();
-	// constant
+    // constant
     float getEp() const;
     float getMaxEp() const;
-	int getAccountId() const;
-	Text *getName() const;
-	Text *zName() const;
-	bool hatSkill() const;
-	bool istAmLeben() const;
-	// Statistik Werte
-	int getSpielerNummer() const;
-	Team *zTeam() const;
-	int getSpielerFarbe() const;
-	int getSchadenBekommen() const;
-	int getSchadenGemacht() const;
-	int getTreibstoffVerbraucht() const;
-	int getSchüsse() const;
-	int getTreffer() const;
-	int getPunkte() const;
-	int getKills() const;
-	int getTode() const;
-	int getZeitAmLeben() const;
-	int getZeitTod() const;
-	double getTeamMaxEnergieBonus() const;
-	double getTeamMaxStabilitätBonus() const;
-	double getTeamReparaturBonus() const;
-	double getTeamLaserIntensitätBonus() const;
-	double getTeamLaserEffizienzBonus() const;
-	double getTeamAkkuLeistungBonus() const;
-	double getTeamLaserTempoBonus() const;
-	double getTeamBeschleunigungBonus() const;
-	double getTeamWendigkeitBonus() const;
+    int getAccountId() const;
+    Text *getName() const;
+    Text *zName() const;
+    bool hatSkill() const;
+    bool istAmLeben() const;
+    // Statistik Werte
+    int getSpielerNummer() const;
+    Team *zTeam() const;
+    int getSpielerFarbe() const;
+    int getSchadenBekommen() const;
+    int getSchadenGemacht() const;
+    int getTreibstoffVerbraucht() const;
+    int getSchüsse() const;
+    int getTreffer() const;
+    int getPunkte() const;
+    int getKills() const;
+    int getTode() const;
+    int getZeitAmLeben() const;
+    int getZeitTod() const;
+    double getTeamMaxEnergieBonus() const;
+    double getTeamMaxStabilitätBonus() const;
+    double getTeamReparaturBonus() const;
+    double getTeamLaserIntensitätBonus() const;
+    double getTeamLaserEffizienzBonus() const;
+    double getTeamAkkuLeistungBonus() const;
+    double getTeamLaserTempoBonus() const;
+    double getTeamBeschleunigungBonus() const;
+    double getTeamWendigkeitBonus() const;
     double getTeamAntriebEffizienzBonus() const;
     double getTeamEnergieSchildBonus() const;
     double getTeamEnergieSchildEffizienzBonus() const;

Asteroids/Spiel/SpielerGUI/SpielerGUI.cpp

@@ -16,15 +16,16 @@ int getStellen( double d )
 
 // Inhalt der Ship Klasse aus Ship.h
 // Konstruktor
-SpielerGUI::SpielerGUI( Schrift * zSchrift )
+SpielerGUI::SpielerGUI( UIInit &uiFactory )
+    : ReferenceCounter()
 {
     player = 0;
     ram = new LRahmen();
     ram->setSize( 200, 417 );
     ram->setFarbe( 0xFFFFFFFF );
-    spieler = initTextFeld( 5, 5, 190, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
-    stabilität = initTextFeld( 5, 30, 165, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
-    energie = initTextFeld( 5, 55, 165, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
+    spieler = initTextFeld( 5, 5, 190, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "" );
+    stabilität = initTextFeld( 5, 30, 165, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "" );
+    energie = initTextFeld( 5, 55, 165, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "" );
     stabilitätB = new FBalken();
     stabilitätB->setPosition( 5, 30 );
     stabilitätB->setSize( 165, 20 );
@@ -45,30 +46,30 @@ SpielerGUI::SpielerGUI( Schrift * zSchrift )
     energieB->setFRFarbe( 0xFF0000FF );
     energieB->setFRBreite( 1 );
     energieB->setStyle( FBalken::Style::Sichtbar | FBalken::Style::L_R | FBalken::Style::Hintergrund | FBalken::Style::FFarbe | FBalken::Style::Rahmen | FBalken::Style::FRahmen );
-    reparatur = initTextFeld( 5, 80, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    akkuLeistung = initTextFeld( 5, 105, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    wendigkeit = initTextFeld( 5, 130, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    beschleunigung = initTextFeld( 5, 155, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    antriebEffizienz = initTextFeld( 5, 180, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    laserIntensität = initTextFeld( 5, 205, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    laserEffizienz = initTextFeld( 5, 230, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    laserTempo = initTextFeld( 5, 255, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    energieSchild = initTextFeld( 5, 280, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    energieSchildEffizienz = initTextFeld( 5, 305, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    netzwerk = initTextFeld( 5, 330, 165, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    stabilitätSkill = initKnopf( 172, 30, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    energieSkill = initKnopf( 172, 55, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    reparaturSkill = initKnopf( 172, 80, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    akkuLeistungSkill = initKnopf( 172, 105, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    wendigkeitSkill = initKnopf( 172, 130, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    beschleunigungSkill = initKnopf( 172, 155, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    antriebEffizienzSkill = initKnopf( 172, 180, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    laserIntensitätSkill = initKnopf( 172, 205, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    laserEffizienzSkill = initKnopf( 172, 230, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    laserTempoSkill = initKnopf( 172, 255, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    energieSchildSkill = initKnopf( 172, 280, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    energieSchildEffizienzSkill = initKnopf( 172, 305, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
-    netzwerkSkill = initKnopf( 172, 330, 20, 20, zSchrift, Knopf::Style::Sichtbar, "+" );
+    reparatur = initTextFeld( 5, 80, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    akkuLeistung = initTextFeld( 5, 105, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    wendigkeit = initTextFeld( 5, 130, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    beschleunigung = initTextFeld( 5, 155, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    antriebEffizienz = initTextFeld( 5, 180, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    laserIntensität = initTextFeld( 5, 205, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    laserEffizienz = initTextFeld( 5, 230, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    laserTempo = initTextFeld( 5, 255, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    energieSchild = initTextFeld( 5, 280, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    energieSchildEffizienz = initTextFeld( 5, 305, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    netzwerk = initTextFeld( 5, 330, 165, 20, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
+    stabilitätSkill = initKnopf( 172, 30, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    energieSkill = initKnopf( 172, 55, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    reparaturSkill = initKnopf( 172, 80, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    akkuLeistungSkill = initKnopf( 172, 105, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    wendigkeitSkill = initKnopf( 172, 130, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    beschleunigungSkill = initKnopf( 172, 155, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    antriebEffizienzSkill = initKnopf( 172, 180, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    laserIntensitätSkill = initKnopf( 172, 205, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    laserEffizienzSkill = initKnopf( 172, 230, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    laserTempoSkill = initKnopf( 172, 255, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    energieSchildSkill = initKnopf( 172, 280, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    energieSchildEffizienzSkill = initKnopf( 172, 305, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
+    netzwerkSkill = initKnopf( 172, 330, 20, 20, uiFactory, Knopf::Style::Sichtbar, "+" );
     stabilitätSkill->removeStyle( Knopf::Style::Erlaubt );
     energieSkill->removeStyle( Knopf::Style::Erlaubt );
     reparaturSkill->removeStyle( Knopf::Style::Erlaubt );
@@ -81,10 +82,9 @@ SpielerGUI::SpielerGUI( Schrift * zSchrift )
     energieSchildSkill->removeStyle( Knopf::Style::Erlaubt );
     energieSchildEffizienzSkill->removeStyle( Knopf::Style::Erlaubt );
     netzwerkSkill->removeStyle( Knopf::Style::Erlaubt );
-    skillPoints = initTextFeld( 5, 355, 180, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    speed = initTextFeld( 5, 380, 180, 20, zSchrift, TextFeld::Style::Sichtbar | TextFeld::Style::VCenter, "" );
-    renderer = new TextRenderer( zSchrift->getThis() );
-    ref = 1;
+    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() ) );
 }
 
 // Destruktor
@@ -127,10 +127,10 @@ SpielerGUI::~SpielerGUI()
 }
 
 // nicht constant
-void SpielerGUI::update( Spieler * zSpieler )
+void SpielerGUI::update( Spieler *zSpieler )
 {
     if( !player )
-        player = (Spieler *)zSpieler->getThis();
+        player = dynamic_cast<Spieler *>( zSpieler->getThis() );
     spieler->setText( zSpieler->name->getText() );
     spieler->setSchriftFarbe( zSpieler->farbe );
     Text txt;
@@ -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 );
@@ -412,33 +412,21 @@ void SpielerGUI::render( Bild & zRObj )
         zRObj.fillRegion( 5, ram->getHeight() - 12, (int)( ( ram->getBreite() - 12 ) * ( player->getEp() / player->getMaxEp() ) ), 5, 0xFFFFFFFF );
     }
     zRObj.releaseDrawOptions();
-    int anz = player->activeSkills->getEintragAnzahl();
-    int x = zRObj.getBreite() - anz * 51 - 1 - 220;
-    int y = zRObj.getHeight() - 56;
-    int index = 0;
-    for( auto s = player->activeSkills->getIterator(); s; s++ )
+    if( player )
     {
-        s->render( x + 1, y + 1, zRObj );
-        zRObj.drawLinieH( x, y, 51, 0xFFFFFFFF );
-        zRObj.drawLinieH( x, y + 55, 51, 0xFFFFFFFF );
-        zRObj.drawLinieV( x, y, 56, 0xFFFFFFFF );
-        zRObj.drawLinieV( x + 51, y, 56, 0xFFFFFFFF );
-        renderer->renderText( x + 3, y + 3, Text( ++index ), zRObj, 0xFFFFFFFF );
-        x += 51;
+        int anz = player->activeSkills->getEintragAnzahl();
+        int x = zRObj.getBreite() - anz * 51 - 1 - 220;
+        int y = zRObj.getHeight() - 56;
+        int index = 0;
+        for( auto s = player->activeSkills->getIterator(); s; s++ )
+        {
+            s->render( x + 1, y + 1, zRObj );
+            zRObj.drawLinieH( x, y, 51, 0xFFFFFFFF );
+            zRObj.drawLinieH( x, y + 55, 51, 0xFFFFFFFF );
+            zRObj.drawLinieV( x, y, 56, 0xFFFFFFFF );
+            zRObj.drawLinieV( x + 51, y, 56, 0xFFFFFFFF );
+            renderer->renderText( x + 3, y + 3, Text( ++index ), zRObj, 0xFFFFFFFF );
+            x += 51;
+        }
     }
-}
-
-// Reference Counting
-SpielerGUI *SpielerGUI::getThis()
-{
-    ref++;
-    return this;
-}
-
-SpielerGUI *SpielerGUI::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Asteroids/Spiel/SpielerGUI/SpielerGUI.h

@@ -8,58 +8,54 @@
 
 using namespace Framework;
 
-class SpielerGUI
+class SpielerGUI : public virtual ReferenceCounter
 {
 private:
-	LRahmen *ram;
-	TextFeld *spieler;
-	TextFeld *stabilität;
-	TextFeld *energie;
-	FBalken *stabilitätB;
-	FBalken *energieB;
-	TextFeld *reparatur;
-	TextFeld *akkuLeistung;
-	TextFeld *wendigkeit;
-	TextFeld *beschleunigung;
+    LRahmen *ram;
+    TextFeld *spieler;
+    TextFeld *stabilität;
+    TextFeld *energie;
+    FBalken *stabilitätB;
+    FBalken *energieB;
+    TextFeld *reparatur;
+    TextFeld *akkuLeistung;
+    TextFeld *wendigkeit;
+    TextFeld *beschleunigung;
     TextFeld *antriebEffizienz;
-	TextFeld *laserIntensität;
-	TextFeld *laserEffizienz;
-	TextFeld *laserTempo;
+    TextFeld *laserIntensität;
+    TextFeld *laserEffizienz;
+    TextFeld *laserTempo;
     TextFeld *energieSchild;
     TextFeld *energieSchildEffizienz;
-	TextFeld *netzwerk;
+    TextFeld *netzwerk;
     TextFeld *speed;
-	Knopf *stabilitätSkill;
-	Knopf *energieSkill;
-	Knopf *reparaturSkill;
-	Knopf *akkuLeistungSkill;
-	Knopf *wendigkeitSkill;
+    Knopf *stabilitätSkill;
+    Knopf *energieSkill;
+    Knopf *reparaturSkill;
+    Knopf *akkuLeistungSkill;
+    Knopf *wendigkeitSkill;
     Knopf *antriebEffizienzSkill;
-	Knopf *beschleunigungSkill;
-	Knopf *laserIntensitätSkill;
-	Knopf *laserEffizienzSkill;
-	Knopf *laserTempoSkill;
+    Knopf *beschleunigungSkill;
+    Knopf *laserIntensitätSkill;
+    Knopf *laserEffizienzSkill;
+    Knopf *laserTempoSkill;
     Knopf *energieSchildSkill;
     Knopf *energieSchildEffizienzSkill;
-	Knopf *netzwerkSkill;
+    Knopf *netzwerkSkill;
     TextFeld *skillPoints;
     Spieler *player;
     TextRenderer *renderer;
-	int ref;
 
 public:
-	// Konstruktor
-	SpielerGUI( Schrift *zSchrift );
-	// Destruktor
-	~SpielerGUI();
-	// nicht constant
-	void update( Spieler *zSpieler );
-	int doPublicMausEreignis( MausEreignis &me );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// Reference Counting
-	SpielerGUI *getThis();
-	SpielerGUI *release();
+    // Konstruktor
+    SpielerGUI( UIInit &uiFactory );
+    // Destruktor
+    ~SpielerGUI();
+    // nicht constant
+    void update( Spieler *zSpieler );
+    int doPublicMausEreignis( MausEreignis &me );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
 };
 
 #endif

Asteroids/Spiel/Team/Team.cpp

@@ -4,48 +4,48 @@
 // Inhalt der Team Klasse aus Team.h
 // Konstruktor
 Team::Team( int f, char *n, TeamStr *zStr )
-{
-	id = zStr->id;
-	farbe = f;
-	name = n;
-	spieler = new RCArray< Spieler >();
-	punkte = zStr->punkte;
-	maxPunkte = zStr->maxPunkte;
-	maxEnergieS = zStr->maxEnergie;
-	maxStabilitätS = zStr->maxStabilität;
-	reparaturS = zStr->reparatur;
-	laserIntensitätS = zStr->laserIntensität;
-	laserEffizienzS = zStr->laserEffizienz;
-	akkuLeistungS = zStr->akkuLeistung;
-	laserTempoS = zStr->laserTempo;
-	beschleunigungS = zStr->beschleunigung;
-	wendigkeitS = zStr->wendigkeit;
+    : ReferenceCounter()
+{
+    id = zStr->id;
+    farbe = f;
+    name = n;
+    spieler = new RCArray< Spieler >();
+    punkte = zStr->punkte;
+    maxPunkte = zStr->maxPunkte;
+    maxEnergieS = zStr->maxEnergie;
+    maxStabilitätS = zStr->maxStabilität;
+    reparaturS = zStr->reparatur;
+    laserIntensitätS = zStr->laserIntensität;
+    laserEffizienzS = zStr->laserEffizienz;
+    akkuLeistungS = zStr->akkuLeistung;
+    laserTempoS = zStr->laserTempo;
+    beschleunigungS = zStr->beschleunigung;
+    wendigkeitS = zStr->wendigkeit;
     antriebEffizienzS = zStr->antriebEffizienz;
     energieSchildS = zStr->energieSchild;
     energieSchildEffizienzS = zStr->energieSchildEffizienz;
-	reset();
-	ref = 1;
+    reset();
 }
 
 // Destruktor
 Team::~Team()
 {
-	spieler->release();
+    spieler->release();
 }
 
 // nicht constant
 void Team::reset()
 {
-	spieler->leeren();
-	maxEnergie = maxEnergieS;
-	maxStabilität = maxStabilitätS;
-	reparatur = reparaturS;
-	laserIntensität = laserIntensitätS;
-	laserEffizienz = laserEffizienzS;
-	akkuLeistung = akkuLeistungS;
-	laserTempo = laserTempoS;
-	beschleunigung = beschleunigungS;
-	wendigkeit = wendigkeitS;
+    spieler->leeren();
+    maxEnergie = maxEnergieS;
+    maxStabilität = maxStabilitätS;
+    reparatur = reparaturS;
+    laserIntensität = laserIntensitätS;
+    laserEffizienz = laserEffizienzS;
+    akkuLeistung = akkuLeistungS;
+    laserTempo = laserTempoS;
+    beschleunigung = beschleunigungS;
+    wendigkeit = wendigkeitS;
     antriebEffizienz = antriebEffizienzS;
     energieSchild = energieSchildS;
     energieSchildEffizienz = energieSchildEffizienzS;
@@ -54,74 +54,74 @@ void Team::reset()
 // constant
 double Team::getMaxEnergieBonus() const
 {
-	double ret = maxEnergieS;
-	for( auto i = spieler->getIterator(); i && i; i++ )
-		ret += i->getTeamMaxEnergieBonus();
-	return ret;
+    double ret = maxEnergieS;
+    for( auto i = spieler->getIterator(); i && i; i++ )
+        ret += i->getTeamMaxEnergieBonus();
+    return ret;
 }
 
 double Team::getMaxStabilitätBonus() const
 {
-	double ret = maxStabilitätS;
-	for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamMaxStabilitätBonus();
-	return ret;
+    double ret = maxStabilitätS;
+    for( auto i = spieler->getIterator(); i; i++ )
+        ret += i->getTeamMaxStabilitätBonus();
+    return ret;
 }
 
 double Team::getReperaturBonus() const
 {
-	double ret = reparaturS;
-	for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamReparaturBonus();
-	return ret;
+    double ret = reparaturS;
+    for( auto i = spieler->getIterator(); i; i++ )
+        ret += i->getTeamReparaturBonus();
+    return ret;
 }
 
 double Team::getLaserIntensitätBonus() const
 {
-	double ret = laserIntensitätS;
+    double ret = laserIntensitätS;
     for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamLaserIntensitätBonus();
-	return ret;
+        ret += i->getTeamLaserIntensitätBonus();
+    return ret;
 }
 
 double Team::getLaserEffizienzBonus() const
 {
-	double ret = laserEffizienzS;
+    double ret = laserEffizienzS;
     for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamLaserEffizienzBonus();
-	return ret;
+        ret += i->getTeamLaserEffizienzBonus();
+    return ret;
 }
 
 double Team::getAkkuLeistungBonus() const
 {
-	double ret = akkuLeistungS;
+    double ret = akkuLeistungS;
     for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamAkkuLeistungBonus();
-	return ret;
+        ret += i->getTeamAkkuLeistungBonus();
+    return ret;
 }
 
 double Team::getLaserTempoBonus() const
 {
-	double ret = laserTempoS;
+    double ret = laserTempoS;
     for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamLaserTempoBonus();
-	return ret;
+        ret += i->getTeamLaserTempoBonus();
+    return ret;
 }
 
 double Team::getBeschleunigungBonus() const
 {
-	double ret = beschleunigungS;
+    double ret = beschleunigungS;
     for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamBeschleunigungBonus();
-	return ret;
+        ret += i->getTeamBeschleunigungBonus();
+    return ret;
 }
 
 double Team::getWendigkeitBonus() const
 {
-	double ret = wendigkeitS;
+    double ret = wendigkeitS;
     for( auto i = spieler->getIterator(); i; i++ )
-		ret += i->getTeamWendigkeitBonus();
-	return ret;
+        ret += i->getTeamWendigkeitBonus();
+    return ret;
 }
 
 double Team::getAntriebEffizienzBonus() const
@@ -146,19 +146,4 @@ double Team::getEnergieSchildEffizienzBonus() const
     for( auto i = spieler->getIterator(); i; i++ )
         ret += i->getTeamEnergieSchildEffizienzBonus();
     return ret;
-}
-
-// Reference Counting
-Team *Team::getThis()
-{
-	ref++;
-	return this;
-}
-
-Team *Team::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
 }

Asteroids/Spiel/Team/Team.h

@@ -8,65 +8,61 @@ class Spieler; // Spieler.h
 
 using namespace Framework;
 
-class Team
+class Team : public virtual ReferenceCounter
 {
 private:
-	double maxEnergieS;
-	double maxStabilitätS;
-	double reparaturS;
-	double laserIntensitätS;
-	double laserEffizienzS;
-	double akkuLeistungS;
-	double laserTempoS;
-	double beschleunigungS;
-	double wendigkeitS;
+    double maxEnergieS;
+    double maxStabilitätS;
+    double reparaturS;
+    double laserIntensitätS;
+    double laserEffizienzS;
+    double akkuLeistungS;
+    double laserTempoS;
+    double beschleunigungS;
+    double wendigkeitS;
     double antriebEffizienzS;
     double energieSchildS;
     double energieSchildEffizienzS;
-	int ref;
 
 public:
-	// variablen
-	int id;
-	int farbe;
-	Text name;
-	RCArray< Spieler > *spieler;
-	int punkte;
-	int maxPunkte;
-	double maxEnergie;
-	double maxStabilität;
-	double reparatur;
-	double laserIntensität;
-	double laserEffizienz;
-	double akkuLeistung;
-	double laserTempo;
-	double beschleunigung;
+    // variablen
+    int id;
+    int farbe;
+    Text name;
+    RCArray< Spieler > *spieler;
+    int punkte;
+    int maxPunkte;
+    double maxEnergie;
+    double maxStabilität;
+    double reparatur;
+    double laserIntensität;
+    double laserEffizienz;
+    double akkuLeistung;
+    double laserTempo;
+    double beschleunigung;
     double antriebEffizienz;
     double energieSchild;
     double energieSchildEffizienz;
-	double wendigkeit;
-	// Konstruktor
-	Team( int f, char *n, TeamStr *zStr );
-	// Destruktor
-	~Team();
-	// nicht constant
-	void reset();
-	// constant
-	double getMaxEnergieBonus() const;
-	double getMaxStabilitätBonus() const;
-	double getReperaturBonus() const;
-	double getLaserIntensitätBonus() const;
-	double getLaserEffizienzBonus() const;
-	double getAkkuLeistungBonus() const;
-	double getLaserTempoBonus() const;
-	double getBeschleunigungBonus() const;
+    double wendigkeit;
+    // Konstruktor
+    Team( int f, char *n, TeamStr *zStr );
+    // Destruktor
+    ~Team();
+    // nicht constant
+    void reset();
+    // constant
+    double getMaxEnergieBonus() const;
+    double getMaxStabilitätBonus() const;
+    double getReperaturBonus() const;
+    double getLaserIntensitätBonus() const;
+    double getLaserEffizienzBonus() const;
+    double getAkkuLeistungBonus() const;
+    double getLaserTempoBonus() const;
+    double getBeschleunigungBonus() const;
     double getAntriebEffizienzBonus() const;
     double getEnergieSchildBonus() const;
     double getEnergieSchildEffizienzBonus() const;
-	double getWendigkeitBonus() const;
-	// Reference Counting
-	Team *getThis();
-	Team *release();
+    double getWendigkeitBonus() const;
 };
 
 #endif

Asteroids/SpielStatistik/Chat/StatistikChat.cpp

@@ -10,473 +10,425 @@
 
 // Inhalt der ChatListeSpieler Klasse aus StatistikChat.h
 // Konstruktor
-ChatListeSpieler::ChatListeSpieler( int accountId, int eigeneId, Schrift *zSchrift, BilderV *bilder, KSGClient::InformationServerClient *zInfoc,
-									bool istFreund, void( *addChatF )( void*, int ), void( *addFreundF )( void*, int ),
-									void( *accountAnsehenF )( void *, int ), void *param )
-									: addChatF( addChatF ),
-									addFreundF( addFreundF ),
-									accountAnsehenF( accountAnsehenF ),
-									nachrichtParam( param ),
-									accountId( accountId ),
-									bg( new AlphaFeld() ),
-									name( initTextFeld( 0, 0, 133, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::VCenter, "" ) ),
-									accountAnsehen( initKnopf( 133, 0, 20, 20, 0, 0, "" ) ),
-									nachrichtSenden( initKnopf( 153, 0, 20, 20, 0, 0, "" ) ),
-									freundesanfrageSenden( initKnopf( 173, 0, 20, 20, 0, 0, "" ) ),
-									pos( 0, 0 ),
-									gr( 133, 20 ),
-									online( 1 ),
-									minKnopfX( 113 - ( ( ( accountId != eigeneId ) + !istFreund ) * 20 ) ),
-									knopfX( 133 ),
-									mausIn( 0 ),
-									tickVal( 0 ),
-									rend( 0 ),
-									ref( 1 )
+ChatListeSpieler::ChatListeSpieler( int accountId, int eigeneId, UIInit &uiFactory, BilderV *bilder, KSGClient::InformationServerClient *zInfoc,
+                                    bool istFreund, void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+                                    void( *accountAnsehenF )( void *, int ), void *param )
+    : ReferenceCounter(),
+    addChatF( addChatF ),
+    addFreundF( addFreundF ),
+    accountAnsehenF( accountAnsehenF ),
+    nachrichtParam( param ),
+    accountId( accountId ),
+    bg( new AlphaFeld() ),
+    name( initTextFeld( 0, 0, 133, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::VCenter, "" ) ),
+    accountAnsehen( initKnopf( 133, 0, 20, 20, uiFactory, 0, "" ) ),
+    nachrichtSenden( initKnopf( 153, 0, 20, 20, uiFactory, 0, "" ) ),
+    freundesanfrageSenden( initKnopf( 173, 0, 20, 20, uiFactory, 0, "" ) ),
+    pos( 0, 0 ),
+    gr( 133, 20 ),
+    online( 1 ),
+    minKnopfX( 113 - ( ( ( accountId != eigeneId ) + !istFreund ) * 20 ) ),
+    knopfX( 133 ),
+    mausIn( 0 ),
+    tickVal( 0 ),
+    rend( 0 )
 {
-	Bild *ansehenBild = bilder->get( "data/client/bilder/chat.ltdb/ansehen.png" );
-	Bild *nachrichtBild = bilder->get( "data/client/bilder/chat.ltdb/nachricht.png" );
-	Bild *einladungBild = bilder->get( "data/client/bilder/chat.ltdb/neuerfreund.png" );
-	bg->setSize( gr );
-	bg->setFarbe( 0x0000FF00 );
-	bg->setStrength( -4 );
-	name->setText( zInfoc->getSpielerName( accountId ) );
-	accountAnsehen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
-	accountAnsehen->setHintergrundBildZ( ansehenBild );
-	nachrichtSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
-	nachrichtSenden->setHintergrundBildZ( nachrichtBild );
-	freundesanfrageSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
-	freundesanfrageSenden->setHintergrundBildZ( einladungBild );
+    Bild *ansehenBild = bilder->get( "data/client/bilder/chat.ltdb/ansehen.png" );
+    Bild *nachrichtBild = bilder->get( "data/client/bilder/chat.ltdb/nachricht.png" );
+    Bild *einladungBild = bilder->get( "data/client/bilder/chat.ltdb/neuerfreund.png" );
+    bg->setSize( gr );
+    bg->setFarbe( 0x0000FF00 );
+    bg->setStrength( -4 );
+    name->setText( zInfoc->getSpielerName( accountId ) );
+    accountAnsehen->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+    accountAnsehen->setHintergrundBildZ( ansehenBild );
+    nachrichtSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+    nachrichtSenden->setHintergrundBildZ( nachrichtBild );
+    freundesanfrageSenden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+    freundesanfrageSenden->setHintergrundBildZ( einladungBild );
 }
 
 // Destruktor
 ChatListeSpieler::~ChatListeSpieler()
 {
-	bg->release();
-	name->release();
-	accountAnsehen->release();
-	nachrichtSenden->release();
-	freundesanfrageSenden->release();
+    bg->release();
+    name->release();
+    accountAnsehen->release();
+    nachrichtSenden->release();
+    freundesanfrageSenden->release();
 }
 
 // nicht constant
 void ChatListeSpieler::setOffline()
 {
-	online = 0;
+    online = 0;
 }
 
 void ChatListeSpieler::setPosition( int y )
 {
-	if( pos.y != y )
-		rend = 1;
-	pos.y = y;
+    if( pos.y != y )
+        rend = 1;
+    pos.y = y;
 }
 
 void ChatListeSpieler::doPublicMausEreignis( MausEreignis &me )
 {
-	int mx = me.mx;
-	int my = me.my;
-	me.mx -= pos.x;
-	me.my -= pos.y;
-	if( me.mx > 0 && me.mx < gr.x && me.my > 0 && me.my < gr.y )
-		mausIn = 1;
-	else
-		mausIn = 0;
-	me.mx += 133 - knopfX;
-	bool vera = me.verarbeitet;
-	accountAnsehen->doPublicMausEreignis( me );
-	int aktion = ( me.verarbeitet && !vera ) ? 1 : 0;
-	nachrichtSenden->doPublicMausEreignis( me );
-	aktion = ( me.verarbeitet && !vera && !aktion ) ? 2 : aktion;
-	freundesanfrageSenden->doPublicMausEreignis( me );
-	aktion = ( me.verarbeitet && !vera && !aktion ) ? 3 : aktion;
-	me.mx -= 133 - knopfX;
-	if( me.id == ME_RLinks && mausIn )
-	{
-		switch( aktion )
-		{
-		case 1:
-			accountAnsehenF( nachrichtParam, accountId );
-			break;
-		case 2:
-			addChatF( nachrichtParam, accountId );
-			break;
-		case 3:
-			addFreundF( nachrichtParam, accountId );
-			break;
-		}
-	}
-	me.mx = mx;
-	me.my = my;
+    int mx = me.mx;
+    int my = me.my;
+    me.mx -= pos.x;
+    me.my -= pos.y;
+    if( me.mx > 0 && me.mx < gr.x && me.my > 0 && me.my < gr.y )
+        mausIn = 1;
+    else
+        mausIn = 0;
+    me.mx += 133 - knopfX;
+    bool vera = me.verarbeitet;
+    accountAnsehen->doPublicMausEreignis( me );
+    int aktion = ( me.verarbeitet && !vera ) ? 1 : 0;
+    nachrichtSenden->doPublicMausEreignis( me );
+    aktion = ( me.verarbeitet && !vera && !aktion ) ? 2 : aktion;
+    freundesanfrageSenden->doPublicMausEreignis( me );
+    aktion = ( me.verarbeitet && !vera && !aktion ) ? 3 : aktion;
+    me.mx -= 133 - knopfX;
+    if( me.id == ME_RLinks && mausIn )
+    {
+        switch( aktion )
+        {
+        case 1:
+            accountAnsehenF( nachrichtParam, accountId );
+            break;
+        case 2:
+            addChatF( nachrichtParam, accountId );
+            break;
+        case 3:
+            addFreundF( nachrichtParam, accountId );
+            break;
+        }
+    }
+    me.mx = mx;
+    me.my = my;
 }
 
 bool ChatListeSpieler::tick( double tickVal )
 {
-	rend |= name->tick( tickVal );
-	rend |= accountAnsehen->tick( tickVal );
-	rend |= nachrichtSenden->tick( tickVal );
-	rend |= freundesanfrageSenden->tick( tickVal );
-	this->tickVal += tickVal * 60;
-	int val = ( int )this->tickVal;
-	if( val )
-	{
-		this->tickVal -= val;
-		if( mausIn && knopfX != minKnopfX )
-		{
-			if( knopfX - val < minKnopfX )
-				knopfX = minKnopfX;
-			else
-				knopfX -= val;
-			rend = 1;
-		}
-		if( !mausIn && knopfX != gr.x )
-		{
-			if( knopfX + val > gr.x )
-				knopfX = gr.x;
-			else
-				knopfX += val;
-			rend = 1;
-		}
-		if( !online && bg->getFarbe() != 0x00FF0000 )
-		{
-			int g = ( bg->getFarbe() >> 8 ) & 0xFF;
-			if( g - val < 0 )
-				bg->setFarbe( 0x00FF0000 );
-			else
-			{
-				bg->setFarbe( ( ( ( g - val ) << 8 ) & 0xFF00 ) | ( bg->getFarbe() & 0xFFFF00FF ) );
-				bg->setFarbe( ( ( ( 255 - ( g - val ) ) << 16 ) & 0xFF0000 ) | ( bg->getFarbe() & 0xFF00FFFF ) );
-			}
-			rend = 1;
-		}
-	}
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    rend |= name->tick( tickVal );
+    rend |= accountAnsehen->tick( tickVal );
+    rend |= nachrichtSenden->tick( tickVal );
+    rend |= freundesanfrageSenden->tick( tickVal );
+    this->tickVal += tickVal * 60;
+    int val = (int)this->tickVal;
+    if( val )
+    {
+        this->tickVal -= val;
+        if( mausIn && knopfX != minKnopfX )
+        {
+            if( knopfX - val < minKnopfX )
+                knopfX = minKnopfX;
+            else
+                knopfX -= val;
+            rend = 1;
+        }
+        if( !mausIn && knopfX != gr.x )
+        {
+            if( knopfX + val > gr.x )
+                knopfX = gr.x;
+            else
+                knopfX += val;
+            rend = 1;
+        }
+        if( !online && bg->getFarbe() != 0x00FF0000 )
+        {
+            int g = ( bg->getFarbe() >> 8 ) & 0xFF;
+            if( g - val < 0 )
+                bg->setFarbe( 0x00FF0000 );
+            else
+            {
+                bg->setFarbe( ( ( ( g - val ) << 8 ) & 0xFF00 ) | ( bg->getFarbe() & 0xFFFF00FF ) );
+                bg->setFarbe( ( ( ( 255 - ( g - val ) ) << 16 ) & 0xFF0000 ) | ( bg->getFarbe() & 0xFF00FFFF ) );
+            }
+            rend = 1;
+        }
+    }
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void ChatListeSpieler::render( Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( pos, gr ) )
-		return;
-	bg->render( zRObj );
-	name->render( zRObj );
-	zRObj.addScrollOffset( 133 - knopfX, 0 );
-	accountAnsehen->render( zRObj );
-	nachrichtSenden->render( zRObj );
-	freundesanfrageSenden->render( zRObj );
-	zRObj.releaseDrawOptions();
+    if( !zRObj.setDrawOptions( pos, gr ) )
+        return;
+    bg->render( zRObj );
+    name->render( zRObj );
+    zRObj.addScrollOffset( 133 - knopfX, 0 );
+    accountAnsehen->render( zRObj );
+    nachrichtSenden->render( zRObj );
+    freundesanfrageSenden->render( zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 // constant
 int ChatListeSpieler::getAccountId() const
 {
-	return accountId;
-}
-
-// Reference Counting
-ChatListeSpieler *ChatListeSpieler::getThis()
-{
-	ref++;
-	return this;
-}
-
-ChatListeSpieler *ChatListeSpieler::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return accountId;
 }
 
 
 // Inhalt der ChatListe Klasse aus StatistikChat.h
 // Konstruktor
-ChatListe::ChatListe( int eigeneId, KSGClient::InformationServerClient *infoc, Schrift *schrift, BilderV *bilder,
-					  void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
-					  void( *accountAnsehen )( void *, int ), void *param )
-					  : addChat( addChat ),
-					  addFreund( addFreund ),
-					  accountAnsehen( accountAnsehen ),
-					  nachrichtParam( nachrichtParam ),
-					  eigeneId( eigeneId ),
-					  spieler( new RCArray< ChatListeSpieler >() ),
-					  vScroll( new VScrollBar() ),
-					  pos( 620, 295 ),
-					  gr( 150, 150 ),
-					  infoc( infoc ),
-					  schrift( schrift ),
-					  bilder( bilder ),
-					  ram( new LRahmen() ),
-					  rend( 0 ),
-					  ref( 1 )
+ChatListe::ChatListe( int eigeneId, KSGClient::InformationServerClient *infoc, UIInit &uiFactory, BilderV *bilder,
+                      void( *addChat )( void *, int ), void( *addFreund )( void *, int ),
+                      void( *accountAnsehen )( void *, int ), void *param )
+    : ReferenceCounter(),
+    addChat( addChat ),
+    addFreund( addFreund ),
+    accountAnsehen( accountAnsehen ),
+    nachrichtParam( nachrichtParam ),
+    eigeneId( eigeneId ),
+    spieler( new RCArray< ChatListeSpieler >() ),
+    vScroll( new VScrollBar() ),
+    pos( 620, 295 ),
+    gr( 150, 150 ),
+    infoc( infoc ),
+    uiFactory( uiFactory ),
+    bilder( bilder ),
+    ram( new LRahmen() ),
+    rend( 0 )
 {
-	vScroll->setKlickScroll( 10 );
-	vScroll->update( 0, 148 );
-	ram->setFarbe( 0xFFFFFFFF );
-	ram->setSize( 150, 150 );
+    vScroll->setKlickScroll( 10 );
+    vScroll->update( 0, 148 );
+    ram->setFarbe( 0xFFFFFFFF );
+    ram->setSize( 150, 150 );
 }
 
 // Destruktor
 ChatListe::~ChatListe()
 {
-	spieler->release();
-	vScroll->release();
-	infoc->release();
-	schrift->release();
-	ram->release();
+    spieler->release();
+    vScroll->release();
+    infoc->release();
+    ram->release();
 }
 
 // nicht constant
 void ChatListe::addSpieler( int accountId, bool istFreund )
 {
-	int anz = spieler->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spieler->z( i ) && spieler->z( i )->getAccountId() == accountId )
-			return;
-	}
-	ChatListeSpieler *s = new ChatListeSpieler( accountId, eigeneId, schrift, bilder, infoc, istFreund, addChat, addFreund, accountAnsehen, nachrichtParam );
-	s->setPosition( anz * 20 );
-	spieler->add( s );
-	rend = 1;
+    int anz = spieler->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spieler->z( i ) && spieler->z( i )->getAccountId() == accountId )
+            return;
+    }
+    ChatListeSpieler *s = new ChatListeSpieler( accountId, eigeneId, uiFactory, bilder, infoc, istFreund, addChat, addFreund, accountAnsehen, nachrichtParam );
+    s->setPosition( anz * 20 );
+    spieler->add( s );
+    rend = 1;
 }
 
 void ChatListe::setOffline( int accountId )
 {
-	int anz = spieler->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spieler->z( i ) && spieler->z( i )->getAccountId() == accountId )
-		{
-			spieler->z( i )->setOffline();
-			return;
-		}
-	}
+    int anz = spieler->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spieler->z( i ) && spieler->z( i )->getAccountId() == accountId )
+        {
+            spieler->z( i )->setOffline();
+            return;
+        }
+    }
 }
 
 void ChatListe::doPublicMausEreignis( MausEreignis &me )
 {
-	int mx = me.mx;
-	int my = me.my;
-	me.mx -= pos.x;
-	me.my -= pos.y - vScroll->getScroll();
-	vScroll->doMausMessage( 134, 1, 15, 148, me );
-	int anz = spieler->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spieler->z( i ) )
-			spieler->z( i )->doPublicMausEreignis( me );
-	}
-	me.mx = mx;
-	me.my = my;
+    int mx = me.mx;
+    int my = me.my;
+    me.mx -= pos.x;
+    me.my -= pos.y - vScroll->getScroll();
+    vScroll->doMausMessage( 134, 1, 15, 148, me );
+    int anz = spieler->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spieler->z( i ) )
+            spieler->z( i )->doPublicMausEreignis( me );
+    }
+    me.mx = mx;
+    me.my = my;
 }
 
 bool ChatListe::tick( double tickVal )
 {
-	rend |= vScroll->getRend();
-	int anz = spieler->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spieler->z( i ) )
-			rend |= spieler->z( i )->tick( tickVal );
-	}
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    rend |= vScroll->getRend();
+    int anz = spieler->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spieler->z( i ) )
+            rend |= spieler->z( i )->tick( tickVal );
+    }
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void ChatListe::render( Bild &zRObj )
 {
-	if( !zRObj.setDrawOptions( pos, gr ) )
-		return;
-	int anz = spieler->getEintragAnzahl();
-	zRObj.addScrollOffset( 0, vScroll->getScroll() );
-	for( int i = 0; i < anz; i++ )
-	{
-		if( spieler->z( i ) )
-			spieler->z( i )->render( zRObj );
-	}
-	zRObj.addScrollOffset( 0, -vScroll->getScroll() );
-	vScroll->render( 134, 1, 15, 148, zRObj );
-	ram->render( zRObj );
-	zRObj.releaseDrawOptions();
-}
-
-// constant
-
-// Reference Counting
-ChatListe *ChatListe::getThis()
-{
-	ref++;
-	return this;
-}
-
-ChatListe *ChatListe::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    if( !zRObj.setDrawOptions( pos, gr ) )
+        return;
+    int anz = spieler->getEintragAnzahl();
+    zRObj.addScrollOffset( 0, vScroll->getScroll() );
+    for( int i = 0; i < anz; i++ )
+    {
+        if( spieler->z( i ) )
+            spieler->z( i )->render( zRObj );
+    }
+    zRObj.addScrollOffset( 0, -vScroll->getScroll() );
+    vScroll->render( 134, 1, 15, 148, zRObj );
+    ram->render( zRObj );
+    zRObj.releaseDrawOptions();
 }
 
 
 // Inhalt der StatistikChat Klasse aus StatistikChat.h
 // Konstruktor
-StatistikChat::StatistikChat( int eigeneId, KSGClient::SpielServerClient *spielc, KSGClient::InformationServerClient *infoc, Schrift *schrift, BilderV *bilder,
-							  void( *addNachricht )( void *, Text *, Text *, Text *, Text * ),
-							  void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
-							  void( *accountAnsehen )( void *, int ), void *param )
-							  : addNachricht( addNachricht ),
-							  nachrichtParam( nachrichtParam ),
-							  spielc( spielc ),
-							  infoc( infoc ),
-							  verlauf( initTextFeld( 10, 295, 600, 150, schrift, TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VScroll | TextFeld::Style::Mehrzeilig, "" ) ),
-							  nachricht( initTextFeld( 10, 450, 575, 20, schrift, TextFeld::Style::TextFeld, "" ) ),
-							  senden( initKnopf( 590, 450, 20, 20, 0, 0, "" ) ),
-							  verlassen( initKnopf( 630, 450, 130, 20, schrift, Knopf::Style::Sichtbar, "Verlassen" ) ),
-							  spielerListe( new ChatListe( eigeneId, infoc->getThis(), schrift, bilder, addChat, addFreund, accountAnsehen, nachrichtParam ) ),
-							  beenden( 0 ),
-							  ref( 1 )
+StatistikChat::StatistikChat( int eigeneId, KSGClient::SpielServerClient *spielc, KSGClient::InformationServerClient *infoc, UIInit &uiFactory, BilderV *bilder,
+                              void( *addNachricht )( void *, Text *, Text *, Text *, Text * ),
+                              void( *addChat )( void *, int ), void( *addFreund )( void *, int ),
+                              void( *accountAnsehen )( void *, int ), void *param )
+    : ReferenceCounter(),
+    addNachricht( addNachricht ),
+    nachrichtParam( nachrichtParam ),
+    spielc( spielc ),
+    infoc( infoc ),
+    verlauf( initTextFeld( 10, 295, 600, 150, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Rahmen | TextFeld::Style::VScroll | TextFeld::Style::Mehrzeilig, "" ) ),
+    nachricht( initTextFeld( 10, 450, 575, 20, uiFactory, TextFeld::Style::TextFeld, "" ) ),
+    senden( initKnopf( 590, 450, 20, 20, uiFactory, 0, "" ) ),
+    verlassen( initKnopf( 630, 450, 130, 20, uiFactory, Knopf::Style::Sichtbar, "Verlassen" ) ),
+    spielerListe( new ChatListe( eigeneId, infoc->getThis(), uiFactory, bilder, addChat, addFreund, accountAnsehen, nachrichtParam ) ),
+    beenden( 0 )
 {
-	Bild *sendenBild = bilder->get( "data/client/bilder/chat.ltdb/senden.png" );
-	senden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
-	senden->setHintergrundBildZ( sendenBild );
+    Bild *sendenBild = bilder->get( "data/client/bilder/chat.ltdb/senden.png" );
+    senden->setStyle( Knopf::Style::Sichtbar | Knopf::Style::Erlaubt | Knopf::Style::Hintergrund | Knopf::Style::HAlpha | Knopf::Style::HBild | Knopf::Style::KlickBuffer );
+    senden->setHintergrundBildZ( sendenBild );
 }
 
 // Destruktor
 StatistikChat::~StatistikChat()
 {
-	spielc->release();
-	infoc->release();
-	verlauf->release();
-	nachricht->release();
-	senden->release();
-	verlassen->release();
-	spielerListe->release();
+    spielc->release();
+    infoc->release();
+    verlauf->release();
+    nachricht->release();
+    senden->release();
+    verlassen->release();
+    spielerListe->release();
 }
 
 // nicht constant
 void StatistikChat::addSpieler( int accountId, bool istFreund )
 {
-	spielerListe->addSpieler( accountId, istFreund );
+    spielerListe->addSpieler( accountId, istFreund );
 }
 
 void StatistikChat::spielerOffline( int accountId )
 {
-	spielerListe->setOffline( accountId );
+    spielerListe->setOffline( accountId );
 }
 
 void StatistikChat::addChatNachricht( int vonAccount, char *nachricht )
 {
-	Text *txt = vonAccount ? infoc->getSpielerName( vonAccount ) : 0;
-	if( !txt )
-		txt = new Text();
-	else
-		*txt += ": ";
-	*txt += nachricht;
-	*txt += "\n";
-	verlauf->zTextRenderer()->textFormatieren( txt, verlauf->getBreite() - 15 );
-	verlauf->zText()->append( txt );
-	verlauf->updateVScroll();
+    Text *txt = vonAccount ? infoc->getSpielerName( vonAccount ) : 0;
+    if( !txt )
+        txt = new Text();
+    else
+        *txt += ": ";
+    *txt += nachricht;
+    *txt += "\n";
+    verlauf->zTextRenderer()->textFormatieren( txt, verlauf->getBreite() - 15 );
+    verlauf->zText()->append( txt );
+    verlauf->updateVScroll();
 }
 
 void StatistikChat::doPublicMausEreignis( MausEreignis &me )
 {
-	verlauf->doPublicMausEreignis( me );
-	nachricht->doPublicMausEreignis( me );
-	spielerListe->doPublicMausEreignis( me );
-	bool vera = me.verarbeitet;
-	senden->doPublicMausEreignis( me );
-	int aktion = ( me.verarbeitet && !vera ) ? 1 : 0;
-	verlassen->doPublicMausEreignis( me );
-	aktion = ( me.verarbeitet && !vera && !aktion ) ? 2 : aktion;
-	if( me.id == ME_RLinks )
-	{
-		if( aktion == 1 )
-		{
-			if( nachricht->zText()->getLength() )
-			{
-				short län = 1 + nachricht->zText()->getLength();
-				char *bytes = new char[ län ];
-				bytes[ 0 ] = 1;
-				for( int i = 0; i < län - 1; i++ )
-					bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
-				if( !spielc->statistikNachricht( län, bytes ) )
-					addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0 );
-				else
-				{
-					nachricht->setAuswahl( 0, 0 );
-					nachricht->setText( "" );
-				}
-				delete[] bytes;
-			}
-		}
-		if( aktion == 2 )
-			beenden = 1;
-	}
+    verlauf->doPublicMausEreignis( me );
+    nachricht->doPublicMausEreignis( me );
+    spielerListe->doPublicMausEreignis( me );
+    bool vera = me.verarbeitet;
+    senden->doPublicMausEreignis( me );
+    int aktion = ( me.verarbeitet && !vera ) ? 1 : 0;
+    verlassen->doPublicMausEreignis( me );
+    aktion = ( me.verarbeitet && !vera && !aktion ) ? 2 : aktion;
+    if( me.id == ME_RLinks )
+    {
+        if( aktion == 1 )
+        {
+            if( nachricht->zText()->getLength() )
+            {
+                short län = 1 + nachricht->zText()->getLength();
+                char *bytes = new char[ län ];
+                bytes[ 0 ] = 1;
+                for( int i = 0; i < län - 1; i++ )
+                    bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
+                if( !spielc->statistikNachricht( län, bytes ) )
+                    addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0 );
+                else
+                {
+                    nachricht->setAuswahl( 0, 0 );
+                    nachricht->setText( "" );
+                }
+                delete[] bytes;
+            }
+        }
+        if( aktion == 2 )
+            beenden = 1;
+    }
 }
 
 void StatistikChat::doTastaturEreignis( TastaturEreignis &te )
 {
-	bool vera = te.verarbeitet;
-	nachricht->doTastaturEreignis( te );
-	if( !vera && te.verarbeitet && te.id == TE_Release && te.taste == T_Enter )
-	{
-		if( nachricht->zText()->getLength() )
-		{
-			short län = 1 + nachricht->zText()->getLength();
-			char *bytes = new char[ län ];
-			bytes[ 0 ] = 1;
-			for( int i = 0; i < län - 1; i++ )
-				bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
-			if( !spielc->statistikNachricht( län, bytes ) )
-				addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0 );
-			else
-			{
-				nachricht->setAuswahl( 0, 0 );
-				nachricht->setText( "" );
-			}
-			delete[] bytes;
-		}
-	}
+    bool vera = te.verarbeitet;
+    nachricht->doTastaturEreignis( te );
+    if( !vera && te.verarbeitet && te.id == TE_Release && te.taste == T_Enter )
+    {
+        if( nachricht->zText()->getLength() )
+        {
+            short län = 1 + nachricht->zText()->getLength();
+            char *bytes = new char[ län ];
+            bytes[ 0 ] = 1;
+            for( int i = 0; i < län - 1; i++ )
+                bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
+            if( !spielc->statistikNachricht( län, bytes ) )
+                addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0 );
+            else
+            {
+                nachricht->setAuswahl( 0, 0 );
+                nachricht->setText( "" );
+            }
+            delete[] bytes;
+        }
+    }
 }
 
 bool StatistikChat::tick( double tickVal )
 {
-	bool rend = verlauf->tick( tickVal );
-	rend |= nachricht->tick( tickVal );
-	rend |= senden->tick( tickVal );
-	rend |= verlassen->tick( tickVal );
-	rend |= spielerListe->tick( tickVal );
-	return rend;
+    bool rend = verlauf->tick( tickVal );
+    rend |= nachricht->tick( tickVal );
+    rend |= senden->tick( tickVal );
+    rend |= verlassen->tick( tickVal );
+    rend |= spielerListe->tick( tickVal );
+    return rend;
 }
 
 void StatistikChat::render( Bild &zRObj )
 {
-	verlauf->render( zRObj );
-	nachricht->render( zRObj );
-	senden->render( zRObj );
-	verlassen->render( zRObj );
-	spielerListe->render( zRObj );
+    verlauf->render( zRObj );
+    nachricht->render( zRObj );
+    senden->render( zRObj );
+    verlassen->render( zRObj );
+    spielerListe->render( zRObj );
 }
 
 // constant
 bool StatistikChat::hatVerlassen()
 {
-	return beenden;
-}
-
-// Reference Counting
-StatistikChat *StatistikChat::getThis()
-{
-	ref++;
-	return this;
-}
-
-StatistikChat *StatistikChat::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return beenden;
 }

Asteroids/SpielStatistik/Chat/StatistikChat.h

@@ -6,127 +6,114 @@
 #include <KSGNetwork.h>
 #include <BilderV.h>
 #include <Rahmen.h>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
-class ChatListeSpieler
+class ChatListeSpieler : public virtual ReferenceCounter
 {
 private:
-	void( *addChatF )( void *, int );
-	void( *addFreundF )( void *, int );
-	void( *accountAnsehenF )( void *, int );
-	void *nachrichtParam;
-	int accountId;
-	AlphaFeld *bg;
-	TextFeld *name;
-	Knopf *accountAnsehen;
-	Knopf *nachrichtSenden;
-	Knopf *freundesanfrageSenden;
-	Punkt pos;
-	Punkt gr;
-	bool online;
-	int minKnopfX;
-	int knopfX;
-	bool mausIn;
-	double tickVal;
-	bool rend;
-	int ref;
+    void( *addChatF )( void *, int );
+    void( *addFreundF )( void *, int );
+    void( *accountAnsehenF )( void *, int );
+    void *nachrichtParam;
+    int accountId;
+    AlphaFeld *bg;
+    TextFeld *name;
+    Knopf *accountAnsehen;
+    Knopf *nachrichtSenden;
+    Knopf *freundesanfrageSenden;
+    Punkt pos;
+    Punkt gr;
+    bool online;
+    int minKnopfX;
+    int knopfX;
+    bool mausIn;
+    double tickVal;
+    bool rend;
 
 public:
-	// Konstruktor
-	ChatListeSpieler( int accountId, int eigeneId, Schrift *zSchrift, BilderV *bilder, KSGClient::InformationServerClient *zInfoc,
-											  bool istFreund, void( *addChatF )( void*, int ), void( *addFreundF )( void*, int ),
-											  void( *accountAnsehenF )( void *, int ), void *param );
-	// Destruktor
-	~ChatListeSpieler();
-	// nicht constant
-	void setOffline();
-	void setPosition( int y );
-	void doPublicMausEreignis( MausEreignis &me );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-	int getAccountId() const;
-	// Reference Counting
-	ChatListeSpieler *getThis();
-	ChatListeSpieler *release();
+    // Konstruktor
+    ChatListeSpieler( int accountId, int eigeneId, UIInit &uiFactory, BilderV *bilder, KSGClient::InformationServerClient *zInfoc,
+                      bool istFreund, void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+                      void( *accountAnsehenF )( void *, int ), void *param );
+    // Destruktor
+    ~ChatListeSpieler();
+    // nicht constant
+    void setOffline();
+    void setPosition( int y );
+    void doPublicMausEreignis( MausEreignis &me );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    // constant
+    int getAccountId() const;
 };
 
-class ChatListe
+class ChatListe : public virtual ReferenceCounter
 {
 private:
-	void( *addChat )( void *, int );
-	void( *addFreund )( void *, int );
-	void( *accountAnsehen )( void *, int );
-	void *nachrichtParam;
-	int eigeneId;
-	RCArray< ChatListeSpieler > *spieler;
-	VScrollBar *vScroll;
-	Punkt pos;
-	Punkt gr;
+    void( *addChat )( void *, int );
+    void( *addFreund )( void *, int );
+    void( *accountAnsehen )( void *, int );
+    void *nachrichtParam;
+    int eigeneId;
+    RCArray< ChatListeSpieler > *spieler;
+    VScrollBar *vScroll;
+    Punkt pos;
+    Punkt gr;
     KSGClient::InformationServerClient *infoc;
-	Schrift *schrift;
-	BilderV *bilder;
-	LRahmen *ram;
-	bool rend;
-	int ref;
+    UIInit uiFactory;
+    BilderV *bilder;
+    LRahmen *ram;
+    bool rend;
 
 public:
-	// Konstruktor
-	ChatListe( int eigeneId, KSGClient::InformationServerClient *infoc, Schrift *schrift, BilderV *bilder,
-									   void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
-									   void( *accountAnsehen )( void *, int ), void *param );
-	// Destruktor
-	~ChatListe();
-	// nicht constant
-	void addSpieler( int accountId, bool istFreund );
-	void setOffline( int accountId );
-	void doPublicMausEreignis( MausEreignis &me );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-
-	// Reference Counting
-	ChatListe *getThis();
-	ChatListe *release();
+    // Konstruktor
+    ChatListe( int eigeneId, KSGClient::InformationServerClient *infoc, UIInit &uiFactory, BilderV *bilder,
+               void( *addChat )( void *, int ), void( *addFreund )( void *, int ),
+               void( *accountAnsehen )( void *, int ), void *param );
+    // Destruktor
+    ~ChatListe();
+    // nicht constant
+    void addSpieler( int accountId, bool istFreund );
+    void setOffline( int accountId );
+    void doPublicMausEreignis( MausEreignis &me );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
 };
 
-class StatistikChat
+class StatistikChat : public virtual ReferenceCounter
 {
 private:
-	void( *addNachricht )( void *, Text *, Text *, Text *, Text * );
-	void *nachrichtParam;
+    void( *addNachricht )( void *, Text *, Text *, Text *, Text * );
+    void *nachrichtParam;
     KSGClient::SpielServerClient *spielc;
     KSGClient::InformationServerClient *infoc;
-	TextFeld *verlauf;
-	TextFeld *nachricht;
-	Knopf *senden;
-	Knopf *verlassen;
-	ChatListe *spielerListe;
-	bool beenden;
-	int ref;
+    TextFeld *verlauf;
+    TextFeld *nachricht;
+    Knopf *senden;
+    Knopf *verlassen;
+    ChatListe *spielerListe;
+    bool beenden;
 
 public:
-	// Konstruktor
-	StatistikChat( int eigeneId, KSGClient::SpielServerClient *spielc, KSGClient::InformationServerClient *infoc, Schrift *schrift, BilderV *bilder,
-										   void( *addNachricht )( void *, Text *, Text *, Text *, Text * ),
-										   void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
-										   void( *accountAnsehen )( void *, int ), void *param );
-	// Destruktor
-	~StatistikChat();
-	// nicht constant
-	void addSpieler( int accountId, bool istFreund );
-	void spielerOffline( int accountId );
-	void addChatNachricht( int vonAccount, char *nachricht );
-	void doPublicMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-	bool hatVerlassen();
-	// Reference Counting
-	StatistikChat *getThis();
-	StatistikChat *release();
+    // Konstruktor
+    StatistikChat( int eigeneId, KSGClient::SpielServerClient *spielc, KSGClient::InformationServerClient *infoc, UIInit &uiFactory, BilderV *bilder,
+                   void( *addNachricht )( void *, Text *, Text *, Text *, Text * ),
+                   void( *addChat )( void *, int ), void( *addFreund )( void *, int ),
+                   void( *accountAnsehen )( void *, int ), void *param );
+    // Destruktor
+    ~StatistikChat();
+    // nicht constant
+    void addSpieler( int accountId, bool istFreund );
+    void spielerOffline( int accountId );
+    void addChatNachricht( int vonAccount, char *nachricht );
+    void doPublicMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    // constant
+    bool hatVerlassen();
 };
 
 #endif

Asteroids/SpielStatistik/SpielStatistik.cpp

@@ -6,379 +6,353 @@
 // Inhalt der SpielStatistik Klasse aus SpielStatistik.h
 // Konstruktor
 SpielStatistik::SpielStatistik()
+    : ReferenceCounter()
 {
-	InitializeCriticalSection( &cs );
-	addNachrichtF = 0;
-	addChatF = 0;
-	addFreundF = 0;
-	accountAnsehenF = 0;
-	istFreundF = 0;
-	nachrichtParam = 0;
-	bilder = 0;
-	schrift = 0;
-	screen = 0;
-	infoc = 0;
-	spielc = 0;
-	status = 0;
-	gss = new Array< SSDSpieler* >();
-	gts = new Array< SSDTeam* >();
-	chat = 0;
-	tabelle = 0;
-	accountId = 0;
-	rend = 0;
-	ref = 1;
+    InitializeCriticalSection( &cs );
+    addNachrichtF = 0;
+    addChatF = 0;
+    addFreundF = 0;
+    accountAnsehenF = 0;
+    istFreundF = 0;
+    nachrichtParam = 0;
+    bilder = 0;
+    infoc = 0;
+    spielc = 0;
+    status = 0;
+    gss = new Array< SSDSpieler * >();
+    gts = new Array< SSDTeam * >();
+    chat = 0;
+    tabelle = 0;
+    accountId = 0;
+    rend = 0;
 }
 
 // Destruktor
 SpielStatistik::~SpielStatistik()
 {
-	if( chat )
-		chat->release();
-	if( tabelle )
-		tabelle->release();
-	if( schrift )
-		schrift->release();
-	if( infoc )
-		infoc->release();
-	if( spielc )
-		spielc->release();
-	int anz = gss->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( gss->hat( i ) )
-			delete gss->get( i );
-	}
-	gss->release();
-	anz = gts->getEintragAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		if( gts->hat( i ) )
-			delete gts->get( i );
-	}
-	gts->release();
-	DeleteCriticalSection( &cs );
+    if( chat )
+        chat->release();
+    if( tabelle )
+        tabelle->release();
+    if( infoc )
+        infoc->release();
+    if( spielc )
+        spielc->release();
+    int anz = gss->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( gss->hat( i ) )
+            delete gss->get( i );
+    }
+    gss->release();
+    anz = gts->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        if( gts->hat( i ) )
+            delete gts->get( i );
+    }
+    gts->release();
+    DeleteCriticalSection( &cs );
 }
 
 // nicht constant
 void SpielStatistik::lock()
 {
-	EnterCriticalSection( &cs );
+    EnterCriticalSection( &cs );
 }
 
 void SpielStatistik::unlock()
 {
-	LeaveCriticalSection( &cs );
+    LeaveCriticalSection( &cs );
 }
 
 void SpielStatistik::bereit()
 {
-	char byte = 0;
-	spielc->statistikNachricht( 1, &byte );
+    char byte = 0;
+    spielc->statistikNachricht( 1, &byte );
 }
 
 void SpielStatistik::setBilder( BilderV *b )
 {
-	bilder = b;
+    bilder = b;
 }
 
 void SpielStatistik::setAccountId( int id )
 {
-	accountId = id;
+    accountId = id;
 }
 
 void SpielStatistik::setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * ),
-										   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
-										   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam )
+                                           void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+                                           void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam )
 {
-	this->addNachrichtF = addNachrichtF;
-	this->addChatF = addChatF;
-	this->addFreundF = addFreundF;
-	this->accountAnsehenF = accountAnsehenF;
-	this->istFreundF = istFreundF;
-	this->nachrichtParam = nachrichtParam;
+    this->addNachrichtF = addNachrichtF;
+    this->addChatF = addChatF;
+    this->addFreundF = addFreundF;
+    this->accountAnsehenF = accountAnsehenF;
+    this->istFreundF = istFreundF;
+    this->nachrichtParam = nachrichtParam;
 }
 
-void SpielStatistik::setSchrift( Schrift *schrift )
+void SpielStatistik::setUIFactory( UIInit &uiFactory )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
-}
-
-void SpielStatistik::setBildschirm( Bildschirm *zScreen )
-{
-	screen = zScreen;
+    this->uiFactory = uiFactory;
 }
 
 void SpielStatistik::setKlients( KSGClient::InformationServerClient *infoc, KSGClient::SpielServerClient *spielc )
 {
-	if( this->infoc )
-		this->infoc->release();
-	if( this->spielc )
-		this->spielc->release();
-	this->infoc = infoc;
-	this->spielc = spielc;
+    if( this->infoc )
+        this->infoc->release();
+    if( this->spielc )
+        this->spielc->release();
+    this->infoc = infoc;
+    this->spielc = spielc;
 }
 
 void SpielStatistik::nachricht( int län, char *bytes )
 {
-	lock();
-	char num = *bytes;
-	bytes++;
-	län--;
-	switch( num )
-	{
-	case 0: // Spieler Statistik
-		if( 1 )
-		{
-			SSDSpieler *ssdgs = new SSDSpieler();
-			ssdgs->spielerNummer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			char snlän = *bytes;
-			län--;
-			bytes++;
-			char *txt = new char[ snlän + 1 ];
-			txt[ snlän ] = 0;
-			for( int i = 0; i < snlän; i++ )
-				txt[ i ] = bytes[ i ];
-			bytes += snlän;
-			län -= snlän;
-			ssdgs->spielerName = txt;
-			delete[] txt;
-			char tnlän = *bytes;
-			län--;
-			bytes++;
-			txt = new char[ tnlän + 1 ];
-			txt[ tnlän ] = 0;
-			for( int i = 0; i < tnlän; i++ )
-				txt[ i ] = bytes[ i ];
-			bytes += tnlän;
-			län -= tnlän;
-			ssdgs->teamName = txt;
-			delete[] txt;
-			ssdgs->spielerFarbe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->teamFarbe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->schadenBekommen = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->schadenGemacht = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->treibstoffVerbraucht = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->schüsse = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->treffer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->punkte = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->kills = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->tode = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->zeitAmLeben = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgs->zeitTod = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			gss->add( ssdgs );
-		}
-		break;
-	case 1: // Team Statistik
-		if( 1 )
-		{
-			SSDTeam *ssdgt = new SSDTeam();
-			ssdgt->teamNummer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			char tnlän = *bytes;
-			län--;
-			bytes++;
-			char *txt = new char[ tnlän + 1 ];
-			txt[ tnlän ] = 0;
-			for( int i = 0; i < tnlän; i++ )
-				txt[ i ] = bytes[ i ];
-			bytes += tnlän;
-			län -= tnlän;
-			ssdgt->teamName = txt;
-			delete[] txt;
-			ssdgt->teamFarbe = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->schadenBekommen = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->schadenGemacht = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->treibstoffVerbraucht = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->schüsse = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->treffer = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->punkte = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->kills = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->tode = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			ssdgt->gewonnen = *bytes != 0;
-			bytes++;
-			län--;
-			gts->add( ssdgt );
-		}
-		break;
-	case 2: // Ladevorgang abgeschlossen
-		if( 1 )
-		{
-			chat = new StatistikChat( accountId, spielc->getThis(), infoc->getThis(), schrift->getThis(), bilder, addNachrichtF, addChatF, addFreundF, accountAnsehenF, nachrichtParam );
-			int anz = gss->getEintragAnzahl();
-			for( int i = 0; i < anz; i++ )
-			{
-				if( gss->hat( i ) )
-				{
-					int acc = infoc->getAccountId( gss->get( i )->spielerName );
-					if( acc )
-						chat->addSpieler( acc, istFreundF( nachrichtParam, acc ) || acc == accountId );
-				}
-			}
-			tabelle = new StatistikTabelle( gss->getThis(), gts->getThis(), schrift, screen );
-			status = 1;
-		}
-		break;
-	case 3: // Chat Nachricht
-		if( 1 )
-		{
-			int vonAccount = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			char *txt = new char[ län + 1 ];
-			txt[ län ] = 0;
-			for( int i = 0; i < län; i++ )
-				txt[ i ] = bytes[ i ];
-			if( status == 1 )
-				chat->addChatNachricht( vonAccount, txt );
-			delete[] txt;
-		}
-		break;
-	case 4: // Spieler hat verlassen
-		if( 1 )
-		{
-			int acc = *(int*)bytes;
-			bytes += 4;
-			län -= 4;
-			if( status == 1 )
-				chat->spielerOffline( acc );
-		}
-		break;
-	default:
-		// Fehler
-		break;
-	}
-	if( län != 0 )
-	{
-		// Fehler
-	}
-	unlock();
+    lock();
+    char num = *bytes;
+    bytes++;
+    län--;
+    switch( num )
+    {
+    case 0: // Spieler Statistik
+        if( 1 )
+        {
+            SSDSpieler *ssdgs = new SSDSpieler();
+            ssdgs->spielerNummer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            char snlän = *bytes;
+            län--;
+            bytes++;
+            char *txt = new char[ snlän + 1 ];
+            txt[ snlän ] = 0;
+            for( int i = 0; i < snlän; i++ )
+                txt[ i ] = bytes[ i ];
+            bytes += snlän;
+            län -= snlän;
+            ssdgs->spielerName = txt;
+            delete[] txt;
+            char tnlän = *bytes;
+            län--;
+            bytes++;
+            txt = new char[ tnlän + 1 ];
+            txt[ tnlän ] = 0;
+            for( int i = 0; i < tnlän; i++ )
+                txt[ i ] = bytes[ i ];
+            bytes += tnlän;
+            län -= tnlän;
+            ssdgs->teamName = txt;
+            delete[] txt;
+            ssdgs->spielerFarbe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->teamFarbe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->schadenBekommen = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->schadenGemacht = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->treibstoffVerbraucht = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->schüsse = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->treffer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->punkte = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->kills = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->tode = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->zeitAmLeben = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgs->zeitTod = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            gss->add( ssdgs );
+        }
+        break;
+    case 1: // Team Statistik
+        if( 1 )
+        {
+            SSDTeam *ssdgt = new SSDTeam();
+            ssdgt->teamNummer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            char tnlän = *bytes;
+            län--;
+            bytes++;
+            char *txt = new char[ tnlän + 1 ];
+            txt[ tnlän ] = 0;
+            for( int i = 0; i < tnlän; i++ )
+                txt[ i ] = bytes[ i ];
+            bytes += tnlän;
+            län -= tnlän;
+            ssdgt->teamName = txt;
+            delete[] txt;
+            ssdgt->teamFarbe = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->schadenBekommen = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->schadenGemacht = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->treibstoffVerbraucht = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->schüsse = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->treffer = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->punkte = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->kills = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->tode = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            ssdgt->gewonnen = *bytes != 0;
+            bytes++;
+            län--;
+            gts->add( ssdgt );
+        }
+        break;
+    case 2: // Ladevorgang abgeschlossen
+        if( 1 )
+        {
+            chat = new StatistikChat( accountId, spielc->getThis(), infoc->getThis(), uiFactory, bilder, addNachrichtF, addChatF, addFreundF, accountAnsehenF, nachrichtParam );
+            int anz = gss->getEintragAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                if( gss->hat( i ) )
+                {
+                    int acc = infoc->getAccountId( gss->get( i )->spielerName );
+                    if( acc )
+                        chat->addSpieler( acc, istFreundF( nachrichtParam, acc ) || acc == accountId );
+                }
+            }
+            tabelle = new StatistikTabelle( dynamic_cast<Array<SSDSpieler *> *>( gss->getThis() ), dynamic_cast<Array<SSDTeam *> *>( gts->getThis() ), uiFactory );
+            status = 1;
+        }
+        break;
+    case 3: // Chat Nachricht
+        if( 1 )
+        {
+            int vonAccount = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            char *txt = new char[ län + 1 ];
+            txt[ län ] = 0;
+            for( int i = 0; i < län; i++ )
+                txt[ i ] = bytes[ i ];
+            if( status == 1 )
+                chat->addChatNachricht( vonAccount, txt );
+            delete[] txt;
+        }
+        break;
+    case 4: // Spieler hat verlassen
+        if( 1 )
+        {
+            int acc = *(int *)bytes;
+            bytes += 4;
+            län -= 4;
+            if( status == 1 )
+                chat->spielerOffline( acc );
+        }
+        break;
+    default:
+        // Fehler
+        break;
+    }
+    if( län != 0 )
+    {
+        // Fehler
+    }
+    unlock();
 }
 
 void SpielStatistik::doPublicMausEreignis( MausEreignis &me )
 {
-	if( !status )
-		return;
-	lock();
-	if( status == 1 )
-	{
-		tabelle->doPublicMausEreignis( me );
-		chat->doPublicMausEreignis( me );
-	}
-	unlock();
+    if( !status )
+        return;
+    lock();
+    if( status == 1 )
+    {
+        tabelle->doPublicMausEreignis( me );
+        chat->doPublicMausEreignis( me );
+    }
+    unlock();
 }
 
 void SpielStatistik::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( !status )
-		return;
-	lock();
-	if( status == 1 )
-		chat->doTastaturEreignis( te );
-	unlock();
+    if( !status )
+        return;
+    lock();
+    if( status == 1 )
+        chat->doTastaturEreignis( te );
+    unlock();
 }
 
 bool SpielStatistik::tick( double zeit )
 {
-	if( !status )
-		return 0;
-	lock();
-	if( status == 1 )
-	{
-		rend |= chat->tick( zeit );
-		rend |= tabelle->tick( zeit );
-		if( chat->hatVerlassen() && status == 1 )
-		{
-			spielc->trenne();
-			status = 2;
-		}
-	}
-	bool ret = rend;
-	rend = 0;
-	unlock();
-	return ret;
+    if( !status )
+        return 0;
+    lock();
+    if( status == 1 )
+    {
+        rend |= chat->tick( zeit );
+        rend |= tabelle->tick( zeit );
+        if( chat->hatVerlassen() && status == 1 )
+        {
+            spielc->trenne();
+            status = 2;
+        }
+    }
+    bool ret = rend;
+    rend = 0;
+    unlock();
+    return ret;
 }
 
 void SpielStatistik::render( Bild &zRObj )
 {
-	if( !status )
-		return;
-	lock();
-	chat->render( zRObj );
-	tabelle->render( zRObj );
-	unlock();
+    if( !status )
+        return;
+    lock();
+    chat->render( zRObj );
+    tabelle->render( zRObj );
+    unlock();
 }
 
 void SpielStatistik::verlassen()
 {
-	if( spielc )
-		spielc->trenne();
-	status = 2;
+    if( spielc )
+        spielc->trenne();
+    status = 2;
 }
 
 // constant
 int SpielStatistik::getStatus() const // 0 = laden, 1 = läuft, 2 = fortsetzen
 {
-	return status;
-}
-
-// Reference Counting
-SpielStatistikV *SpielStatistik::getThis()
-{
-	ref++;
-	return this;
-}
-
-SpielStatistikV *SpielStatistik::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return status;
 }

Asteroids/SpielStatistik/SpielStatistik.h

@@ -9,55 +9,49 @@
 class SpielStatistik : public SpielStatistikV
 {
 private:
-	void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * );
-	void( *addChatF )( void *, int );
-	void( *addFreundF )( void *, int );
-	void( *accountAnsehenF )( void *, int );
-	bool( *istFreundF )( void *, int );
-	void *nachrichtParam;
-	BilderV *bilder;
-	Schrift *schrift;
-	Bildschirm *screen;
+    void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * );
+    void( *addChatF )( void *, int );
+    void( *addFreundF )( void *, int );
+    void( *accountAnsehenF )( void *, int );
+    bool( *istFreundF )( void *, int );
+    void *nachrichtParam;
+    BilderV *bilder;
+    UIInit uiFactory;
     KSGClient::InformationServerClient *infoc;
     KSGClient::SpielServerClient *spielc;
-	CRITICAL_SECTION cs;
-	Array< SSDSpieler* > *gss;
-	Array< SSDTeam* > *gts;
-	StatistikChat *chat;
-	StatistikTabelle *tabelle;
-	int accountId;
-	bool rend;
-	int status;
-	int ref;
+    CRITICAL_SECTION cs;
+    Array< SSDSpieler * > *gss;
+    Array< SSDTeam * > *gts;
+    StatistikChat *chat;
+    StatistikTabelle *tabelle;
+    int accountId;
+    bool rend;
+    int status;
 
 public:
-	// Konstruktor
-	SpielStatistik();
-	// Destruktor
-	~SpielStatistik();
-	// nicht constant
-	void lock();
-	void unlock();
-	virtual void bereit();
-	virtual void setBilder( BilderV *b );
-	virtual void setAccountId( int id );
-	virtual void setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * ),
-															   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
-															   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam );
-	virtual void setSchrift( Schrift *schrift );
-	virtual void setBildschirm( Bildschirm *zScreen );
-	virtual void setKlients( KSGClient::InformationServerClient *infoc, KSGClient::SpielServerClient *spielc );
-	virtual void nachricht( int län, char *bytes );
-	virtual void doPublicMausEreignis( MausEreignis &me );
-	virtual void doTastaturEreignis( TastaturEreignis &te );
-	virtual bool tick( double zeit );
-	virtual void render( Bild &zRObj );
-	virtual void verlassen();
-	// constant
-	virtual int getStatus() const; // 0 = laden, 1 = läuft, 2 = fortsetzen
-	// Reference Counting
-	virtual SpielStatistikV *getThis();
-	virtual SpielStatistikV *release();
+    // Konstruktor
+    SpielStatistik();
+    // Destruktor
+    ~SpielStatistik();
+    // nicht constant
+    void lock();
+    void unlock();
+    virtual void bereit();
+    virtual void setBilder( BilderV *b );
+    virtual void setAccountId( int id );
+    virtual void setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * ),
+                                       void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
+                                       void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam );
+    virtual void setUIFactory( UIInit &factory );
+    virtual void setKlients( KSGClient::InformationServerClient *infoc, KSGClient::SpielServerClient *spielc );
+    virtual void nachricht( int län, char *bytes );
+    virtual void doPublicMausEreignis( MausEreignis &me );
+    virtual void doTastaturEreignis( TastaturEreignis &te );
+    virtual bool tick( double zeit );
+    virtual void render( Bild &zRObj );
+    virtual void verlassen();
+    // constant
+    virtual int getStatus() const; // 0 = laden, 1 = läuft, 2 = fortsetzen
 };
 
 #endif

Asteroids/SpielStatistik/Tabelle/StatistikTabelle.cpp

@@ -6,417 +6,401 @@
 
 // Inhalt der StatistikTabelle Klasse aus StatistikTabelle.h
 // Konstruktor
-StatistikTabelle::StatistikTabelle( Array< SSDSpieler* > *ssdgs, Array< SSDTeam* > *ssdgt,
-									Schrift *zSchrift, Bildschirm *zScreen, bool historie )
-									: schrift( zSchrift->getThis() ),
-									ssdgs( ssdgs ),
-									ssdgt( ssdgt ),
-									stAuswahl( initAuswahlBox( 10, 10, 120, 20, zSchrift, ABSTYLE, { "Spieler", "Teams" } ) ),
-									sortAuswahlGS( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Spielername", "Teamname",
-									"Spielerfarbe", "Teamfarbe", "Schaden bekommen", "Schaden gemacht", "Treibstoff verbraucht",
-									"Präzision", "Punkte", "Kills", "Tode", "Zeit am Leben", "Zeit tod" } ) ),
-									sortAuswahlGT( initAuswahlBox( 270, 10, 120, 20, zSchrift, ABSTYLE, { "Teamname", "Teamfarbe",
-									"Schaden bekommen", "Schaden gemacht", "Treibstoff verbraucht", "Präzision", "Punkte", "Kills", "Tode" } ) ),
-									sortRichtungGS( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
-									sortRichtungGT( initAuswahlBox( 400, 10, 120, 20, zSchrift, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
-									gesamtSpieler( initObjTabelle( 10, 40, 760, 245, zSchrift, OTSTYLE, { { "Spielername", 120, 20, 200 },
-									{ "Teamname", 120, 20, 120 }, { "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 },
-									{ "Schaden bekommen", 130, 20, 130 }, { "Schaden gemacht", 130, 20, 130 },
-									{ "Treibstoff verbraucht", 140, 20, 140 }, { "Präzision", 60, 20, 60 }, { "Punkte", 50, 20, 50 },
-									{ "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 }, { "Zeit Am Leben", 120, 20, 120 },
-									{ "Zeit tod", 60, 20, 60 } }, 20 ) ),
-									gesamtTeam( initObjTabelle( 10, 40, 760, 245, zSchrift, OTSTYLE, { { "Teamname", 120, 20, 120 },
-									{ "Teamfarbe", 100, 20, 100 }, { "Schaden bekommen", 130, 20, 130 }, { "Schaden gemacht", 130, 20, 130 },
-									{ "Treibstoff verbraucht", 140, 20, 140 }, { "Präzision", 60, 20, 60 }, { "Punkte", 50, 20, 50 },
-									{ "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
-									teamS( 0 ),
-									rend( 0 ),
-									ref( 1 )
+StatistikTabelle::StatistikTabelle( Array< SSDSpieler * > *ssdgs, Array< SSDTeam * > *ssdgt,
+                                    UIInit &uiFactory, bool historie )
+    : ReferenceCounter(),
+    uiFactory( uiFactory ),
+    ssdgs( ssdgs ),
+    ssdgt( ssdgt ),
+    stAuswahl( initAuswahlBox( 10, 10, 120, 20, uiFactory, ABSTYLE, { "Spieler", "Teams" } ) ),
+    sortAuswahlGS( initAuswahlBox( 270, 10, 120, 20, uiFactory, ABSTYLE, { "Spielername", "Teamname",
+    "Spielerfarbe", "Teamfarbe", "Schaden bekommen", "Schaden gemacht", "Treibstoff verbraucht",
+    "Präzision", "Punkte", "Kills", "Tode", "Zeit am Leben", "Zeit tod" } ) ),
+    sortAuswahlGT( initAuswahlBox( 270, 10, 120, 20, uiFactory, ABSTYLE, { "Teamname", "Teamfarbe",
+    "Schaden bekommen", "Schaden gemacht", "Treibstoff verbraucht", "Präzision", "Punkte", "Kills", "Tode" } ) ),
+    sortRichtungGS( initAuswahlBox( 400, 10, 120, 20, uiFactory, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
+    sortRichtungGT( initAuswahlBox( 400, 10, 120, 20, uiFactory, ABSTYLE, { "Aufwärts", "Abwärts" } ) ),
+    gesamtSpieler( initObjTabelle( 10, 40, 760, 245, uiFactory, OTSTYLE, { { "Spielername", 120, 20, 200 },
+    { "Teamname", 120, 20, 120 }, { "Spielerfarbe", 100, 20, 100 }, { "Teamfarbe", 100, 20, 100 },
+    { "Schaden bekommen", 130, 20, 130 }, { "Schaden gemacht", 130, 20, 130 },
+    { "Treibstoff verbraucht", 140, 20, 140 }, { "Präzision", 60, 20, 60 }, { "Punkte", 50, 20, 50 },
+    { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 }, { "Zeit Am Leben", 120, 20, 120 },
+    { "Zeit tod", 60, 20, 60 } }, 20 ) ),
+    gesamtTeam( initObjTabelle( 10, 40, 760, 245, uiFactory, OTSTYLE, { { "Teamname", 120, 20, 120 },
+    { "Teamfarbe", 100, 20, 100 }, { "Schaden bekommen", 130, 20, 130 }, { "Schaden gemacht", 130, 20, 130 },
+    { "Treibstoff verbraucht", 140, 20, 140 }, { "Präzision", 60, 20, 60 }, { "Punkte", 50, 20, 50 },
+    { "Kills", 40, 20, 40 }, { "Tode", 40, 20, 40 } }, 20 ) ),
+    teamS( 0 ),
+    rend( 0 )
 {
-	tabelleFüllen( gesamtSpieler );
-	tabelleFüllen( gesamtTeam );
-	if( historie )
-	{
-		sortRichtungGS->setSize( 110, 20 );
-		sortRichtungGT->setSize( 110, 20 );
-		gesamtSpieler->setSize( 760, 380 );
-		gesamtTeam->setSize( 760, 380 );
-	}
+    tabelleFüllen( gesamtSpieler );
+    tabelleFüllen( gesamtTeam );
+    if( historie )
+    {
+        sortRichtungGS->setSize( 110, 20 );
+        sortRichtungGT->setSize( 110, 20 );
+        gesamtSpieler->setSize( 760, 380 );
+        gesamtTeam->setSize( 760, 380 );
+    }
 }
 
 // Destruktor
 StatistikTabelle::~StatistikTabelle()
 {
-	schrift->release();
-	ssdgs->release();
-	ssdgt->release();
-	stAuswahl->release();
-	sortAuswahlGS->release();
-	sortAuswahlGT->release();
-	sortRichtungGS->release();
-	sortRichtungGT->release();
-	gesamtSpieler->release();
-	gesamtTeam->release();
+    ssdgs->release();
+    ssdgt->release();
+    stAuswahl->release();
+    sortAuswahlGS->release();
+    sortAuswahlGT->release();
+    sortRichtungGS->release();
+    sortRichtungGT->release();
+    gesamtSpieler->release();
+    gesamtTeam->release();
 }
 
 // privat
 void StatistikTabelle::tabelleLehren( ObjTabelle *zT, bool überschrift )
 {
-	int zAnz = zT->getZeilenAnzahl();
-	for( int i = !überschrift; i < zAnz; i++ )
-		zT->removeZeile( !überschrift );
+    int zAnz = zT->getZeilenAnzahl();
+    for( int i = !überschrift; i < zAnz; i++ )
+        zT->removeZeile( !überschrift );
 }
 
 void StatistikTabelle::tabelleFüllen( ObjTabelle *zT )
 {
-	if( zT == gesamtSpieler )
-	{
-		if( !sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() ) )
-			return;
-		if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
-			return;
-		Array< int > reihenfolge;
-		bool aufsteigend = sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() )->istGleich( "Aufwärts" );
-		int anz = ssdgs->getEintragAnzahl();
-		bool *fertig = new bool[ anz ];
-		ZeroMemory( fertig, anz );
-		bool spielername = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielername" );
-		bool teamname = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamname" );
-		bool spielerfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielerfarbe" );
-		bool teamfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamfarbe" );
-		bool schadenBekommen = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Schaden bekommen" );
-		bool schadenGemacht = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Schaden gemacht" );
-		bool treibstoffVerbraucht = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Treibstoff verbraucht" );
-		bool präzision = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Präzision" );
-		bool punkte = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Punkte" );
-		bool kills = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Kills" );
-		bool tode = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Tode" );
-		bool zeitamleben = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit am Leben" );
-		bool zeittod = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit tod" );
-		for( int i = 0; i < anz; i++ )
-		{
-			Text minMaxT;
-			int minMax;
-			int pos = -1;
-			for( int j = 0; j < anz; j++ )
-			{
-				if( !ssdgs->hat( j ) || fertig[ j ] )
-					continue;
-				if( spielername && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->spielerName > minMaxT ) ) )
-				{ // Sortiert nach Spieler Name
-					minMaxT = ssdgs->get( j )->spielerName.getText();
-					pos = j;
-				}
-				if( teamname && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->teamName > minMaxT ) ) )
-				{ // Sortiert nach Team Name
-					minMaxT = ssdgs->get( j )->teamName.getText();
-					pos = j;
-				}
-				if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->spielerFarbe > minMax ) ) )
-				{ // Sortiert nach Spieler Farbe
-					minMax = ssdgs->get( j )->spielerFarbe;
-					pos = j;
-				}
-				if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->teamFarbe > minMax ) ) )
-				{ // Sortiert nach Team Farbe
-					minMax = ssdgs->get( j )->teamFarbe;
-					pos = j;
-				}
-				if( schadenBekommen && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->schadenBekommen < minMax ) || ( !aufsteigend && ssdgs->get( j )->schadenBekommen > minMax ) ) )
-				{ // Sortiert nach Schaden bekommen
-					minMax = ssdgs->get( j )->schadenBekommen;
-					pos = j;
-				}
-				if( schadenGemacht && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->schadenGemacht < minMax ) || ( !aufsteigend && ssdgs->get( j )->schadenGemacht > minMax ) ) )
-				{ // Sortiert nach Schaden gemacht
-					minMax = ssdgs->get( j )->schadenGemacht;
-					pos = j;
-				}
-				if( treibstoffVerbraucht && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->treibstoffVerbraucht < minMax ) || ( !aufsteigend && ssdgs->get( j )->treibstoffVerbraucht > minMax ) ) )
-				{ // Sortiert nach Treibstoff verbraucht
-					minMax = ssdgs->get( j )->treibstoffVerbraucht;
-					pos = j;
-				}
-				if( präzision && ( pos < 0 || ( aufsteigend && ( ssdgs->get( j )->treffer ? (int)( 100 / ( (double)ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) ) : 0 ) < minMax ) || ( !aufsteigend && ( 100 / ( ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) ) > minMax ) ) )
-				{ // Sortiert nach Treibstoff verbraucht
-					minMax = (int)( 100 / ( (double)ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) );
-					pos = j;
-				}
-				if( punkte && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgs->get( j )->punkte > minMax ) ) )
-				{ // Sortiert nach Punkten
-					minMax = ssdgs->get( j )->punkte;
-					pos = j;
-				}
-				if( kills && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->kills < minMax ) || ( !aufsteigend && ssdgs->get( j )->kills > minMax ) ) )
-				{ // Sortiert nach Kills
-					minMax = ssdgs->get( j )->kills;
-					pos = j;
-				}
-				if( tode && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->tode < minMax ) || ( !aufsteigend && ssdgs->get( j )->tode > minMax ) ) )
-				{ // Sortiert nach Toden
-					minMax = ssdgs->get( j )->tode;
-					pos = j;
-				}
-				if( zeitamleben && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitAmLeben < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitAmLeben > minMax ) ) )
-				{ // Sortiert nach Zeit Am Leben
-					minMax = ssdgs->get( j )->zeitAmLeben;
-					pos = j;
-				}
-				if( zeittod && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitTod < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitTod > minMax ) ) )
-				{ // Sortiert nach Zeit Tod
-					minMax = ssdgs->get( j )->zeitTod;
-					pos = j;
-				}
-			}
-			if( pos >= 0 )
-			{
-				reihenfolge.add( pos );
-				fertig[ pos ] = 1;
-			}
-			else
-				break;
-		}
-		delete[] fertig;
-		anz = reihenfolge.getEintragAnzahl();
-		for( int j = 0; j < anz; j++ )
-		{
-			int i = reihenfolge.get( j );
-			zT->addZeile( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
-			int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->spielerName ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgs->get( i )->teamName ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->spielerFarbe );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->teamFarbe );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenBekommen ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenGemacht ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->treibstoffVerbraucht ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ( ssdgs->get( i )->schüsse ? ( 100 * ssdgs->get( i )->treffer / ssdgs->get( i )->schüsse ) : 0 ) ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->tode ) );
-			Text zeitAmLeben;
-			zeitAmLeben += ssdgs->get( i )->zeitAmLeben / 60;
-			zeitAmLeben += ":";
-			zeitAmLeben += ssdgs->get( i )->zeitAmLeben % 60;
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit Am Leben" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitAmLeben ) );
-			Text zeitTod;
-			zeitTod += ssdgs->get( i )->zeitTod / 60;
-			zeitTod += ":";
-			zeitTod += ssdgs->get( i )->zeitTod % 60;
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit tod" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, zeitTod ) );
-		}
-		return;
-	}
-	if( zT == gesamtTeam )
-	{
-		if( !sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() ) )
-			return;
-		if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
-			return;
-		Array< int > reihenfolge;
-		bool aufsteigend = sortRichtungGT->zEintragText( sortRichtungGT->getAuswahl() )->istGleich( "Aufwärts" );
-		int anz = ssdgt->getEintragAnzahl();
-		bool *fertig = new bool[ anz ];
-		ZeroMemory( fertig, anz );
-		bool teamname = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamname" );
-		bool teamfarbe = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamfarbe" );
-		bool schadenBekommen = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Schaden bekommen" );
-		bool schadenGemacht = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Schaden gemacht" );
-		bool treibstoffVerbraucht = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Treibstoff verbraucht" );
-		bool präzision = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Präzision" );
-		bool punkte = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Punkte" );
-		bool kills = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Kills" );
-		bool tode = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Tode" );
-		for( int i = 0; i < anz; i++ )
-		{
-			Text minMaxT;
-			int minMax;
-			int pos = -1;
-			for( int j = 0; j < anz; j++ )
-			{
-				if( !ssdgt->hat( j ) || fertig[ j ] )
-					continue;
-				if( teamname && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgt->get( j )->teamName > minMaxT ) ) )
-				{ // Sortiert nach Team Name
-					minMaxT = ssdgt->get( j )->teamName.getText();
-					pos = j;
-				}
-				if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgt->get( j )->teamFarbe > minMax ) ) )
-				{ // Sortiert nach Team Farbe
-					minMax = ssdgt->get( j )->teamFarbe;
-					pos = j;
-				}
-				if( schadenBekommen && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->schadenBekommen < minMax ) || ( !aufsteigend && ssdgt->get( j )->schadenBekommen > minMax ) ) )
-				{ // Sortiert nach Schaden bekommen
-					minMax = ssdgt->get( j )->schadenBekommen;
-					pos = j;
-				}
-				if( schadenGemacht && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->schadenGemacht < minMax ) || ( !aufsteigend && ssdgt->get( j )->schadenGemacht > minMax ) ) )
-				{ // Sortiert nach Schaden gemacht
-					minMax = ssdgt->get( j )->schadenGemacht;
-					pos = j;
-				}
-				if( treibstoffVerbraucht && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->treibstoffVerbraucht < minMax ) || ( !aufsteigend && ssdgt->get( j )->treibstoffVerbraucht > minMax ) ) )
-				{ // Sortiert nach Linienlängen
-					minMax = ssdgt->get( j )->treibstoffVerbraucht;
-					pos = j;
-				}
-				if( präzision && ( pos < 0 || ( aufsteigend && ( ssdgt->get( j )->treffer ? (int)( 100 / ( (double)ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) : 0 ) < minMax ) || ( !aufsteigend && ( 100 / ( ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) > minMax ) ) )
-				{ // Sortiert nach Präzision
-					minMax = (int)( 100 / ( (double)ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) );
-					pos = j;
-				}
-				if( punkte && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgt->get( j )->punkte > minMax ) ) )
-				{ // Sortiert nach Punkten
-					minMax = ssdgt->get( j )->punkte;
-					pos = j;
-				}
-				if( kills && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->kills < minMax ) || ( !aufsteigend && ssdgt->get( j )->kills > minMax ) ) )
-				{ // Sortiert nach Kills
-					minMax = ssdgt->get( j )->kills;
-					pos = j;
-				}
-				if( tode && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->tode < minMax ) || ( !aufsteigend && ssdgt->get( j )->tode > minMax ) ) )
-				{ // Sortiert nach Toden
-					minMax = ssdgt->get( j )->tode;
-					pos = j;
-				}
-			}
-			if( pos >= 0 )
-			{
-				reihenfolge.add( pos );
-				fertig[ pos ] = 1;
-			}
-			else
-				break;
-		}
-		delete[] fertig;
-		anz = reihenfolge.getEintragAnzahl();
-		for( int j = 0; j < anz; j++ )
-		{
-			int i = reihenfolge.get( j );
-			zT->addZeile( Text( "Team " ) += ssdgt->get( i )->teamNummer );
-			int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdgt->get( i )->teamNummer );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, ssdgt->get( i )->teamName ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, 0, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
-			( (TextFeld*)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgt->get( i )->teamFarbe );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->schadenBekommen ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->schadenGemacht ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->treibstoffVerbraucht ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ( ssdgt->get( j )->treffer ? ( 100 / ( ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) : 0 ) ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->punkte ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->kills ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgt->get( i )->tode ) );
-		}
-		return;
-	}
+    if( zT == gesamtSpieler )
+    {
+        if( !sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() ) )
+            return;
+        if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
+            return;
+        Array< int > reihenfolge;
+        bool aufsteigend = sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() )->istGleich( "Aufwärts" );
+        int anz = ssdgs->getEintragAnzahl();
+        bool *fertig = new bool[ anz ];
+        ZeroMemory( fertig, anz );
+        bool spielername = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielername" );
+        bool teamname = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamname" );
+        bool spielerfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Spielerfarbe" );
+        bool teamfarbe = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Teamfarbe" );
+        bool schadenBekommen = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Schaden bekommen" );
+        bool schadenGemacht = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Schaden gemacht" );
+        bool treibstoffVerbraucht = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Treibstoff verbraucht" );
+        bool präzision = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Präzision" );
+        bool punkte = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Punkte" );
+        bool kills = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Kills" );
+        bool tode = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Tode" );
+        bool zeitamleben = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit am Leben" );
+        bool zeittod = sortAuswahlGS->zEintragText( sortAuswahlGS->getAuswahl() )->istGleich( "Zeit tod" );
+        for( int i = 0; i < anz; i++ )
+        {
+            Text minMaxT;
+            int minMax;
+            int pos = -1;
+            for( int j = 0; j < anz; j++ )
+            {
+                if( !ssdgs->hat( j ) || fertig[ j ] )
+                    continue;
+                if( spielername && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->spielerName > minMaxT ) ) )
+                { // Sortiert nach Spieler Name
+                    minMaxT = ssdgs->get( j )->spielerName.getText();
+                    pos = j;
+                }
+                if( teamname && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgs->get( j )->teamName > minMaxT ) ) )
+                { // Sortiert nach Team Name
+                    minMaxT = ssdgs->get( j )->teamName.getText();
+                    pos = j;
+                }
+                if( spielerfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->spielerFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->spielerFarbe > minMax ) ) )
+                { // Sortiert nach Spieler Farbe
+                    minMax = ssdgs->get( j )->spielerFarbe;
+                    pos = j;
+                }
+                if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgs->get( j )->teamFarbe > minMax ) ) )
+                { // Sortiert nach Team Farbe
+                    minMax = ssdgs->get( j )->teamFarbe;
+                    pos = j;
+                }
+                if( schadenBekommen && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->schadenBekommen < minMax ) || ( !aufsteigend && ssdgs->get( j )->schadenBekommen > minMax ) ) )
+                { // Sortiert nach Schaden bekommen
+                    minMax = ssdgs->get( j )->schadenBekommen;
+                    pos = j;
+                }
+                if( schadenGemacht && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->schadenGemacht < minMax ) || ( !aufsteigend && ssdgs->get( j )->schadenGemacht > minMax ) ) )
+                { // Sortiert nach Schaden gemacht
+                    minMax = ssdgs->get( j )->schadenGemacht;
+                    pos = j;
+                }
+                if( treibstoffVerbraucht && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->treibstoffVerbraucht < minMax ) || ( !aufsteigend && ssdgs->get( j )->treibstoffVerbraucht > minMax ) ) )
+                { // Sortiert nach Treibstoff verbraucht
+                    minMax = ssdgs->get( j )->treibstoffVerbraucht;
+                    pos = j;
+                }
+                if( präzision && ( pos < 0 || ( aufsteigend && ( ssdgs->get( j )->treffer ? (int)( 100 / ( (double)ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) ) : 0 ) < minMax ) || ( !aufsteigend && ( 100 / ( ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) ) > minMax ) ) )
+                { // Sortiert nach Treibstoff verbraucht
+                    minMax = (int)( 100 / ( (double)ssdgs->get( j )->schüsse / ssdgs->get( j )->treffer ) );
+                    pos = j;
+                }
+                if( punkte && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgs->get( j )->punkte > minMax ) ) )
+                { // Sortiert nach Punkten
+                    minMax = ssdgs->get( j )->punkte;
+                    pos = j;
+                }
+                if( kills && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->kills < minMax ) || ( !aufsteigend && ssdgs->get( j )->kills > minMax ) ) )
+                { // Sortiert nach Kills
+                    minMax = ssdgs->get( j )->kills;
+                    pos = j;
+                }
+                if( tode && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->tode < minMax ) || ( !aufsteigend && ssdgs->get( j )->tode > minMax ) ) )
+                { // Sortiert nach Toden
+                    minMax = ssdgs->get( j )->tode;
+                    pos = j;
+                }
+                if( zeitamleben && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitAmLeben < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitAmLeben > minMax ) ) )
+                { // Sortiert nach Zeit Am Leben
+                    minMax = ssdgs->get( j )->zeitAmLeben;
+                    pos = j;
+                }
+                if( zeittod && ( pos < 0 || ( aufsteigend && ssdgs->get( j )->zeitTod < minMax ) || ( !aufsteigend && ssdgs->get( j )->zeitTod > minMax ) ) )
+                { // Sortiert nach Zeit Tod
+                    minMax = ssdgs->get( j )->zeitTod;
+                    pos = j;
+                }
+            }
+            if( pos >= 0 )
+            {
+                reihenfolge.add( pos );
+                fertig[ pos ] = 1;
+            }
+            else
+                break;
+        }
+        delete[] fertig;
+        anz = reihenfolge.getEintragAnzahl();
+        for( int j = 0; j < anz; j++ )
+        {
+            int i = reihenfolge.get( j );
+            zT->addZeile( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
+            int zNum = zT->getZeilenNummer( Text( "Spieler " ) += ssdgs->get( i )->spielerNummer );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Spielername" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, ssdgs->get( i )->spielerName ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, ssdgs->get( i )->teamName ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Spielerfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+            ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Spielerfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->spielerFarbe );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+            ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgs->get( i )->teamFarbe );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenBekommen ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenGemacht ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgs->get( i )->treibstoffVerbraucht ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ( ssdgs->get( i )->schüsse ? ( 100 * ssdgs->get( i )->treffer / ssdgs->get( i )->schüsse ) : 0 ) ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgs->get( i )->tode ) );
+            Text zeitAmLeben;
+            zeitAmLeben += ssdgs->get( i )->zeitAmLeben / 60;
+            zeitAmLeben += ":";
+            zeitAmLeben += ssdgs->get( i )->zeitAmLeben % 60;
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit Am Leben" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, zeitAmLeben ) );
+            Text zeitTod;
+            zeitTod += ssdgs->get( i )->zeitTod / 60;
+            zeitTod += ":";
+            zeitTod += ssdgs->get( i )->zeitTod % 60;
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Zeit tod" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, zeitTod ) );
+        }
+        return;
+    }
+    if( zT == gesamtTeam )
+    {
+        if( !sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() ) )
+            return;
+        if( !sortRichtungGS->zEintragText( sortRichtungGS->getAuswahl() ) )
+            return;
+        Array< int > reihenfolge;
+        bool aufsteigend = sortRichtungGT->zEintragText( sortRichtungGT->getAuswahl() )->istGleich( "Aufwärts" );
+        int anz = ssdgt->getEintragAnzahl();
+        bool *fertig = new bool[ anz ];
+        ZeroMemory( fertig, anz );
+        bool teamname = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamname" );
+        bool teamfarbe = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Teamfarbe" );
+        bool schadenBekommen = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Schaden bekommen" );
+        bool schadenGemacht = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Schaden gemacht" );
+        bool treibstoffVerbraucht = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Treibstoff verbraucht" );
+        bool präzision = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Präzision" );
+        bool punkte = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Punkte" );
+        bool kills = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Kills" );
+        bool tode = sortAuswahlGT->zEintragText( sortAuswahlGT->getAuswahl() )->istGleich( "Tode" );
+        for( int i = 0; i < anz; i++ )
+        {
+            Text minMaxT;
+            int minMax;
+            int pos = -1;
+            for( int j = 0; j < anz; j++ )
+            {
+                if( !ssdgt->hat( j ) || fertig[ j ] )
+                    continue;
+                if( teamname && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamName < minMaxT ) || ( !aufsteigend && ssdgt->get( j )->teamName > minMaxT ) ) )
+                { // Sortiert nach Team Name
+                    minMaxT = ssdgt->get( j )->teamName.getText();
+                    pos = j;
+                }
+                if( teamfarbe && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->teamFarbe < minMax ) || ( !aufsteigend && ssdgt->get( j )->teamFarbe > minMax ) ) )
+                { // Sortiert nach Team Farbe
+                    minMax = ssdgt->get( j )->teamFarbe;
+                    pos = j;
+                }
+                if( schadenBekommen && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->schadenBekommen < minMax ) || ( !aufsteigend && ssdgt->get( j )->schadenBekommen > minMax ) ) )
+                { // Sortiert nach Schaden bekommen
+                    minMax = ssdgt->get( j )->schadenBekommen;
+                    pos = j;
+                }
+                if( schadenGemacht && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->schadenGemacht < minMax ) || ( !aufsteigend && ssdgt->get( j )->schadenGemacht > minMax ) ) )
+                { // Sortiert nach Schaden gemacht
+                    minMax = ssdgt->get( j )->schadenGemacht;
+                    pos = j;
+                }
+                if( treibstoffVerbraucht && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->treibstoffVerbraucht < minMax ) || ( !aufsteigend && ssdgt->get( j )->treibstoffVerbraucht > minMax ) ) )
+                { // Sortiert nach Linienlängen
+                    minMax = ssdgt->get( j )->treibstoffVerbraucht;
+                    pos = j;
+                }
+                if( präzision && ( pos < 0 || ( aufsteigend && ( ssdgt->get( j )->treffer ? (int)( 100 / ( (double)ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) : 0 ) < minMax ) || ( !aufsteigend && ( 100 / ( ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) > minMax ) ) )
+                { // Sortiert nach Präzision
+                    minMax = (int)( 100 / ( (double)ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) );
+                    pos = j;
+                }
+                if( punkte && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->punkte < minMax ) || ( !aufsteigend && ssdgt->get( j )->punkte > minMax ) ) )
+                { // Sortiert nach Punkten
+                    minMax = ssdgt->get( j )->punkte;
+                    pos = j;
+                }
+                if( kills && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->kills < minMax ) || ( !aufsteigend && ssdgt->get( j )->kills > minMax ) ) )
+                { // Sortiert nach Kills
+                    minMax = ssdgt->get( j )->kills;
+                    pos = j;
+                }
+                if( tode && ( pos < 0 || ( aufsteigend && ssdgt->get( j )->tode < minMax ) || ( !aufsteigend && ssdgt->get( j )->tode > minMax ) ) )
+                { // Sortiert nach Toden
+                    minMax = ssdgt->get( j )->tode;
+                    pos = j;
+                }
+            }
+            if( pos >= 0 )
+            {
+                reihenfolge.add( pos );
+                fertig[ pos ] = 1;
+            }
+            else
+                break;
+        }
+        delete[] fertig;
+        anz = reihenfolge.getEintragAnzahl();
+        for( int j = 0; j < anz; j++ )
+        {
+            int i = reihenfolge.get( j );
+            zT->addZeile( Text( "Team " ) += ssdgt->get( i )->teamNummer );
+            int zNum = zT->getZeilenNummer( Text( "Team " ) += ssdgt->get( i )->teamNummer );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamname" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, ssdgt->get( i )->teamName ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Teamfarbe" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Sichtbar | TextFeld::Style::Hintergrund, 0 ) );
+            ( (TextFeld *)zT->zZeichnung( zT->getSpaltenNummer( "Teamfarbe" ), zNum ) )->setHintergrundFarbe( ssdgt->get( i )->teamFarbe );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgt->get( i )->schadenBekommen ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgt->get( i )->schadenGemacht ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgt->get( i )->treibstoffVerbraucht ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ( ssdgt->get( j )->treffer ? ( 100 / ( ssdgt->get( j )->schüsse / ssdgt->get( j )->treffer ) ) : 0 ) ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgt->get( i )->punkte ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgt->get( i )->kills ) );
+            zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text, Text() += ssdgt->get( i )->tode ) );
+        }
+        return;
+    }
 }
 
 // nicht constant
 void StatistikTabelle::doPublicMausEreignis( MausEreignis &me )
 {
-	// Auswahl Boxen
-	int ausw = stAuswahl->getAuswahl();
-	stAuswahl->doPublicMausEreignis( me );
-	if( ausw != stAuswahl->getAuswahl() )
-	{
-		teamS = stAuswahl->zEintragText( stAuswahl->getAuswahl() )->istGleich( "Teams" );
-		stAuswahl->einklappen();
-	}
-	if( teamS )
-	{ // Team Statistik
-		int ausw = sortAuswahlGT->getAuswahl();
-		sortAuswahlGT->doPublicMausEreignis( me );
-		if( ausw != sortAuswahlGT->getAuswahl() )
-		{ // Sortierungs Spalte ändert sich
-			tabelleLehren( gesamtTeam, 0 );
-			tabelleFüllen( gesamtTeam );
-			sortAuswahlGT->einklappen();
-		}
-		ausw = sortRichtungGT->getAuswahl();
-		sortRichtungGT->doPublicMausEreignis( me );
-		if( ausw != sortRichtungGT->getAuswahl() )
-		{ // Sortierungs Richtung ändert sich
-			tabelleLehren( gesamtTeam, 0 );
-			tabelleFüllen( gesamtTeam );
-			sortRichtungGT->einklappen();
-		}
-		gesamtTeam->doPublicMausEreignis( me );
-	}
-	else
-	{ // Spieler Statistik
-		int ausw = sortAuswahlGS->getAuswahl();
-		sortAuswahlGS->doPublicMausEreignis( me );
-		if( ausw != sortAuswahlGS->getAuswahl() )
-		{ // Sortierungs Spalte ändert sich
-			tabelleLehren( gesamtSpieler, 0 );
-			tabelleFüllen( gesamtSpieler );
-			sortAuswahlGS->einklappen();
-		}
-		ausw = sortRichtungGS->getAuswahl();
-		sortRichtungGS->doPublicMausEreignis( me );
-		if( ausw != sortRichtungGS->getAuswahl() )
-		{ // Sortierungs Richtung ändert sich
-			tabelleLehren( gesamtSpieler, 0 );
-			tabelleFüllen( gesamtSpieler );
-			sortRichtungGS->einklappen();
-		}
-		gesamtSpieler->doPublicMausEreignis( me );
-	}
+    // Auswahl Boxen
+    int ausw = stAuswahl->getAuswahl();
+    stAuswahl->doPublicMausEreignis( me );
+    if( ausw != stAuswahl->getAuswahl() )
+    {
+        teamS = stAuswahl->zEintragText( stAuswahl->getAuswahl() )->istGleich( "Teams" );
+        stAuswahl->einklappen();
+    }
+    if( teamS )
+    { // Team Statistik
+        int ausw = sortAuswahlGT->getAuswahl();
+        sortAuswahlGT->doPublicMausEreignis( me );
+        if( ausw != sortAuswahlGT->getAuswahl() )
+        { // Sortierungs Spalte ändert sich
+            tabelleLehren( gesamtTeam, 0 );
+            tabelleFüllen( gesamtTeam );
+            sortAuswahlGT->einklappen();
+        }
+        ausw = sortRichtungGT->getAuswahl();
+        sortRichtungGT->doPublicMausEreignis( me );
+        if( ausw != sortRichtungGT->getAuswahl() )
+        { // Sortierungs Richtung ändert sich
+            tabelleLehren( gesamtTeam, 0 );
+            tabelleFüllen( gesamtTeam );
+            sortRichtungGT->einklappen();
+        }
+        gesamtTeam->doPublicMausEreignis( me );
+    }
+    else
+    { // Spieler Statistik
+        int ausw = sortAuswahlGS->getAuswahl();
+        sortAuswahlGS->doPublicMausEreignis( me );
+        if( ausw != sortAuswahlGS->getAuswahl() )
+        { // Sortierungs Spalte ändert sich
+            tabelleLehren( gesamtSpieler, 0 );
+            tabelleFüllen( gesamtSpieler );
+            sortAuswahlGS->einklappen();
+        }
+        ausw = sortRichtungGS->getAuswahl();
+        sortRichtungGS->doPublicMausEreignis( me );
+        if( ausw != sortRichtungGS->getAuswahl() )
+        { // Sortierungs Richtung ändert sich
+            tabelleLehren( gesamtSpieler, 0 );
+            tabelleFüllen( gesamtSpieler );
+            sortRichtungGS->einklappen();
+        }
+        gesamtSpieler->doPublicMausEreignis( me );
+    }
 }
 
 bool StatistikTabelle::tick( double tickVal )
 {
-	if( teamS )
-	{ // Team Statistik
-		rend |= gesamtTeam->tick( tickVal );
-		rend |= sortAuswahlGT->tick( tickVal );
-		rend |= sortRichtungGT->tick( tickVal );
-	}
-	else
-	{ // Spieler Statistik
-		rend |= gesamtSpieler->tick( tickVal );
-		rend |= sortAuswahlGS->tick( tickVal );
-		rend |= sortRichtungGS->tick( tickVal );
-	}
-	// Auswahl Boxen
-	rend |= stAuswahl->tick( tickVal );
-	bool ret = rend;
-	rend = 0;
-	return ret;
+    if( teamS )
+    { // Team Statistik
+        rend |= gesamtTeam->tick( tickVal );
+        rend |= sortAuswahlGT->tick( tickVal );
+        rend |= sortRichtungGT->tick( tickVal );
+    }
+    else
+    { // Spieler Statistik
+        rend |= gesamtSpieler->tick( tickVal );
+        rend |= sortAuswahlGS->tick( tickVal );
+        rend |= sortRichtungGS->tick( tickVal );
+    }
+    // Auswahl Boxen
+    rend |= stAuswahl->tick( tickVal );
+    bool ret = rend;
+    rend = 0;
+    return ret;
 }
 
 void StatistikTabelle::render( Bild &zRObj )
 {
-	if( teamS )
-	{ // Team Statistik
-		gesamtTeam->render( zRObj );
-		sortAuswahlGT->render( zRObj );
-		sortRichtungGT->render( zRObj );
-	}
-	else
-	{ // Spieler Statistik
-		gesamtSpieler->render( zRObj );
-		sortAuswahlGS->render( zRObj );
-		sortRichtungGS->render( zRObj );
-	}
-	// Auswahl Boxen
-	stAuswahl->render( zRObj );
-}
-
-// Reference Counting
-StatistikTabelle *StatistikTabelle::getThis()
-{
-	ref++;
-	return this;
-}
-
-StatistikTabelle *StatistikTabelle::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    if( teamS )
+    { // Team Statistik
+        gesamtTeam->render( zRObj );
+        sortAuswahlGT->render( zRObj );
+        sortRichtungGT->render( zRObj );
+    }
+    else
+    { // Spieler Statistik
+        gesamtSpieler->render( zRObj );
+        sortAuswahlGS->render( zRObj );
+        sortRichtungGS->render( zRObj );
+    }
+    // Auswahl Boxen
+    stAuswahl->render( zRObj );
 }

Asteroids/SpielStatistik/Tabelle/StatistikTabelle.h

@@ -3,42 +3,39 @@
 
 #include <Tabelle.h>
 #include <AuswahlBox.h>
+#include <UIInitialization.h>
 #include "../SpielStatistikDaten.h"
 
 using namespace Framework;
 
-class StatistikTabelle
+class StatistikTabelle : public virtual ReferenceCounter
 {
 private:
-	Schrift *schrift;
-	Array< SSDSpieler* > *ssdgs;
-	Array< SSDTeam* > *ssdgt;
-	AuswahlBox *stAuswahl;
-	AuswahlBox *sortAuswahlGS;
-	AuswahlBox *sortAuswahlGT;
-	AuswahlBox *sortRichtungGS;
-	AuswahlBox *sortRichtungGT;
-	ObjTabelle *gesamtSpieler;
-	ObjTabelle *gesamtTeam;
-	bool teamS;
-	bool rend;
-	int ref;
-	// privat
-	void tabelleLehren( ObjTabelle *zT, bool überschrift );
-	void tabelleFüllen( ObjTabelle *zT );
+    UIInit uiFactory;
+    Array< SSDSpieler * > *ssdgs;
+    Array< SSDTeam * > *ssdgt;
+    AuswahlBox *stAuswahl;
+    AuswahlBox *sortAuswahlGS;
+    AuswahlBox *sortAuswahlGT;
+    AuswahlBox *sortRichtungGS;
+    AuswahlBox *sortRichtungGT;
+    ObjTabelle *gesamtSpieler;
+    ObjTabelle *gesamtTeam;
+    bool teamS;
+    bool rend;
+    // privat
+    void tabelleLehren( ObjTabelle *zT, bool überschrift );
+    void tabelleFüllen( ObjTabelle *zT );
 
 public:
-	// Konstruktor
-	StatistikTabelle( Array< SSDSpieler* > *ssdgs, Array< SSDTeam* > *ssdgt, Schrift *zSchrift, Bildschirm *zScreen, bool historie = 0 );
-	// Destruktor
-	~StatistikTabelle();
-	// nicht constant
-	void doPublicMausEreignis( MausEreignis &me );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// Reference Counting
-	StatistikTabelle *getThis();
-	StatistikTabelle *release();
+    // Konstruktor
+    StatistikTabelle( Array< SSDSpieler * > *ssdgs, Array< SSDTeam * > *ssdgt, UIInit &uiFactory, bool historie = 0 );
+    // Destruktor
+    ~StatistikTabelle();
+    // nicht constant
+    void doPublicMausEreignis( MausEreignis &me );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
 };
 
 #endif