use framework ui initialisation and reference counting

Asteroids/Asteroids.vcxproj

@@ -22,13 +22,13 @@
     <ProjectGuid>{AD3BC355-BDAD-47D9-8A60-96399F56F750}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>Asteroids</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
+    <PlatformToolset>v142</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

Asteroids/Data.cpp

@@ -4,14 +4,15 @@
 
 // Konstructor
 GameData::GameData( const char *shipM2, const char *asteroidsM2 )
+    : ReferenceCounter()
 {
     world = new Welt2D();
     //world->setAirResistance( 0.01f );
     schuss = new RCArray< Schuss >();
     ship = 0;
     asteroid = new RCArray< Asteroid >();
-    aData = new Model2DData*[ 7 ]();
-    sData = new Model2DData*[ 2 ]();
+    aData = new Model2DData * [ 7 ]();
+    sData = new Model2DData * [ 2 ]();
     M2Datei m2d( asteroidsM2 );
     m2d.leseDaten();
     for( int i = 0; i < 7; i++ )
@@ -42,7 +43,6 @@ GameData::GameData( const char *shipM2, const char *asteroidsM2 )
     gameTime = 0;
     tastenStände = 0;
     rGen = 0;
-    ref = 1;
 }
 
 // Destructor
@@ -83,7 +83,7 @@ Asteroid *GameData::createNewAsteroid()
     {
         if( speed.x < 0 )
             pos.x = (float)( breite + 200 );
-        Asteroid *ast = new Asteroid( aData[ num ]->getThis(), 0, pos, speed, (float)( rGen->rand() * 100 ) / 75.f, (float)sw, aGröße / 1000.f, num );
+        Asteroid *ast = new Asteroid( dynamic_cast<Model2DData *>( aData[ num ]->getThis() ), 0, pos, speed, (float)( rGen->rand() * 100 ) / 75.f, (float)sw, aGröße / 1000.f, num );
         int aAnz = asteroid->getEintragAnzahl();
         for( int i = 0; i < aAnz; i++ )
         {
@@ -108,7 +108,7 @@ void GameData::reset( Text *zOptionen )
     scoreCheck = score * 11197;
     tastenStände = 0;
     if( ship )
-        ship = (Ship*)ship->release();
+        ship = (Ship *)ship->release();
     world->removeAll();
     schuss->leeren();
     asteroid->leeren();
@@ -132,7 +132,7 @@ void GameData::reset( Text *zOptionen )
     Vec2< float > shipSpeed( 0, 0 );
     float shipR = (float)-PI / 2;
     if( rGen )
-        rGen = rGen->release();
+        rGen = (RandomGenerator *)rGen->release();
     rGen = new RandomGenerator();
     if( zOptionen->positionVon( '=', 7 ) >= 0 )
     {
@@ -140,7 +140,7 @@ void GameData::reset( Text *zOptionen )
         rGen->setSeed( (__int64)*tmp );
         tmp->release();
     }
-    ship = new Ship( sData[ shipN ]->getThis(), shipPos, shipSpeed, shipR );
+    ship = new Ship( dynamic_cast<Model2DData *>( sData[ shipN ]->getThis() ), shipPos, shipSpeed, shipR );
     world->addObject( ship );
 }
 
@@ -168,7 +168,7 @@ bool GameData::tick( double tickVal )
             if( newA )
             {
                 asteroid->add( newA );
-                world->addObject( newA->getThis() );
+                world->addObject( dynamic_cast<Asteroid *>( newA->getThis() ) );
             }
         }
     }
@@ -218,16 +218,16 @@ bool GameData::tick( double tickVal )
                 char id = asteroid->z( j )->getId();
                 if( id >= 0 )
                     id = -id - 1;
-                Asteroid *newA = new Asteroid( npdA, asteroid->z( j )->zTextur()->zTextur()->getThis(), pa.rotation( rot ) + asteroid->z( j )->getPosition(), asteroid->z( j )->getSpeed(), asteroid->z( j )->getDrehungSpeed(), rot, asteroid->z( j )->getSize(), id );
+                Asteroid *newA = new Asteroid( npdA, dynamic_cast<Bild *>( asteroid->z( j )->zTextur()->zTextur()->getThis() ), pa.rotation( rot ) + asteroid->z( j )->getPosition(), asteroid->z( j )->getSpeed(), asteroid->z( j )->getDrehungSpeed(), rot, asteroid->z( j )->getSize(), id );
                 asteroid->add( newA );
-                world->addObject( newA->getThis() );
+                world->addObject( dynamic_cast<Asteroid *>( newA->getThis() ) );
                 Array< Polygon2D > *npaB = new Array< Polygon2D >();
                 npaB->add( bp );
                 Model2DData *npdB = new Model2DData();
                 npdB->erstelleModell( npaB );
-                newA = new Asteroid( npdB, asteroid->z( j )->zTextur()->zTextur()->getThis(), pb.rotation( rot ) + asteroid->z( j )->getPosition(), asteroid->z( j )->getSpeed(), asteroid->z( j )->getDrehungSpeed(), rot, asteroid->z( j )->getSize(), id );
+                newA = new Asteroid( npdB, dynamic_cast<Bild *>( asteroid->z( j )->zTextur()->zTextur()->getThis() ), pb.rotation( rot ) + asteroid->z( j )->getPosition(), asteroid->z( j )->getSpeed(), asteroid->z( j )->getDrehungSpeed(), rot, asteroid->z( j )->getSize(), id );
                 asteroid->add( newA );
-                world->addObject( newA->getThis() );
+                world->addObject( dynamic_cast<Asteroid *>( newA->getThis() ) );
                 b = 1;
                 asteroid->z( j )->setSize( 0 );
             }
@@ -262,19 +262,4 @@ int GameData::getScore() const
 bool GameData::istBeendet() const
 {
     return beendet;
-}
-
-// Reference Counting
-GameData *GameData::getThis()
-{
-    ref++;
-    return this;
-}
-
-GameData *GameData::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Asteroids/Data.h

@@ -5,7 +5,7 @@
 #include "Ship.h"
 #include "Asteroid.h"
 
-class GameData
+class GameData : public virtual ReferenceCounter
 {
 protected:
     Welt2D *world;
@@ -29,7 +29,6 @@ protected:
     Critical cs;
     RandomGenerator *rGen;
     char tastenStände;
-    int ref;
 
     virtual Asteroid *createNewAsteroid();
 
@@ -44,7 +43,4 @@ public:
     // constant
     int getScore() const;
     bool istBeendet() const;
-    // Reference Counting
-    GameData *getThis();
-    GameData *release();
 };

Asteroids/Game.cpp

@@ -4,13 +4,11 @@
 // Inhalt der Game Klasse aus Game.h
 // Konstruktor
 Game::Game()
+    : ReferenceCounter()
 {
-	schrift = 0;
-	screen = 0;
-	alpha = 0;
-	menü = 0;
+    alpha = 0;
+    menü = 0;
     client = 0;
-	ref = 1;
 }
 
 // Destruktor
@@ -18,10 +16,8 @@ Game::~Game()
 {
     if( client )
         client->release();
-	if( schrift )
-		schrift->release();
-	if( menü )
-		menü->release();
+    if( menü )
+        menü->release();
 }
 
 // nicht constant
@@ -34,88 +30,64 @@ void Game::setMinigameClientZ( KSGClient::MinigameServerClient *client )
 
 void Game::setMinigameAPI( MinigameAPI *api )
 {
-    
+
 }
 
 bool Game::laden()
 {
-	return 1;
+    return 1;
 }
 
 void Game::doPublicMausEreignis( MausEreignis &me )
 {
-	if( menü )
-		menü->doPublicMausEreignis( me );
+    if( menü )
+        menü->doPublicMausEreignis( me );
 }
 
 void Game::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( menü )
-		menü->doTastaturEreignis( te );
+    if( menü )
+        menü->doTastaturEreignis( te );
 }
 
 bool Game::tick( double zeit )
 {
-	int val = (int)( zeit * 150 );
-	if( menü && !menü->istBeendet() && alpha != 255 )
-	{
-		alpha += val;
-		if( alpha > 255 )
-			alpha = 255;
-		return 1;
-	}
-	if( menü && menü->istBeendet() && alpha )
-	{
-		alpha -= val;
-		if( alpha < 255 )
-			alpha = 0;
-	}
-	if( menü )
-		return menü->tick( zeit );
-	return 0;
+    int val = (int)( zeit * 150 );
+    if( menü && !menü->istBeendet() && alpha != 255 )
+    {
+        alpha += val;
+        if( alpha > 255 )
+            alpha = 255;
+        return 1;
+    }
+    if( menü && menü->istBeendet() && alpha )
+    {
+        alpha -= val;
+        if( alpha < 255 )
+            alpha = 0;
+    }
+    if( menü )
+        return menü->tick( zeit );
+    return 0;
 }
 
 void Game::render( Bild &zRObj )
 {
-	zRObj.setAlpha( alpha );
-	if( menü )
-		menü->render( zRObj );
-	zRObj.releaseAlpha();
+    zRObj.setAlpha( alpha );
+    if( menü )
+        menü->render( zRObj );
+    zRObj.releaseAlpha();
 }
 
-void Game::setSchriftZ( Schrift *schrift )
+void Game::setUIFactory( UIInit &uiFactory )
 {
-    if( this->schrift )
-        this->schrift->release();
-	this->schrift = schrift;
-	if( !menü && this->schrift && screen && client )
-		menü = new Menü( schrift, screen, client->getThis() );
-}
-
-void Game::setBildschirmZ( Bildschirm *zScreen )
-{
-	screen = zScreen;
-	if( !menü && schrift && screen && client )
-		menü = new Menü( schrift, screen, client->getThis() );
+    this->uiFactory = uiFactory;
+    if( !menü && client )
+        menü = new Menü( uiFactory, dynamic_cast<KSGClient::MinigameServerClient *>( client->getThis() ) );
 }
 
 // constant
 bool Game::istEnde() const
 {
-	return menü ? ( menü->istBeendet() && !alpha ) : 0;
-}
-
-// Reference Counting
-MiniGameV *Game::getThis()
-{
-	ref++;
-	return this;
-}
-
-MiniGameV *Game::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    return menü ? ( menü->istBeendet() && !alpha ) : 0;
 }

Asteroids/Game.h

@@ -7,12 +7,10 @@
 class Game : public MiniGameV
 {
 private:
-    Schrift *schrift;
-    Bildschirm *screen;
+    UIInit uiFactory;
     Menü *menü;
     KSGClient::MinigameServerClient *client;
     int alpha;
-    int ref;
 
 public:
     // Konstruktor
@@ -27,13 +25,9 @@ public:
     virtual void doTastaturEreignis( TastaturEreignis &te ) override;
     virtual bool tick( double zeit ) override;
     virtual void render( Bild &zRObj ) override;
-    virtual void setSchriftZ( Schrift *schrift ) override;
-    virtual void setBildschirmZ( Bildschirm *zScreen ) override;
+    virtual void setUIFactory( UIInit &uiFactory ) override;
     // constant
     virtual bool istEnde() const override;
-    // Reference Counting
-    virtual MiniGameV *getThis() override;
-    virtual MiniGameV *release() override;
 };
 
 #endif

Asteroids/Initialisierung.cpp

@@ -3,182 +3,84 @@
 #include <Textfeld.h>
 #include <MausEreignis.h>
 
-Knopf *initKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *titel )
+Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *titel )
 {
-	Knopf *ret = new Knopf();
-	ret->addStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( zSchrift )
-		ret->setSchriftZ( zSchrift->getThis() );
-	ret->setText( titel );
-	return ret;
+    Knopf *ret = uiFactory.createKnopf( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    ret->setText( titel );
+    return ret;
 }
 
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt )
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt )
 {
-	KontrollKnopf *ret = new KontrollKnopf();
-	ret->setMausEreignis( _ret1ME );
-	ret->addStyle( style );
-	ret->setSchriftZ( zSchrift->getThis() );
-	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" );
-	return ret;
+    KontrollKnopf *ret = uiFactory.createKontrollKnopf( uiFactory.initParam );
+    ret->addStyle( style );
+    ret->setText( txt );
+    ret->setSText( txt );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    return ret;
 }
 
-TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt )
+TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt )
 {
-	TextFeld *ret = new TextFeld();
-	ret->setStyle( style );
-	ret->setSchriftZ( zSchrift->getThis() );
-	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 );
+    ret->setText( txt );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    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, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
+ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, __int64 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 | TextFeld::Style::Center, i->name ) );
-		}
-	}
-	return ret;
+    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 | TextFeld::Style::Center, i->name ) );
+        }
+    }
+    return ret;
 }
 
-LDiag *initLinienDiagramm( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, DiagDaten *data )
+LDiag *initLinienDiagramm( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, DiagDaten *data )
 {
-	LDiag *ret = new LDiag();
-	ret->setStyle( style );
-	ret->setPosition( x, y );
-	ret->setSize( br, hö );
-	if( zSchrift )
-	{
-		ret->setSchriftZ( zSchrift->getThis() );
-		ret->setSchriftSize( 12 );
-	}
-	if( data )
-		ret->setDiagDatenZ( data );
-	if( ret->hatStyle( LDiag::Style::Rahmen ) )
-	{
-		ret->setRahmenBreite( 1 );
-		ret->setRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ret->hatStyle( LDiag::Style::DatenRahmen ) )
-	{
-		ret->setDatenRahmenBreite( 1 );
-		ret->setDatenRahmenFarbe( 0xFFFFFFFF );
-	}
-	if( ret->hatStyle( LDiag::Style::Hintergrund ) )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	if( ret->hatStyle( LDiag::Style::DatenHintergrund ) )
-		ret->setHintergrundFarbe( 0xFF000000 );
-	return ret;
+    LDiag *ret = uiFactory.createLDiag( uiFactory.initParam );
+    ret->setStyle( style );
+    ret->setPosition( x, y );
+    ret->setSize( br, hö );
+    if( data )
+        ret->setDiagDatenZ( data );
+    return ret;
 }

Asteroids/Initialisierung.h

@@ -7,22 +7,23 @@
 #include <Tabelle.h>
 #include <Diagramm.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, __int64 style, char *titel );
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt );
-TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, char *txt );
-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, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
-LDiag *initLinienDiagramm( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, DiagDaten *data );
+Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *titel );
+KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt );
+TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt );
+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, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
+LDiag *initLinienDiagramm( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, DiagDaten *data );
 
 #endif

Asteroids/Map.cpp

@@ -18,36 +18,36 @@ Map::Map( KSGClient::MinigameServerClient *klient )
     : GameData( "data/Minigames/Asteroids/models/ship.m2", "data/Minigames/Asteroids/models/asteroids.m2" )
 {
     kamera = new Kamera2D();
-    kamera->setWelt( world->getThis(), 1 );
+    kamera->setWelt( dynamic_cast<Welt2D *>( world->getThis() ), 1 );
     kamera->setSize( 800, 500 );
     mapKamera = new Kamera2D();
-    mapKamera->setWelt( world->getThis(), 0 );
+    mapKamera->setWelt( dynamic_cast<Welt2D *>( world->getThis() ), 0 );
     this->klient = klient;
-    aTextur = new Bild*[ 7 ]();
-    sTextur = new Bild*[ 2 ]();
+    aTextur = new Bild * [ 7 ]();
+    sTextur = new Bild * [ 2 ]();
     // lade Flammen animation
     LTDBDatei flammenStartLTDB;
     flammenStartLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_start.ltdb" ) );
     flammenStartLTDB.leseDaten( 0 );
     Animation2DData *flammenStart = new Animation2DData();
-    flammenStart->ladeAnimation( flammenStartLTDB.getThis() );
+    flammenStart->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenStartLTDB.getThis() ) );
     flammenStart->setFPS( 60 );
     flammenStart->setWiederhohlend( 0 );
     LTDBDatei flammenLTDB;
     flammenLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_burn.ltdb" ) );
     Animation2DData *flammenBurn = new Animation2DData();
-    flammenBurn->ladeAnimation( flammenLTDB.getThis() );
+    flammenBurn->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenLTDB.getThis() ) );
     flammenBurn->setFPS( 60 );
     flammenBurn->setWiederhohlend( 1 );
     flammenM = new Textur2D();
-    flammenM->addAnimationZ( flammenStart->getThis() );
-    flammenM->addAnimationZ( flammenBurn->getThis() );
+    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart->getThis() ) );
+    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn->getThis() ) );
     flammenL = new Textur2D();
-    flammenL->addAnimationZ( flammenStart->getThis() );
-    flammenL->addAnimationZ( flammenBurn->getThis() );
+    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart->getThis() ) );
+    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn->getThis() ) );
     flammenR = new Textur2D();
-    flammenR->addAnimationZ( flammenStart );
-    flammenR->addAnimationZ( flammenBurn );
+    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart ) );
+    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn ) );
     LTDBDatei td;
     td.setDatei( new Text( "data/Minigames/Asteroids/bilder/asteroids.ltdb" ) );
     td.leseDaten( 0 );
@@ -55,7 +55,7 @@ Map::Map( KSGClient::MinigameServerClient *klient )
     {
         Text name = "";
         name.append( (char)( 'a' + i ) );
-        aTextur[ i ] = td.laden( 0, new Text( (char*)( Text( name ) += ".png" ) ) );
+        aTextur[ i ] = td.laden( 0, new Text( (char *)( Text( name ) += ".png" ) ) );
     }
     td.setDatei( new Text( "data/Minigames/Asteroids/bilder/ship.ltdb" ) );
     td.leseDaten( 0 );
@@ -63,7 +63,7 @@ Map::Map( KSGClient::MinigameServerClient *klient )
     {
         Text name = "";
         name.append( (char)( 'a' + i ) );
-        sTextur[ i ] = td.laden( 0, new Text( (char*)( Text( name ) += ".png" ) ) );
+        sTextur[ i ] = td.laden( 0, new Text( (char *)( Text( name ) += ".png" ) ) );
     }
     map = new LRahmen();
     map->setFarbe( 0xFFFFFFFF );
@@ -101,7 +101,7 @@ Asteroid *Map::createNewAsteroid()
     if( a )
     {
         Textur2D *text = new Textur2D();
-        text->setTexturZ( aTextur[ a->getId() ]->getThis() );
+        text->setTexturZ( dynamic_cast<Bild *>( aTextur[ a->getId() ]->getThis() ) );
         a->setTextur( text );
     }
     return a;
@@ -148,34 +148,34 @@ void Map::reset( Text *zOptionen )
         int shn = 0;
         __int64 seed;
         if( rGen )
-            rGen = rGen->release();
-        save->lese( (char*)&seed, 8 );
+            rGen = (RandomGenerator *)rGen->release();
+        save->lese( (char *)&seed, 8 );
         rGen = new RandomGenerator();
         rGen->setSeed( seed );
-        save->lese( (char*)&gameTime, 8 );
-        save->lese( (char*)&br, 4 );
-        save->lese( (char*)&hö, 4 );
-        save->lese( (char*)&gr, 4 );
-        save->lese( (char*)&shn, 4 );
+        save->lese( (char *)&gameTime, 8 );
+        save->lese( (char *)&br, 4 );
+        save->lese( (char *)&hö, 4 );
+        save->lese( (char *)&gr, 4 );
+        save->lese( (char *)&shn, 4 );
         if( br == breite && hö == höhe && gr == aGröße && shn == shipN )
         {
-            save->lese( (char*)&score, 4 );
+            save->lese( (char *)&score, 4 );
             scoreCheck = score * 11197;
-            save->lese( (char*)&mTimer, 4 );
+            save->lese( (char *)&mTimer, 4 );
             // Schiff laden
             Vec2< float > shipPos( (float)( breite / 2 ), (float)( höhe / 2 ) );
             Vec2< float > shipSpeed( 0, 0 );
             float shipR = (float)-PI / 2;
             float shipRSpeed = 0;
-            save->lese( (char*)&shipPos.x, 4 );
-            save->lese( (char*)&shipPos.y, 4 );
-            save->lese( (char*)&shipSpeed.x, 4 );
-            save->lese( (char*)&shipSpeed.y, 4 );
-            save->lese( (char*)&shipR, 4 );
-            save->lese( (char*)&shipRSpeed, 4 );
+            save->lese( (char *)&shipPos.x, 4 );
+            save->lese( (char *)&shipPos.y, 4 );
+            save->lese( (char *)&shipSpeed.x, 4 );
+            save->lese( (char *)&shipSpeed.y, 4 );
+            save->lese( (char *)&shipR, 4 );
+            save->lese( (char *)&shipRSpeed, 4 );
             ship->setPRS( shipPos, shipSpeed, shipR, shipRSpeed );
             int anz = 0;
-            save->lese( (char*)&anz, 4 );
+            save->lese( (char *)&anz, 4 );
             for( int i = 0; i < anz; i++ )
             { // Asteroiden Laden
                 char n = 0;
@@ -187,18 +187,18 @@ void Map::reset( Text *zOptionen )
                 float r = 0;
                 float gr = 0;
                 save->lese( &n, 1 );
-                save->lese( (char*)&x, 4 );
-                save->lese( (char*)&y, 4 );
-                save->lese( (char*)&xs, 4 );
-                save->lese( (char*)&ys, 4 );
-                save->lese( (char*)&rs, 4 );
-                save->lese( (char*)&r, 4 );
-                save->lese( (char*)&gr, 4 );
+                save->lese( (char *)&x, 4 );
+                save->lese( (char *)&y, 4 );
+                save->lese( (char *)&xs, 4 );
+                save->lese( (char *)&ys, 4 );
+                save->lese( (char *)&rs, 4 );
+                save->lese( (char *)&r, 4 );
+                save->lese( (char *)&gr, 4 );
                 Bild *at = 0;
                 Model2DData *ad = 0;
                 if( n < 0 )
                 {
-                    at = aTextur[ -n - 1 ]->getThis();
+                    at = dynamic_cast<Bild *>( aTextur[ -n - 1 ]->getThis() );
                     ad = sad.ladeModel( sad.zModelName( index++ )->getText() );
                     if( index == 120 )
                     {
@@ -214,28 +214,28 @@ void Map::reset( Text *zOptionen )
                 }
                 else
                 {
-                    at = aTextur[ n ]->getThis();
-                    ad = aData[ n ]->getThis();
+                    at = dynamic_cast<Bild *>( aTextur[ n ]->getThis() );
+                    ad = dynamic_cast<Model2DData *>( aData[ n ]->getThis() );
                 }
                 asteroid->add( new Asteroid( ad, at,
                                              Vec2< float >( x, y ), Vec2< float >( xs, ys ), rs, r, gr, n ) );
             }
-            save->lese( (char*)&anz, 4 );
+            save->lese( (char *)&anz, 4 );
             for( int i = 0; i < anz; i++ )
             { // Schüsse Laden
                 float x = 0;
                 float y = 0;
                 float xs = 0;
                 float ys = 0;
-                save->lese( (char*)&x, 4 );
-                save->lese( (char*)&y, 4 );
-                save->lese( (char*)&xs, 4 );
-                save->lese( (char*)&ys, 4 );
+                save->lese( (char *)&x, 4 );
+                save->lese( (char *)&y, 4 );
+                save->lese( (char *)&xs, 4 );
+                save->lese( (char *)&ys, 4 );
                 if( schuss->getEintragAnzahl() > 100 )
                 {
                     Schuss *newS = new Schuss( Vec2< float >( x, y ), Vec2< float >( xs, ys ) );
                     schuss->add( newS );
-                    world->addObject( newS->getThis() );
+                    world->addObject( dynamic_cast<Object2D *>( newS->getThis() ) );
                 }
             }
         }
@@ -253,10 +253,10 @@ void Map::reset( Text *zOptionen )
             capture.erstellen();
             capture.open( Datei::Style::schreiben );
             __int64 seed = rGen->getSeed();
-            capture.schreibe( (char*)&seed, 8 );
+            capture.schreibe( (char *)&seed, 8 );
         }
     }
-    ship->setTexture( flammenM, flammenL, flammenR, sTextur[ shipN ]->getThis() );
+    ship->setTexture( flammenM, flammenL, flammenR, dynamic_cast<Bild *>( sTextur[ shipN ]->getThis() ) );
 }
 
 void Map::doPublicMausEreignis( MausEreignis &me )
@@ -273,7 +273,7 @@ void Map::doTastaturEreignis( TastaturEreignis &te )
         {
             if( te.id == TE_Press )
             {
-                if( (tastenStände | 1) != tastenStände )
+                if( ( tastenStände | 1 ) != tastenStände )
                     flammenM->setAnimation( 0 );
                 tastenStände |= 1;
             }
@@ -326,7 +326,7 @@ void Map::doTastaturEreignis( TastaturEreignis &te )
         {
             if( klient )
             {
-                capture.schreibe( (char*)&gameTime, 8 );
+                capture.schreibe( (char *)&gameTime, 8 );
                 capture.schreibe( &tastenStände, 1 );
             }
         }
@@ -335,14 +335,14 @@ void Map::doTastaturEreignis( TastaturEreignis &te )
     {
         if( klient && ok )
         {
-            capture.schreibe( (char*)&gameTime, 8 );
+            capture.schreibe( (char *)&gameTime, 8 );
             capture.schreibe( "\x10", 1 );
         }
         if( schuss->getEintragAnzahl() < 100 )
         {
             Schuss *newS = ship->getSchuss();
             schuss->add( newS );
-            world->addObject( newS->getThis() );
+            world->addObject( dynamic_cast<Object2D *>( newS->getThis() ) );
         }
     }
     cs.unlock();
@@ -360,8 +360,8 @@ bool Map::tick( double t )
         DateiRemove( "data/Minigames/Asteroids/data/upload.mgc" );
         DateiUmbenennen( "data/Minigames/Asteroids/data/game.mgc", "data/Minigames/Asteroids/data/upload.mgc" );
         int tmpScore = score;
-        KSGClient::MinigameServerClient *tmpKlient = klient->getThis();
-        new AsynchronCall( [ tmpScore, tmpKlient ]()
+        KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
+        new AsynchronCall( [tmpScore, tmpKlient]()
         {
             InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
             opd->laden();
@@ -422,7 +422,7 @@ bool Map::tick( double t )
 void Map::render( Bild &zRObj )
 {
     cs.lock();
-    kamera->lookAtWorldPos( (int)ship->getPosition().x, (int)ship->getPosition().y );
+    kamera->lookAtWorldPos( ship->getPosition().x, ship->getPosition().y );
     if( autoKam )
         kamera->setDrehung( -ship->getDrehung() );
     kamera->render( zRObj );
@@ -433,8 +433,8 @@ void Map::render( Bild &zRObj )
             mapKamera->setSize( 200, (int)( ( 200.0 / world->getWorldInfo().size.x ) * world->getWorldInfo().size.y ) );
         else
             mapKamera->setSize( (int)( ( 200.0 / world->getWorldInfo().size.y ) * world->getWorldInfo().size.x ), 200 );
-        mapKamera->lookAtWorldPos( world->getWorldInfo().size.x / 2, world->getWorldInfo().size.y / 2 );
-        mapKamera->lookAtWorldArea( world->getWorldInfo().size.x, world->getWorldInfo().size.y );
+        mapKamera->lookAtWorldPos( world->getWorldInfo().size.x / 2.f, world->getWorldInfo().size.y / 2.f );
+        mapKamera->lookAtWorldArea( (float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y );
         mapKamera->render( zRObj );
         map->setSize( mapKamera->getBreite(), mapKamera->getHeight() );
         map->render( zRObj );
@@ -477,20 +477,20 @@ void Map::speichern()
         d->erstellen();
         d->open( Datei::Style::schreiben );
         __int64 seed = rGen->getSeed();
-        d->schreibe( (char*)&seed, 8 );
-        d->schreibe( (char*)&gameTime, 8 );
-        d->schreibe( (char*)&breite, 4 );
-        d->schreibe( (char*)&höhe, 4 );
-        d->schreibe( (char*)&aGröße, 4 );
-        d->schreibe( (char*)&shipN, 4 );
-        d->schreibe( (char*)&score, 4 );
-        d->schreibe( (char*)&mTimer, 4 );
+        d->schreibe( (char *)&seed, 8 );
+        d->schreibe( (char *)&gameTime, 8 );
+        d->schreibe( (char *)&breite, 4 );
+        d->schreibe( (char *)&höhe, 4 );
+        d->schreibe( (char *)&aGröße, 4 );
+        d->schreibe( (char *)&shipN, 4 );
+        d->schreibe( (char *)&score, 4 );
+        d->schreibe( (char *)&mTimer, 4 );
         ship->save( d );
-        d->schreibe( (char*)&anz, 4 );
+        d->schreibe( (char *)&anz, 4 );
         for( int i = 0; i < anz; i++ )
             asteroid->z( i )->save( d );
         anz = schuss->getEintragAnzahl();
-        d->schreibe( (char*)&anz, 4 );
+        d->schreibe( (char *)&anz, 4 );
         for( int i = 0; i < anz; i++ )
             schuss->z( i )->save( d );
         d->close();

Asteroids/Menü.cpp

@@ -15,16 +15,16 @@
 
 // Inhalt der MenüVerloren Klasse aus Menü.h
 // Kontruktor
-MenüVerloren::MenüVerloren( Schrift *zSchrift )
+MenüVerloren::MenüVerloren( UIInit &uiFactory )
+    : ReferenceCounter()
 {
     ram = new LRahmen();
     ram->setSize( 160, 100 );
     ram->setPosition( 320, 200 );
     ram->setFarbe( 0xFFFFFFFF );
-    verloren = initTextFeld( 325, 210, 150, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
-    neu = initKnopf( 350, 240, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
-    beenden = initKnopf( 350, 270, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
-    ref = 1;
+    verloren = initTextFeld( 325, 210, 150, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
+    neu = initKnopf( 350, 240, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
+    beenden = initKnopf( 350, 270, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
 }
 
 // Destruktor
@@ -67,33 +67,18 @@ void Men
     ram->render( zRObj );
 }
 
-// Reference Counting
-MenüVerloren *MenüVerloren::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüVerloren *MenüVerloren::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüSpiel Klasse aus Menü.h
 // Konstruktor
-MenüSpiel::MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient )
+MenüSpiel::MenüSpiel( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
+    : ReferenceCounter()
 {
-    scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
-    beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    scoreT = initTextFeld( 690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0" );
+    beenden = initKnopf( 690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
     map = new Map( klient );
-    verloren = new MenüVerloren( zSchrift );
+    verloren = new MenüVerloren( uiFactory );
     beendet = 0;
     timePuffer = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -241,33 +226,19 @@ bool Men
     return beendet;
 }
 
-// Reference Counting
-MenüSpiel *MenüSpiel::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüSpiel *MenüSpiel::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüWiederhohlung Klasse
 // Konstruktor
-MenüWiederhohlung::MenüWiederhohlung( Schrift *zSchrift, Bildschirm *zScreen, Datei *datei, Text *zOptionen )
+MenüWiederhohlung::MenüWiederhohlung( UIInit &uiFactory, Datei *datei, Text *zOptionen )
+    : ReferenceCounter()
 {
-    scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
-    beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    scoreT = initTextFeld( 690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0" );
+    beenden = initKnopf( 690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
     this->datei = datei;
     if( !datei->istOffen() )
         datei->open( Datei::Style::lesen );
     __int64 seed;
-    datei->lese( (char*)&seed, 8 );
+    datei->lese( (char *)&seed, 8 );
     zOptionen->append( ",Fortsetzen=0,AutoKam=0,Seed=" );
     zOptionen->append( seed );
     map = new Map( 0 );
@@ -276,9 +247,8 @@ Men
     nowTime = 0;
     nextTime = 0;
     tastenStände = 0;
-    datei->lese( (char*)&nextTime, 8 );
+    datei->lese( (char *)&nextTime, 8 );
     timePuffer = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -322,7 +292,7 @@ bool Men
         if( datei->istEnde() )
             nextTime = -1;
         else
-            datei->lese( (char*)&nextTime, 8 );
+            datei->lese( (char *)&nextTime, 8 );
         TastaturEreignis te;
         te.verarbeitet = 0;
         if( ( aktion | 16 ) == aktion )
@@ -381,40 +351,25 @@ bool Men
     return beendet;
 }
 
-// Reference Counting
-MenüWiederhohlung *MenüWiederhohlung::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüWiederhohlung *MenüWiederhohlung::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüStatistik Klasse aus Menü.h
 // Konstruktor
-MenüStatistik::MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient )
+MenüStatistik::MenüStatistik( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
 {
     this->klient = klient;
     wiederH = 0;
-    ansichtT = initTextFeld( 245, 10, 50, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
-    ansicht = initAuswahlBox( 295, 10, 120, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
-    optionen = initKontrollKnopf( 425, 10, 130, 20, zSchrift, KontrollKnopf::Style::Normal, "Optionen beachten" );
-    worldBestT = initObjTabelle( 115, 40, 570, 120, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, {"Ansehen", 55, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-    gesammtT = initObjTabelle( 115, 170, 570, 290, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-    optionenT = initObjTabelle( 115, 170, 570, 290, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-    gesammtD = initLinienDiagramm( 100, 170, 600, 290, zSchrift, LDiag::Style::DatenRahmen, 0 );
-    optionenD = initLinienDiagramm( 100, 170, 600, 290, zSchrift, LDiag::Style::DatenRahmen, 0 );
-    remove = initKnopf( 10, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurücksetzen" );
-    zurück = initKnopf( 350, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurück" );
-    screen = zScreen->getThis();
-    schrift = zSchrift->getThis();
-    tr = new TextRenderer( schrift->getThis() );
+    ansichtT = initTextFeld( 245, 10, 50, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
+    ansicht = initAuswahlBox( 295, 10, 120, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
+    optionen = initKontrollKnopf( 425, 10, 130, 20, uiFactory, KontrollKnopf::Style::Normal, "Optionen beachten" );
+    worldBestT = initObjTabelle( 115, 40, 570, 120, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, {"Ansehen", 55, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
+    gesammtT = initObjTabelle( 115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
+    optionenT = initObjTabelle( 115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
+    gesammtD = initLinienDiagramm( 100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0 );
+    optionenD = initLinienDiagramm( 100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0 );
+    remove = initKnopf( 10, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurücksetzen" );
+    zurück = initKnopf( 350, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurück" );
+    this->uiFactory = uiFactory;
+    tr = new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
     asyncFinished = 1;
 }
 
@@ -434,23 +389,20 @@ Men
     optionenD->release();
     remove->release();
     zurück->release();
-    schrift->release();
     klient->release();
     if( wiederH )
         wiederH->release();
-    screen->release();
 }
 
 // nicht constant
 void MenüStatistik::reset()
 {
     if( wiederH )
-        wiederH = wiederH->release();
-    ObjTabelle *tmpWBT = (ObjTabelle*)worldBestT->getThis();
-    KSGClient::MinigameServerClient *tmpKlient = klient->getThis();
-    Schrift *tmpSchrift = schrift->getThis();
+        wiederH = (MenüWiederhohlung *)wiederH->release();
+    ObjTabelle *tmpWBT = dynamic_cast<ObjTabelle *>( worldBestT->getThis() );
+    KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
     asyncFinished = 0;
-    new AsynchronCall( [ this, tmpWBT, tmpKlient, tmpSchrift ]()
+    new AsynchronCall( [this, tmpWBT, tmpKlient]()
     {
         Array< int > score;
         RCArray< Text > player;
@@ -458,8 +410,8 @@ void Men
         int anz = tmpKlient->getMinigameBestscoreList( "Asteroids", &score, &player, &option );
         for( int i = 0; i < anz; i++ )
         {
-            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
-            TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
+            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
+            TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
             Text optionen = option.z( i )->getText();
             Text *breite = optionen.getTeilText( optionen.positionVon( '=' ) + 1, optionen.positionVon( ',' ) );
             Text *höhe = optionen.getTeilText( optionen.positionVon( '=', 1 ) + 1, optionen.positionVon( ',', 1 ) );
@@ -475,31 +427,31 @@ void Men
                 ship->setText( "Enterprise" );
                 break;
             }
-            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
+            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
             breite->release();
-            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
+            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
             höhe->release();
-            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, größe->getText() );
+            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, größe->getText() );
             größe->release();
-            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, timer->getText() );
+            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, timer->getText() );
             timer->release();
-            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, ship->getText() );
+            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, ship->getText() );
             ship->release();
-            Knopf *ansehenK = initKnopf( 0, 0, 0, 0, tmpSchrift, Knopf::Style::Normal, "Ansehen" );
-            ansehenK->setMausEreignis( [ this, optionen ]( void *p, void *obj, MausEreignis me ) -> bool
+            Knopf *ansehenK = initKnopf( 0, 0, 0, 0, uiFactory, Knopf::Style::Normal, "Ansehen" );
+            ansehenK->setMausEreignis( [this, optionen]( void *p, void *obj, MausEreignis me ) -> bool
             {
                 if( me.id == ME_RLinks && !me.verarbeitet )
                 {
-                    ( (Knopf*)obj )->removeStyle( Knopf::Style::Erlaubt );
+                    ( (Knopf *)obj )->removeStyle( Knopf::Style::Erlaubt );
                     getThis();
-                    new AsynchronCall( [ this, optionen, obj ]()
+                    new AsynchronCall( [this, optionen, obj]()
                     {
                         Datei *d = klient->downloadGameCapture( "Asteroids", optionen );
-                        ( (Knopf*)obj )->addStyle( Knopf::Style::Erlaubt );
+                        ( (Knopf *)obj )->addStyle( Knopf::Style::Erlaubt );
                         if( wiederH )
-                            wiederH = wiederH->release();
+                            wiederH = (MenüWiederhohlung *)wiederH->release();
                         Text options = optionen.getText();
-                        wiederH = new MenüWiederhohlung( schrift, screen, d, &options );
+                        wiederH = new MenüWiederhohlung( uiFactory, d, &options );
                         release();
                     } );
                 }
@@ -517,7 +469,6 @@ void Men
         }
         tmpKlient->release();
         tmpWBT->release();
-        tmpSchrift->release();
     }, &asyncFinished );
     InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
     opd->laden();
@@ -559,13 +510,13 @@ void Men
         if( p >= 0 )
         {
             fertig[ p ] = 1;
-            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
-            TextFeld *datumT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
-            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
-            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
-            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
-            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
-            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 6 )->getText() );
+            TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
+            TextFeld *datumT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
+            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
+            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
+            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
+            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
+            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 6 )->getText() );
             int ship = *stb->zFeld( p, 6 );
             switch( ship )
             {
@@ -592,13 +543,13 @@ void Men
             {
                 optionenT->addZeile( Text() += p );
                 int n = optionenT->getZeilenNummer( Text() += p );
-                optionenT->setZeichnungZ( 0, n, scoreT->getThis() );
-                optionenT->setZeichnungZ( 1, n, datumT->getThis() );
-                optionenT->setZeichnungZ( 2, n, breiteT->getThis() );
-                optionenT->setZeichnungZ( 3, n, höheT->getThis() );
-                optionenT->setZeichnungZ( 4, n, größeT->getThis() );
-                optionenT->setZeichnungZ( 5, n, timerT->getThis() );
-                optionenT->setZeichnungZ( 6, n, shipT->getThis() );
+                optionenT->setZeichnungZ( 0, n, dynamic_cast<Zeichnung *>( scoreT->getThis() ) );
+                optionenT->setZeichnungZ( 1, n, dynamic_cast<Zeichnung *>( datumT->getThis() ) );
+                optionenT->setZeichnungZ( 2, n, dynamic_cast<Zeichnung *>( breiteT->getThis() ) );
+                optionenT->setZeichnungZ( 3, n, dynamic_cast<Zeichnung *>( höheT->getThis() ) );
+                optionenT->setZeichnungZ( 4, n, dynamic_cast<Zeichnung *>( größeT->getThis() ) );
+                optionenT->setZeichnungZ( 5, n, dynamic_cast<Zeichnung *>( timerT->getThis() ) );
+                optionenT->setZeichnungZ( 6, n, dynamic_cast<Zeichnung *>( shipT->getThis() ) );
                 if( !omS )
                     omS = maxScore;
                 oAnz++;
@@ -719,7 +670,7 @@ bool Men
     {
         bool ret = wiederH->tick( tickVal );
         if( wiederH->istBeendet() )
-            wiederH = wiederH->release();
+            wiederH = (MenüWiederhohlung *)wiederH->release();
         return ret;
     }
     bool ret = ansicht->tick( tickVal );
@@ -779,46 +730,31 @@ bool Men
     return wiederH != 0;
 }
 
-// Reference Counting
-MenüStatistik *MenüStatistik::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüStatistik *MenüStatistik::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der MenüOptionen aus Menü.h
 // Konstruktor
-MenüOptionen::MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen )
+MenüOptionen::MenüOptionen( UIInit &uiFactory )
+    : ReferenceCounter()
 {
-    breiteT = initTextFeld( 310, 120, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
-    breite = initTextFeld( 440, 120, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    breiteT = initTextFeld( 310, 120, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
+    breite = initTextFeld( 440, 120, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     breite->setTastaturEreignis( _nurNummernTE );
-    höheT = initTextFeld( 310, 160, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Höhe:" );
-    höhe = initTextFeld( 440, 160, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    höheT = initTextFeld( 310, 160, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Höhe:" );
+    höhe = initTextFeld( 440, 160, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     höhe->setTastaturEreignis( _nurNummernTE );
-    aGrößeT = initTextFeld( 310, 200, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Asteroiden Größe:" );
-    aGröße = initTextFeld( 440, 200, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    aGrößeT = initTextFeld( 310, 200, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Asteroiden Größe:" );
+    aGröße = initTextFeld( 440, 200, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     aGröße->setTastaturEreignis( _nurNummernTE );
-    timerT = initTextFeld( 310, 240, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
-    timer = initTextFeld( 440, 240, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    timerT = initTextFeld( 310, 240, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
+    timer = initTextFeld( 440, 240, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
     timer->setTastaturEreignis( _nurNummernTE );
-    shipT = initTextFeld( 310, 280, 80, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Raumschiff:" );
-    ship = initAuswahlBox( 390, 280, 100, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Normal", "Enterprise" } );
-    autoKam = initKontrollKnopf( 310, 320, 180, 25, zSchrift, KontrollKnopf::Style::Normal, "Kamera drehen" );
-    fortsetzen = initKontrollKnopf( 310, 360, 180, 25, zSchrift, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
-    abbrechen = initKnopf( 310, 400, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
-    ok = initKnopf( 405, 400, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Ok" );
+    shipT = initTextFeld( 310, 280, 80, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Raumschiff:" );
+    ship = initAuswahlBox( 390, 280, 100, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Normal", "Enterprise" } );
+    autoKam = initKontrollKnopf( 310, 320, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Kamera drehen" );
+    fortsetzen = initKontrollKnopf( 310, 360, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
+    abbrechen = initKnopf( 310, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Abbrechen" );
+    ok = initKnopf( 405, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Ok" );
     beendet = 0;
-    ref = 1;
 }
 
 // Destruktor
@@ -1000,33 +936,19 @@ bool Men
     return beendet;
 }
 
-// Reference Counting
-MenüOptionen *MenüOptionen::getThis()
-{
-    ref++;
-    return this;
-}
-
-MenüOptionen *MenüOptionen::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
 
 // Inhalt der Menü Klasse aus Menü.h
 // Konstruktor
-Menü::Menü( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient )
+Menü::Menü( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
+    : ReferenceCounter()
 {
-    spielen = initKnopf( 350, 180, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Spielen" );
-    spielenF = new MenüSpiel( zSchrift, zScreen, klient->getThis() );
-    optionen = initKnopf( 350, 220, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Optionen" );
-    optionenF = new MenüOptionen( zSchrift, zScreen );
-    statistik = initKnopf( 350, 260, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Statistik" );
-    statistikF = new MenüStatistik( zSchrift, zScreen, klient );
-    beenden = initKnopf( 350, 300, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    spielen = initKnopf( 350, 180, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Spielen" );
+    spielenF = new MenüSpiel( uiFactory, dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() ) );
+    optionen = initKnopf( 350, 220, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Optionen" );
+    optionenF = new MenüOptionen( uiFactory );
+    statistik = initKnopf( 350, 260, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Statistik" );
+    statistikF = new MenüStatistik( uiFactory, klient );
+    beenden = initKnopf( 350, 300, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
     ram = new LRahmen();
     ram->setFarbe( 0xFFFFFFFF );
     beendet = 0;
@@ -1036,7 +958,6 @@ Men
     bgd->leseDaten( 0 );
     hintergrund = bgd->laden( 0, new Text( "bg.jpg" ) );
     bgd->release();
-    ref = 1;
 }
 
 // Destruktor
@@ -1189,19 +1110,4 @@ void Men
 bool Menü::istBeendet() const
 {
     return beendet;
-}
-
-// Reference Counting
-Menü *Menü::getThis()
-{
-    ref++;
-    return this;
-}
-
-Menü *Menü::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
 }

Asteroids/Menü.h

@@ -7,33 +7,30 @@
 #include <AuswahlBox.h>
 #include "Map.h"
 #include <Rahmen.h>
+#include <UIInitialization.h>
 
 using namespace Framework;
 
-class MenüVerloren
+class MenüVerloren : public virtual ReferenceCounter
 {
 private:
     LRahmen *ram;
     TextFeld *verloren;
     Knopf *neu;
     Knopf *beenden;
-    int ref;
 
 public:
     // Kontruktor
-    MenüVerloren( Schrift *zSchrift );
+    MenüVerloren( UIInit &uiFactory );
     // Destruktor
     ~MenüVerloren();
     // nicht constant
     int doPublicMausEreignis( MausEreignis &me );
     bool tick( double tickVal );
     void render( Bild &zRObj );
-    // Reference Counting
-    MenüVerloren *getThis();
-    MenüVerloren *release();
 };
 
-class MenüSpiel
+class MenüSpiel : public virtual ReferenceCounter
 {
 private:
     TextFeld *scoreT;
@@ -42,11 +39,10 @@ private:
     MenüVerloren *verloren;
     double timePuffer;
     bool beendet;
-    int ref;
 
 public:
     // Konstruktor
-    MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
+    MenüSpiel( UIInit &uiFactory, KSGClient::MinigameServerClient *klient );
     // Destruktor
     ~MenüSpiel();
     // nicht constant
@@ -57,12 +53,9 @@ public:
     void render( Bild &zRObj );
     // constant
     bool istBeendet() const;
-    // Reference Counting
-    MenüSpiel *getThis();
-    MenüSpiel *release();
 };
 
-class MenüWiederhohlung
+class MenüWiederhohlung : public virtual ReferenceCounter
 {
 private:
     TextFeld *scoreT;
@@ -74,11 +67,10 @@ private:
     bool beendet;
     char tastenStände;
     double timePuffer;
-    int ref;
 
 public:
     // Konstruktor
-    MenüWiederhohlung( Schrift *zSchrift, Bildschirm *zScreen, Datei *datei, Text *zOptionen );
+    MenüWiederhohlung( UIInit &uiFactory, Datei *datei, Text *zOptionen );
     // Destruktor
     ~MenüWiederhohlung();
     // nicht constant
@@ -88,14 +80,12 @@ public:
     void render( Bild &zRObj );
     // constant
     bool istBeendet() const;
-    // Reference Counting
-    MenüWiederhohlung *getThis();
-    MenüWiederhohlung *release();
 };
 
-class MenüStatistik
+class MenüStatistik : public virtual ReferenceCounter
 {
 private:
+    UIInit uiFactory;
     TextFeld *ansichtT;
     AuswahlBox *ansicht;
     KontrollKnopf *optionen;
@@ -106,18 +96,15 @@ private:
     LDiag *optionenD;
     Knopf *remove;
     Knopf *zurück;
-    Schrift *schrift;
     TextRenderer *tr;
     KSGClient::MinigameServerClient *klient;
     MenüWiederhohlung *wiederH;
-    Bildschirm *screen;
     bool asyncFinished;
     bool beendet;
-    int ref = 1;
 
 public:
     // Konstruktor
-    MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
+    MenüStatistik( UIInit &uiFactory, KSGClient::MinigameServerClient *klient );
     // Destruktor
     ~MenüStatistik();
     // nicht constant
@@ -128,12 +115,9 @@ public:
     // constant
     bool istBeendet() const;
     bool istWiederhohlung() const;
-    // Reference Counting
-    MenüStatistik *getThis();
-    MenüStatistik *release();
 };
 
-class MenüOptionen
+class MenüOptionen : public virtual ReferenceCounter
 {
 private:
     TextFeld *breiteT;
@@ -151,11 +135,10 @@ private:
     Knopf *abbrechen;
     Knopf *ok;
     bool beendet;
-    int ref;
 
 public:
     // Konstruktor
-    MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen );
+    MenüOptionen( UIInit &uiFactory );
     // Destruktor
     ~MenüOptionen();
     // nicht constant
@@ -166,12 +149,9 @@ public:
     void render( Bild &zRObj );
     // constant
     bool istBeendet() const;
-    // Reference Counting
-    MenüOptionen *getThis();
-    MenüOptionen *release();
 };
 
-class Menü
+class Menü : public virtual ReferenceCounter
 {
 private:
     Knopf *spielen;
@@ -185,11 +165,10 @@ private:
     LRahmen *ram;
     bool beendet;
     int status;
-    int ref;
 
 public:
     // Konstruktor
-    Menü( Schrift *zSchrift, Bildschirm *zScreen, KSGClient::MinigameServerClient *klient );
+    Menü( UIInit &uiFactory, KSGClient::MinigameServerClient *klient );
     // Destruktor
     ~Menü();
     // nicht constant
@@ -200,9 +179,6 @@ public:
     void render( Bild &zRObj );
     // constant
     bool istBeendet() const;
-    // Reference Counting
-    Menü *getThis();
-    Menü *release();
 };
 
 #endif

Asteroids/Schuss.cpp

@@ -7,13 +7,12 @@ Schuss::Schuss( Vec2< float > pos, Vec2< float > speed )
 {
     setPosition( pos );
     setSpeed( speed );
-	ref = 1;
 }
 
 // nicht constant
 void Schuss::render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName )
 {
-	zRObj.drawLinie( (Punkt)(kamMat * position), (Punkt)( kamMat * (position - speed / 10) ), 0xFFFFFFFF );
+    zRObj.drawLinie( (Punkt)( kamMat * position ), (Punkt)( kamMat * ( position - speed / 10 ) ), 0xFFFFFFFF );
 }
 
 // constant
@@ -29,8 +28,8 @@ Rect2< float > Schuss::getBoundingBox() const
 
 void Schuss::save( Datei *zD ) const
 {
-	zD->schreibe( (char*)&position.x, 4 );
-	zD->schreibe( (char*)&position.y, 4 );
-	zD->schreibe( (char*)&speed.x, 4 );
-	zD->schreibe( (char*)&speed.y, 4 );
+    zD->schreibe( (char *)&position.x, 4 );
+    zD->schreibe( (char *)&position.y, 4 );
+    zD->schreibe( (char *)&speed.x, 4 );
+    zD->schreibe( (char *)&speed.y, 4 );
 }

Asteroids/Ship.cpp

@@ -96,9 +96,9 @@ void Ship::setTexture( Textur2D *zFlammenM, Textur2D *zFlammenL, Textur2D *zFlam
     Textur2D *txt = new Textur2D();
     txt->setTexturZ( textur );
     setTextur( txt, "ship" );
-    setTextur( zFlammenL->getThis(), "engine_l" );
-    setTextur( zFlammenR->getThis(), "engine_r" );
-    setTextur( zFlammenM->getThis(), "engine_m" );
+    setTextur( dynamic_cast<Textur2D *>( zFlammenL->getThis() ), "engine_l" );
+    setTextur( dynamic_cast<Textur2D *>( zFlammenR->getThis() ), "engine_r" );
+    setTextur( dynamic_cast<Textur2D *>( zFlammenM->getThis() ), "engine_m" );
 }
 
 void Ship::setPRS( Vec2< float > p, Vec2< float > s, float r, float rSpeed )
@@ -118,15 +118,15 @@ bool Ship::tick( const WeltInfo &info, double zeit )
 {
     if( ( tastenstände | 1 ) == tastenstände )
     {
-        impuls( getWorldPos(stM), getWorldDir(kM) * (float)zeit * 10 );
+        impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)zeit * 10 );
     }
     if( ( tastenstände | 2 ) == tastenstände )
     {
-        impuls( getWorldPos(stL), getWorldDir(kL) * ((float)zeit * 10) );
+        impuls( getWorldPos( stL ), getWorldDir( kL ) * ( (float)zeit * 10 ) );
     }
     if( ( tastenstände | 4 ) == tastenstände )
     {
-        impuls( getWorldPos(stR), getWorldDir(kR) * ((float)zeit * 10) );
+        impuls( getWorldPos( stR ), getWorldDir( kR ) * ( (float)zeit * 10 ) );
     }
     speed /= 1.01f;
     rSpeed /= 1.01f;
@@ -136,13 +136,13 @@ bool Ship::tick( const WeltInfo &info, double zeit )
 // constant
 void Ship::save( Datei *zD ) const
 {
-    zD->schreibe( (char*)&position.x, 4 );
-    zD->schreibe( (char*)&position.y, 4 );
-    zD->schreibe( (char*)&speed.x, 4 );
-    zD->schreibe( (char*)&speed.y, 4 );
+    zD->schreibe( (char *)&position.x, 4 );
+    zD->schreibe( (char *)&position.y, 4 );
+    zD->schreibe( (char *)&speed.x, 4 );
+    zD->schreibe( (char *)&speed.y, 4 );
     float r = getDrehung();
-    zD->schreibe( (char*)&r, 4 );
-    zD->schreibe( (char*)&rSpeed, 4 );
+    zD->schreibe( (char *)&r, 4 );
+    zD->schreibe( (char *)&rSpeed, 4 );
 }
 
 Schuss *Ship::getSchuss() const