Wiederhohlung des weltbesten Spiels ist jetzt möglich

Asteroids/Asteroid.cpp

@@ -3,6 +3,7 @@
 #include <Globals.h>
 #include <TastaturEreignis.h>
 #include "Schuss.h"
+#include <iostream>
 
 // Inhalt der Asteroid Klasse aus Asteroid.h
 // Konstruktor
@@ -34,13 +35,13 @@ bool Asteroid::tick( double zeit, int breite, int h
 	Vertex minP = (Vertex)asteroid->zModel()->minP * asteroid->getSize() + asteroid->getPosition();
 	Vertex maxP = (Vertex)asteroid->zModel()->maxP * asteroid->getSize() + asteroid->getPosition();
 	if( maxP.x < 0 && speed.x < 0 )
-		pos.x = breite + asteroid->zModel()->maxP.x * asteroid->getSize();
+		pos.x += breite + asteroid->zModel()->maxP.x * asteroid->getSize();
 	if( maxP.y < 0 && speed.y < 0 )
-		pos.y = höhe + asteroid->zModel()->maxP.y * asteroid->getSize();
+		pos.y += höhe + asteroid->zModel()->maxP.y * asteroid->getSize();
 	if( minP.x > breite && speed.x > 0 )
-		pos.x = 0 - asteroid->zModel()->maxP.x * asteroid->getSize();
+		pos.x -= breite + asteroid->zModel()->maxP.x * asteroid->getSize();
 	if( minP.y > höhe && speed.y > 0 )
-		pos.y = 0 - asteroid->zModel()->maxP.y * asteroid->getSize();
+		pos.y -= höhe + asteroid->zModel()->maxP.y * asteroid->getSize();
 	asteroid->setPosition( pos );
 	if( mGröße )
 	{

Asteroids/Game.cpp

@@ -9,12 +9,15 @@ Game::Game()
 	screen = 0;
 	alpha = 0;
 	menü = 0;
+    client = 0;
 	ref = 1;
 }
 
 // Destruktor
 Game::~Game()
 {
+    if( client )
+        client->release();
 	if( schrift )
 		schrift->release();
 	if( screen )
@@ -24,6 +27,13 @@ Game::~Game()
 }
 
 // nicht constant
+void Game::setMinigameClientZ( MinigameKlientV *client )
+{
+    if( this->client )
+        this->client->release();
+    this->client = client;
+}
+
 bool Game::laden()
 {
 	return 1;
@@ -73,15 +83,15 @@ void Game::render( Bild &zRObj )
 void Game::setSchriftZ( Schrift *schrift )
 {
 	this->schrift = schrift;
-	if( !menü && this->schrift && screen )
-		menü = new Menü( schrift, screen );
+	if( !menü && this->schrift && screen && client )
+		menü = new Menü( schrift, screen, client->getThis() );
 }
 
 void Game::setBildschirmZ( Bildschirm *screen )
 {
 	this->screen = screen;
-	if( !menü && schrift && screen )
-		menü = new Menü( schrift, screen );
+	if( !menü && schrift && screen && client )
+		menü = new Menü( schrift, screen, client->getThis() );
 }
 
 // constant

Asteroids/Game.h

@@ -10,6 +10,7 @@ private:
 	Schrift *schrift;
 	Bildschirm *screen;
 	Menü *menü;
+    MinigameKlientV *client;
 	int alpha;
 	int ref;
 
@@ -19,6 +20,7 @@ public:
 	// Destruktor
 	~Game();
 	// nicht constant
+    virtual void setMinigameClientZ( MinigameKlientV *client ) override;
 	virtual bool laden() override;
 	virtual void doMausEreignis( MausEreignis &me ) override;
 	virtual void doTastaturEreignis( TastaturEreignis &te ) override;

Asteroids/Map.cpp

@@ -9,200 +9,226 @@
 #include <Zeit.h>
 #include <Rahmen.h>
 #include <Globals.h>
+#include <AsynchronCall.h>
+#include <iostream>
 
 // Inhalt der Map Klasse aus Map.h
 // Konstruktor
-Map::Map()
+Map::Map( MinigameKlientV *klient )
 {
-	schuss = new RCArray< Schuss >();
-	ship = 0;
-	asteroid = new RCArray< Asteroid >();
-	aData = new Model2DData*[ 7 ]();
-	aTextur = new Bild*[ 7 ]();
-	sData = new Model2DData*[ 2 ]();
-	sTextur = new Bild*[ 2 ]();
-	M2Datei m2d( "data/Minigames/Asteroids/models/asteroids.m2" );
-	m2d.leseDaten();
-	LTDBDatei td;
-	td.setDatei( new Text( "data/Minigames/Asteroids/bilder/asteroids.ltdb" ) );
-	td.leseDaten( 0 );
-	for( int i = 0; i < 7; i++ )
-	{
-		Text name = "";
-		name.append( (char)( 'a' + i ) );
-		aData[ i ] = m2d.ladeModel( name );
-		aTextur[ i ] = td.laden( 0, new Text( (char*)( Text( name ) += ".png" ) ) );
-	}
-	m2d.setPfad( "data/Minigames/Asteroids/models/ship.m2" );
-	m2d.leseDaten();
-	td.setDatei( new Text( "data/Minigames/Asteroids/bilder/ship.ltdb" ) );
-	td.leseDaten( 0 );
-	for( int i = 0; i < 2; i++ )
-	{
-		Text name = "";
-		name.append( (char)( 'a' + i ) );
-		sData[ i ] = m2d.ladeModel( name );
-		sTextur[ i ] = td.laden( 0, new Text( (char*)( Text( name ) += ".png" ) ) );
-	}
-	kam = new LRahmen();
-	kam->setFarbe( 0xFF777777 );
-	map = new LRahmen();
-	map->setFarbe( 0xFFFFFFFF );
-	map->setPosition( 10, 10 );
-	map->setSize( 200, 200 );
-	shipN = 0;
-	score = 0;
-	breite = 0;
-	höhe = 0;
-	aGröße = 0;
-	maxTimer = 0;
-	mTimer = 0;
-	timer = 0;
-	beendet = 1;
-	rend = 0;
-	sr = 1;
-	ref = 1;
+    this->klient = klient;
+    schuss = new RCArray< Schuss >();
+    ship = 0;
+    asteroid = new RCArray< Asteroid >();
+    aData = new Model2DData*[ 7 ]();
+    aTextur = new Bild*[ 7 ]();
+    sData = new Model2DData*[ 2 ]();
+    sTextur = new Bild*[ 2 ]();
+    M2Datei m2d( "data/Minigames/Asteroids/models/asteroids.m2" );
+    m2d.leseDaten();
+    LTDBDatei td;
+    td.setDatei( new Text( "data/Minigames/Asteroids/bilder/asteroids.ltdb" ) );
+    td.leseDaten( 0 );
+    for( int i = 0; i < 7; i++ )
+    {
+        Text name = "";
+        name.append( (char)( 'a' + i ) );
+        aData[ i ] = m2d.ladeModel( name );
+        aTextur[ i ] = td.laden( 0, new Text( (char*)( Text( name ) += ".png" ) ) );
+    }
+    m2d.setPfad( "data/Minigames/Asteroids/models/ship.m2" );
+    m2d.leseDaten();
+    td.setDatei( new Text( "data/Minigames/Asteroids/bilder/ship.ltdb" ) );
+    td.leseDaten( 0 );
+    for( int i = 0; i < 2; i++ )
+    {
+        Text name = "";
+        name.append( (char)( 'a' + i ) );
+        sData[ i ] = m2d.ladeModel( name );
+        sTextur[ i ] = td.laden( 0, new Text( (char*)( Text( name ) += ".png" ) ) );
+    }
+    kam = new LRahmen();
+    kam->setFarbe( 0xFF777777 );
+    map = new LRahmen();
+    map->setFarbe( 0xFFFFFFFF );
+    map->setPosition( 10, 10 );
+    map->setSize( 200, 200 );
+    shipN = 0;
+    score = 0;
+    breite = 0;
+    höhe = 0;
+    aGröße = 0;
+    maxTimer = 0;
+    mTimer = 0;
+    timer = 0;
+    beendet = 1;
+    rend = 0;
+    gameTime = 0;
+    tastenStände = 0;
+    rGen = 0;
+    ref = 1;
 }
 
 // Destruktor
 Map::~Map()
 {
-	speichern();
-	schuss->release();
-	if( ship )
-		ship->release();
-	asteroid->release();
-	for( int i = 0; i < 7; i++ )
-	{
-		aData[ i ]->release();
-		aTextur[ i ]->release();
-	}
-	for( int i = 0; i < 2; i++ )
-	{
-		sData[ i ]->release();
-		sTextur[ i ]->release();
-	}
-	delete[] aData;
-	delete[] aTextur;
-	delete[] sData;
-	delete[] sTextur;
-	kam->release();
-	map->release();
+    speichern();
+    schuss->release();
+    if( ship )
+        ship->release();
+    asteroid->release();
+    for( int i = 0; i < 7; i++ )
+    {
+        aData[ i ]->release();
+        aTextur[ i ]->release();
+    }
+    for( int i = 0; i < 2; i++ )
+    {
+        sData[ i ]->release();
+        sTextur[ i ]->release();
+    }
+    delete[] aData;
+    delete[] aTextur;
+    delete[] sData;
+    delete[] sTextur;
+    kam->release();
+    map->release();
+    if( rGen )
+        rGen->release();
+    if( klient )
+        klient->release();
 }
 
 // nicht constant
-void Map::reset()
+void Map::reset( Text *zOptionen )
 {
-	timer = 0;
-	beendet = 0;
-	score = 0;
-	if( ship )
-		ship = ship->release();
-	schuss->leeren();
-	asteroid->leeren();
-	InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-	if( !opd->laden() )
-		DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
-	breite = 800;
-	if( opd->wertExistiert( "Breite" ) )
-		breite = (int)*opd->zWert( "Breite" );
-	else
-		opd->addWert( "Breite", "800" );
-	höhe = 500;
-	if( opd->wertExistiert( "Höhe" ) )
-		höhe = (int)*opd->zWert( "Höhe" );
-	else
-		opd->addWert( "Höhe", "500" );
-	aGröße = 1000;
-	if( opd->wertExistiert( "Größe" ) )
-		aGröße = (int)*opd->zWert( "Größe" );
-	else
-		opd->addWert( "Größe", "1000" );
-	maxTimer = 5000;
-	if( opd->wertExistiert( "Timer" ) )
-		maxTimer = (int)*opd->zWert( "Timer" );
-	else
-		opd->addWert( "Timer", "5000" );
-	mTimer = maxTimer;
-	shipN = 0;
-	if( opd->wertExistiert( "Ship" ) )
-		shipN = (int)*opd->zWert( "Ship" );
-	else
-		opd->addWert( "Ship", "0" );
-	bool fortsetzen = 0;
-	if( opd->wertExistiert( "Fortsetzen" ) )
-		fortsetzen = (int)*opd->zWert( "Fortsetzen" ) != 0;
-	else
-		opd->addWert( "Fortsetzen", "0" );
-	opd->speichern();
-	opd->release();
-	Vec2< float > shipPos( (float)( breite / 2 ), (float)( höhe / 2 ) );
-	Vec2< float > shipSpeed( 0, 0 );
-	float shipR = (float)-PI / 2;
-	if( fortsetzen && DateiExistiert( "data/Minigames/Asteroids/data/game.save" ) )
-	{
-		Datei *save = new Datei();
-		save->setDatei( "data/Minigames/Asteroids/data/game.save" );
-		save->open( Datei::Style::lesen );
-		int br = 0;
-		int hö = 0;
-		int gr = 0;
-		int shn = 0;
-		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*)&mTimer, 4 );
-			// Schiff laden
-			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 );
-			int anz = 0;
-			save->lese( (char*)&anz, 4 );
-			for( int i = 0; i < anz; i++ )
-			{ // Asteroiden Laden
-				char n = 0;
-				float x = 0;
-				float y = 0;
-				float xs = 0;
-				float ys = 0;
-				float rs = 0;
-				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 );
-				asteroid->add( new Asteroid( aData[ n ]->getThis(), aTextur[ n ]->getThis(),
-							   Vec2< float >( x, y ), Vec2< float >( xs, ys ), rs, r, gr, n ) );
-			}
-			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 );
-				schuss->add( new Schuss( Vec2< float >( x, y ), Vec2< float >( xs, ys ) ) );
-			}
-		}
-		save->close();
-		save->release();
-	}
-	ship = new Ship( sData[ shipN ]->getThis(), sTextur[ shipN ]->getThis(), shipPos, shipSpeed, shipR );
+    gameTime = 0;
+    timer = 0;
+    beendet = 0;
+    score = 0;
+    tastenStände = 0;
+    if( ship )
+        ship = ship->release();
+    schuss->leeren();
+    asteroid->leeren();
+    Text *tmp = zOptionen->getTeilText( zOptionen->positionVon( '=' ) + 1, zOptionen->positionVon( ',' ) );
+    breite = *tmp;
+    tmp->release();
+    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 1 ) + 1, zOptionen->positionVon( ',', 1 ) );
+    höhe = *tmp;
+    tmp->release();
+    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 2 ) + 1, zOptionen->positionVon( ',', 2 ) );
+    aGröße = *tmp;
+    tmp->release();
+    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 3 ) + 1, zOptionen->positionVon( ',', 3 ) );
+    maxTimer = *tmp;
+    tmp->release();
+    mTimer = maxTimer;
+    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 4 ) + 1, zOptionen->positionVon( ',', 4 ) );
+    shipN = *tmp;
+    tmp->release();
+    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 5 ) + 1, zOptionen->positionVon( ',', 5 ) );
+    bool fortsetzen = (int)*tmp != 0;
+    tmp->release();
+    Vec2< float > shipPos( (float)( breite / 2 ), (float)( höhe / 2 ) );
+    Vec2< float > shipSpeed( 0, 0 );
+    float shipR = (float)-PI / 2;
+    if( rGen )
+        rGen = rGen->release();
+    if( fortsetzen && DateiExistiert( "data/Minigames/Asteroids/data/game.save" ) && klient )
+    {
+        if( capture.istOffen() )
+            capture.close();
+        capture.setDatei( "data/Minigames/Asteroids/data/game.mgc" );
+        capture.open( Datei::Style::schreiben | Datei::Style::ende | Datei::Style::lesen );
+        Datei *save = new Datei();
+        save->setDatei( "data/Minigames/Asteroids/data/game.save" );
+        save->open( Datei::Style::lesen );
+        int br = 0;
+        int hö = 0;
+        int gr = 0;
+        int shn = 0;
+        __int64 seed;
+        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 );
+        if( br == breite && hö == höhe && gr == aGröße && shn == shipN )
+        {
+            save->lese( (char*)&score, 4 );
+            save->lese( (char*)&mTimer, 4 );
+            // Schiff laden
+            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 );
+            int anz = 0;
+            save->lese( (char*)&anz, 4 );
+            for( int i = 0; i < anz; i++ )
+            { // Asteroiden Laden
+                char n = 0;
+                float x = 0;
+                float y = 0;
+                float xs = 0;
+                float ys = 0;
+                float rs = 0;
+                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 );
+                asteroid->add( new Asteroid( aData[ n ]->getThis(), aTextur[ n ]->getThis(),
+                                             Vec2< float >( x, y ), Vec2< float >( xs, ys ), rs, r, gr, n ) );
+            }
+            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 );
+                schuss->add( new Schuss( Vec2< float >( x, y ), Vec2< float >( xs, ys ) ) );
+            }
+        }
+        save->close();
+        save->release();
+    }
+    else
+    {
+        rGen = new RandomGenerator();
+        if( klient )
+        {
+            if( capture.istOffen() )
+                capture.close();
+            DateiRemove( "data/Minigames/Asteroids/data/game.mgc" );
+            capture.setDatei( "data/Minigames/Asteroids/data/game.mgc" );
+            capture.erstellen();
+            capture.open( Datei::Style::schreiben );
+            __int64 seed = rGen->getSeed();
+            capture.schreibe( (char*)&seed, 8 );
+        }
+        else
+        {
+            tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 6 ) + 1 );
+            rGen->setSeed( (__int64)*tmp );
+            tmp->release();
+        }
+    }
+    ship = new Ship( sData[ shipN ]->getThis(), sTextur[ shipN ]->getThis(), shipPos, shipSpeed, shipR );
 }
 
 void Map::doMausEreignis( MausEreignis &me )
@@ -212,201 +238,289 @@ void Map::doMausEreignis( MausEreignis &me )
 
 void Map::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( te.taste == T_Space && te.id == TE_Press )
-		schuss->add( ship->getSchuss() );
+    cs.lock();
+    bool ok = 1;
+    if( !beendet )
+    {
+        char tmp = tastenStände;
+        if( te.taste == 'w' || te.taste == 'W' || te.taste == T_Oben )
+        {
+            if( te.id == TE_Press )
+                tastenStände |= 1;
+            else
+                tastenStände &= ~1;
+        }
+        if( te.taste == 'd' || te.taste == 'D' || te.taste == T_Rechts )
+        {
+            if( te.id == TE_Press )
+                tastenStände |= 2;
+            else
+                tastenStände &= ~2;
+        }
+        if( te.taste == 'a' || te.taste == 'A' || te.taste == T_Links )
+        {
+            if( te.id == TE_Press )
+                tastenStände |= 4;
+            else
+                tastenStände &= ~4;
+        }
+        if( te.taste == T_Space )
+        {
+            if( te.id == TE_Press )
+            {
+                tastenStände |= 8;
+                ok = 0;
+            }
+            else
+                tastenStände &= ~8;
+        }
+        if( tmp != tastenStände && klient )
+        {
+            if( klient )
+            {
+                capture.schreibe( (char*)&gameTime, 8 );
+                capture.schreibe( &tastenStände, 1 );
+            }
+        }
+    }
+    if( te.taste == T_Space && te.id == TE_Press )
+    {
+        if( klient && ok )
+        {
+            capture.schreibe( (char*)&gameTime, 8 );
+            capture.schreibe( "\x10", 1 );
+        }
+        schuss->add( ship->getSchuss() );
+    }
+    cs.unlock();
 }
 
 bool Map::tick( double tickVal )
 {
-	if( beendet )
-	{
-		bool ret = rend;
-		rend = 0;
-		return ret;
-	}
-	if( sr )
-		srand( (int)time( 0 ) );
-	sr = 0;
-	// Timer
-	timer -= tickVal;
-	if( timer <= 0 )
-	{
-		mTimer -= 25;
-		if( mTimer < 500 )
-			mTimer = 500;
-		timer = mTimer / 1000.0;
-		for( int i = 0; i < rand() % 4 + 1; i++ )
-		{
-			int num = rand() % 7;
-			double sw = ( rand() % 360 ) / 180.0 * PI;
-			Vec2< float > speed( (float)cos( sw ), (float)sin( sw ) );
-			speed *= (float)( rand() % 40 );
-			Vec2< float > pos( -200.f, höhe / 2.f );
-			if( speed.x < 0 )
-				pos.x = (float)( breite + 200 );
-			asteroid->add( new Asteroid( aData[ num ]->getThis(), aTextur[ num ]->getThis(), pos, speed, ( rand() % 100 ) / 75.f, (float)sw, aGröße / 1000.f, num ) );
-		}
-	}
-	// Update
-	int aAnz = asteroid->getEintragAnzahl();
-	for( int i = 0; i < aAnz; i++ )
-		asteroid->z( i )->tick( tickVal, breite, höhe );
-	int sAnz = schuss->getEintragAnzahl();
-	for( int i = 0; i < sAnz; i++ )
-		schuss->z( i )->tick( tickVal );
-	ship->tick( tickVal, breite, höhe );
-	for( int i = aAnz - 1; i >= 0; i-- )
-	{
-		if( !asteroid->z( i )->amLeben() )
-		{
-			score++;
-			asteroid->remove( i );
-			aAnz--;
-		}
-	}
-	for( int i = sAnz - 1; i >= 0; i-- )
-	{
-		Vec2< float > pos = schuss->z( i )->getPos();
-		if( pos.x < 0 || pos.y < 0 || pos.x > breite || pos.y > höhe )
-		{
-			sAnz--;
-			schuss->remove( i );
-		}
-	}
-	// Collision
-	for( int i = sAnz - 1; i >= 0; i-- )
-	{
-		Schuss *zs = schuss->z( i );
-		bool b = 0;
-		for( int j = 0; j < aAnz; j++ )
-			b |= asteroid->z( j )->istGetroffen( zs );
-		if( b )
-		{
-			schuss->remove( i );
-			sAnz--;
-		}
-	}
-	for( int i = 0; i < aAnz && !beendet; i++ )
-		beendet |= ship->istTod( asteroid->z( i ) );
-	if( beendet )
-	{
-		KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
-		if( !stb->laden() )
-			DateiPfadErstellen( "data/Minigames/Asteroids/data/score.ksgt" );
-		RCArray< Text > *zeile = new RCArray< Text >();
-		Zeit *zeit = getZeit();
-		zeile->add( zeit->getZeit( "y-m-d h:i:s" ) );
-		zeit->release();
-		Text *scoreT = new Text();
-		scoreT->append( score );
-		zeile->add( scoreT );
-		Text *breiteT = new Text();
-		breiteT->append( breite );
-		zeile->add( breiteT );
-		Text *höheT = new Text();
-		höheT->append( höhe );
-		zeile->add( höheT );
-		Text *timerT = new Text();
-		timerT->append( maxTimer );
-		zeile->add( timerT );
-		Text *aGrößeT = new Text();
-		aGrößeT->append( aGröße );
-		zeile->add( aGrößeT );
-		Text *shipT = new Text();
-		shipT->append( shipN );
-		zeile->add( shipT );
-		stb->addZeile( 7, zeile );
-		zeile->release();
-		stb->speichern();
-		stb->release();
+    if( beendet )
+    {
+        bool ret = rend;
+        rend = 0;
+        return ret;
+    }
+    cs.lock();
+    gameTime += tickVal;
+    // Timer
+    timer -= tickVal;
+    if( timer <= 0 )
+    {
+        mTimer -= 25;
+        if( mTimer < 500 )
+            mTimer = 500;
+        timer = mTimer / 1000.0;
+        for( int i = 0; i < rGen->rand() * 4 + 1; i++ )
+        {
+            int num = (int)(rGen->rand() * 7);
+            double sw = ( rGen->rand() * 360 ) / 180.0 * PI;
+            Vec2< float > speed( (float)cos( sw ), (float)sin( sw ) );
+            speed *= (float)( rGen->rand() * 40 );
+            Vec2< float > pos( -200.f, höhe / 2.f );
+            if( speed.x < 0 )
+                pos.x = (float)( breite + 200 );
+            asteroid->add( new Asteroid( aData[ num ]->getThis(), aTextur[ num ]->getThis(), pos, speed, (float)( rGen->rand() * 100 ) / 75.f, (float)sw, aGröße / 1000.f, num ) );
+        }
+    }
+    // Update
+    int aAnz = asteroid->getEintragAnzahl();
+    for( int i = 0; i < aAnz; i++ )
+        asteroid->z( i )->tick( tickVal, breite, höhe );
+    int sAnz = schuss->getEintragAnzahl();
+    for( int i = 0; i < sAnz; i++ )
+        schuss->z( i )->tick( tickVal );
+    ship->tick( tickVal, breite, höhe, tastenStände );
+    for( int i = aAnz - 1; i >= 0; i-- )
+    {
+        if( !asteroid->z( i )->amLeben() )
+        {
+            score++;
+            asteroid->remove( i );
+            aAnz--;
+        }
+    }
+    for( int i = sAnz - 1; i >= 0; i-- )
+    {
+        Vec2< float > pos = schuss->z( i )->getPos();
+        if( pos.x < 0 || pos.y < 0 || pos.x > breite || pos.y > höhe )
+        {
+            sAnz--;
+            schuss->remove( i );
+        }
+    }
+    // Collision
+    for( int i = sAnz - 1; i >= 0; i-- )
+    {
+        Schuss *zs = schuss->z( i );
+        bool b = 0;
+        for( int j = 0; j < aAnz; j++ )
+            b |= asteroid->z( j )->istGetroffen( zs );
+        if( b )
+        {
+            schuss->remove( i );
+            sAnz--;
+        }
+    }
+    for( int i = 0; i < aAnz && !beendet; i++ )
+        beendet |= ship->istTod( asteroid->z( i ) );
+    if( beendet && klient )
+    {
+        capture.close();
+        DateiRemove( "data/Minigames/Asteroids/data/upload.mgc" );
+        DateiUmbenennen( "data/Minigames/Asteroids/data/game.mgc", "data/Minigames/Asteroids/data/upload.mgc" );
+        int tmpScore = score;
+        MinigameKlientV *tmpKlient = klient->getThis();
+        new AsynchronCall( [ tmpScore, tmpKlient ]()
+        {
+            InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
+            opd->laden();
+            Text optionen = "Width=";
+            optionen += opd->zWert( "Breite" )->getText();
+            optionen += ",Height=";
+            optionen += opd->zWert( "Höhe" )->getText();
+            optionen += ",Size=";
+            optionen += opd->zWert( "Größe" )->getText();
+            optionen += ",Timer=";
+            optionen += opd->zWert( "Timer" )->getText();
+            optionen += ",Ship=";
+            optionen += opd->zWert( "Ship" )->getText();
+            opd->release();
+            int status = tmpKlient->reportEndOfGame( "Asteroids", optionen, tmpScore );
+            if( status == 2 )
+            {
+                Datei d;
+                d.setDatei( "data/Minigames/Asteroids/data/upload.mgc" );
+                tmpKlient->uploadGameCapture( &d );
+            }
+            DateiRemove( "data/Minigames/Asteroids/data/upload.mgc" );
+            tmpKlient->release();
+        } );
+        KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
+        if( !stb->laden() )
+            DateiPfadErstellen( "data/Minigames/Asteroids/data/score.ksgt" );
+        RCArray< Text > *zeile = new RCArray< Text >();
+        Zeit *zeit = getZeit();
+        zeile->add( zeit->getZeit( "y-m-d h:i:s" ) );
+        zeit->release();
+        Text *scoreT = new Text();
+        scoreT->append( score );
+        zeile->add( scoreT );
+        Text *breiteT = new Text();
+        breiteT->append( breite );
+        zeile->add( breiteT );
+        Text *höheT = new Text();
+        höheT->append( höhe );
+        zeile->add( höheT );
+        Text *timerT = new Text();
+        timerT->append( maxTimer );
+        zeile->add( timerT );
+        Text *aGrößeT = new Text();
+        aGrößeT->append( aGröße );
+        zeile->add( aGrößeT );
+        Text *shipT = new Text();
+        shipT->append( shipN );
+        zeile->add( shipT );
+        stb->addZeile( 7, zeile );
+        zeile->release();
+        stb->speichern();
+        stb->release();
         DateiRemove( "data/Minigames/Asteroids/data/game.save" );
-	}
-	return 1;
+    }
+    cs.unlock();
+    return 1;
 }
 
 void Map::render( Bild &zRObj )
 {
-	Punkt kamP = ship->getKamPos( breite, höhe );
-	zRObj.addScrollOffset( kamP.x, kamP.y );
-	int aAnz = asteroid->getEintragAnzahl();
-	for( int i = 0; i < aAnz; i++ )
-		asteroid->z( i )->render( zRObj );
-	int sAnz = schuss->getEintragAnzahl();
-	for( int i = 0; i < sAnz; i++ )
-		schuss->z( i )->render( zRObj );
-	ship->render( zRObj );
-	zRObj.addScrollOffset( -kamP.x, -kamP.y );
-	if( breite >= 800 || höhe >= 500 )
-	{ // Minimap
-		const Punkt &dOff = zRObj.getDrawOff();
-		map->render( zRObj );
-		zRObj.setPixelDP( 10 + ( ship->getPos().x * 200 ) / breite + dOff.x, 10 + ( ship->getPos().y * 200 ) / höhe + dOff.y, 0xFF00FF00 );
-		for( int i = 0; i < aAnz; i++ )
-			zRObj.setPixelDP( 10 + ( asteroid->z( i )->getPos().x * 200 ) / breite + dOff.x, 10 + ( asteroid->z( i )->getPos().y * 200 ) / höhe + dOff.y, 0xFFFF0000 );
-		for( int i = 0; i < sAnz; i++ )
-			zRObj.setPixelDP( 10 + ( (int)schuss->z( i )->getPos().x * 200 ) / breite + dOff.x, 10 + ( (int)schuss->z( i )->getPos().y * 200 ) / höhe + dOff.y, 0xFF00FFFF );
-		kam->setPosition( 10 + ( 200 * kamP.x ) / breite, 10 + ( 200 * kamP.y ) / höhe );
-		kam->setSize( ( 200 * 800 ) / breite, ( 200 * 500 ) / höhe );
-		if( kam->getBreite() > 200 )
-			kam->setSize( 200, kam->getHeight() );
-		if( kam->getHeight() > 200 )
-			kam->setSize( kam->getBreite(), 200 );
-		kam->render( zRObj );
-	}
+    Punkt kamP = ship->getKamPos( breite, höhe );
+    zRObj.addScrollOffset( kamP.x, kamP.y );
+    int aAnz = asteroid->getEintragAnzahl();
+    for( int i = 0; i < aAnz; i++ )
+        asteroid->z( i )->render( zRObj );
+    int sAnz = schuss->getEintragAnzahl();
+    for( int i = 0; i < sAnz; i++ )
+        schuss->z( i )->render( zRObj );
+    ship->render( zRObj );
+    zRObj.addScrollOffset( -kamP.x, -kamP.y );
+    if( breite >= 800 || höhe >= 500 )
+    { // Minimap
+        const Punkt &dOff = zRObj.getDrawOff();
+        map->render( zRObj );
+        zRObj.setPixelDP( 10 + ( ship->getPos().x * 200 ) / breite + dOff.x, 10 + ( ship->getPos().y * 200 ) / höhe + dOff.y, 0xFF00FF00 );
+        for( int i = 0; i < aAnz; i++ )
+            zRObj.setPixelDP( 10 + ( asteroid->z( i )->getPos().x * 200 ) / breite + dOff.x, 10 + ( asteroid->z( i )->getPos().y * 200 ) / höhe + dOff.y, 0xFFFF0000 );
+        for( int i = 0; i < sAnz; i++ )
+            zRObj.setPixelDP( 10 + ( (int)schuss->z( i )->getPos().x * 200 ) / breite + dOff.x, 10 + ( (int)schuss->z( i )->getPos().y * 200 ) / höhe + dOff.y, 0xFF00FFFF );
+        kam->setPosition( 10 + ( 200 * kamP.x ) / breite, 10 + ( 200 * kamP.y ) / höhe );
+        kam->setSize( ( 200 * 800 ) / breite, ( 200 * 500 ) / höhe );
+        if( kam->getBreite() > 200 )
+            kam->setSize( 200, kam->getHeight() );
+        if( kam->getHeight() > 200 )
+            kam->setSize( kam->getBreite(), 200 );
+        kam->render( zRObj );
+    }
 }
 
-// constant
-void Map::speichern() const
+void Map::speichern()
 {
-	if( !beendet )
-	{
-		Datei *d = new Datei();
-		d->setDatei( "data/Minigames/Asteroids/data/game.save" );
-		d->erstellen();
-		d->open( Datei::Style::schreiben );
-		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 );
-		int anz = asteroid->getEintragAnzahl();
-		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 );
-		for( int i = 0; i < anz; i++ )
-			schuss->z( i )->save( d );
-		d->close();
-		d->release();
-	}
-	else
-		DateiRemove( "data/Minigames/Asteroids/data/game.save" );
+    if( !beendet && klient )
+    {
+        if( capture.istOffen() )
+            capture.close();
+        Datei *d = new Datei();
+        d->setDatei( "data/Minigames/Asteroids/data/game.save" );
+        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 );
+        ship->save( d );
+        int anz = asteroid->getEintragAnzahl();
+        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 );
+        for( int i = 0; i < anz; i++ )
+            schuss->z( i )->save( d );
+        d->close();
+        d->release();
+    }
+    else if( klient )
+        DateiRemove( "data/Minigames/Asteroids/data/game.save" );
 }
 
+// constant
 int Map::getScore() const
 {
-	return score;
+    return score;
 }
 
 bool Map::istBeendet() const
 {
-	return beendet;
+    return beendet;
 }
 
 // Reference Counting
 Map *Map::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Map *Map::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Asteroids/Map.h

@@ -5,52 +5,59 @@
 #include "Schuss.h"
 #include "Ship.h"
 #include "Asteroid.h"
+#include <Random.h>
+#include "../../../Include/KSGKlientV.h"
 
 using namespace Framework;
 
 class Map
 {
 private:
-	RCArray< Schuss > *schuss;
-	Ship *ship;
-	RCArray< Asteroid > *asteroid;
-	Model2DData **aData;
-	Bild **aTextur;
-	Model2DData **sData;
-	Bild **sTextur;
-	LRahmen *kam;
-	LRahmen *map;
-	int shipN;
-	int score;
-	int breite;
-	int höhe;
-	int aGröße;
-	int mTimer;
-	int maxTimer;
-	double timer;
-	bool beendet;
-	bool rend;
-	bool sr;
-	int ref;
+    RCArray< Schuss > *schuss;
+    Ship *ship;
+    RCArray< Asteroid > *asteroid;
+    Model2DData **aData;
+    Bild **aTextur;
+    Model2DData **sData;
+    Bild **sTextur;
+    LRahmen *kam;
+    LRahmen *map;
+    int shipN;
+    int score;
+    int breite;
+    int höhe;
+    int aGröße;
+    int mTimer;
+    int maxTimer;
+    double timer;
+    bool beendet;
+    bool rend;
+    double gameTime;
+    Datei capture;
+    Critical cs;
+    MinigameKlientV *klient;
+    RandomGenerator *rGen;
+    int ref;
+    char tastenStände;
 
 public:
-	// Konstruktor
-	Map();
-	// Destruktor
-	~Map();
-	// nicht constant
-	void reset();
-	void doMausEreignis( MausEreignis &me );
-	void doTastaturEreignis( TastaturEreignis &te );
-	bool tick( double tickVal );
-	void render( Bild &zRObj );
-	// constant
-	void speichern() const;
-	int getScore() const;
-	bool istBeendet() const;
-	// Reference Counting
-	Map *getThis();
-	Map *release();
+    // Konstruktor
+    Map( MinigameKlientV *klient );
+    // Destruktor
+    ~Map();
+    // nicht constant
+    void reset( Text *zOptionen );
+    void doMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    void speichern();
+    // constant
+    int getScore() const;
+    bool istBeendet() const;
+    // Reference Counting
+    Map *getThis();
+    Map *release();
 };
 
 #endif

Asteroids/Menü.cpp

@@ -10,474 +10,820 @@
 #include <Schrift.h>
 #include <DateiSystem.h>
 #include <Rahmen.h>
+#include <AsynchronCall.h>
+#include <Bildschirm.h>
 
 // Inhalt der MenüVerloren Klasse aus Menü.h
 // Kontruktor
 MenüVerloren::MenüVerloren( Schrift *zSchrift )
 {
-	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;
+    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;
 }
 
 // Destruktor
 MenüVerloren::~MenüVerloren()
 {
-	verloren->release();
-	neu->release();
-	beenden->release();
-	ram->release();
+    verloren->release();
+    neu->release();
+    beenden->release();
+    ram->release();
 }
 
 // nicht constant
 int MenüVerloren::doMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	int ret = 0;
-	neu->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-		ret = 1;
-	beenden->doMausEreignis( me );
-	if( !vera && me.verarbeitet && !ret && me.id == ME_RLinks )
-		ret = 2;
-	return ret;
+    bool vera = me.verarbeitet;
+    int ret = 0;
+    neu->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+        ret = 1;
+    beenden->doMausEreignis( me );
+    if( !vera && me.verarbeitet && !ret && me.id == ME_RLinks )
+        ret = 2;
+    return ret;
 }
 
 bool MenüVerloren::tick( double tickVal )
 {
-	bool ret = verloren->tick( tickVal );
-	ret |= neu->tick( tickVal );
-	ret |= beenden->tick( tickVal );
-	return ret;
+    bool ret = verloren->tick( tickVal );
+    ret |= neu->tick( tickVal );
+    ret |= beenden->tick( tickVal );
+    return ret;
 }
 
 void MenüVerloren::render( Bild &zRObj )
 {
-	zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
-	verloren->render( zRObj );
-	neu->render( zRObj );
-	beenden->render( zRObj );
-	ram->render( zRObj );
+    zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
+    verloren->render( zRObj );
+    neu->render( zRObj );
+    beenden->render( zRObj );
+    ram->render( zRObj );
 }
 
 // Reference Counting
 MenüVerloren *MenüVerloren::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 MenüVerloren *MenüVerloren::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
 // Inhalt der MenüSpiel Klasse aus Menü.h
 // Konstruktor
-MenüSpiel::MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen )
+MenüSpiel::MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient )
 {
-	scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
-	beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
-	map = new Map();
-	verloren = new MenüVerloren( zSchrift );
-	beendet = 0;
-	ref = 1;
+    scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
+    beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    map = new Map( klient );
+    verloren = new MenüVerloren( zSchrift );
+    beendet = 0;
+    timePuffer = 0;
+    ref = 1;
 }
 
 // Destruktor
 MenüSpiel::~MenüSpiel()
 {
-	scoreT->release();
-	beenden->release();
-	map->release();
-	verloren->release();
+    scoreT->release();
+    beenden->release();
+    map->release();
+    verloren->release();
 }
 
 // nicht constant
 void MenüSpiel::reset()
 {
-	map->reset();
-	beendet = 0;
-	scoreT->setText( "Score: " );
-	scoreT->zText()->append( map->getScore() );
+    Text optionen = "Width=";
+    InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
+    if( !opd->laden() )
+        DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
+    if( opd->wertExistiert( "Breite" ) )
+        optionen += (int)*opd->zWert( "Breite" );
+    else
+    {
+        opd->addWert( "Breite", "800" );
+        optionen += "800";
+    }
+    optionen += ",Height=";
+    if( opd->wertExistiert( "Höhe" ) )
+        optionen += (int)*opd->zWert( "Höhe" );
+    else
+    {
+        opd->addWert( "Höhe", "500" );
+        optionen += "500";
+    }
+    optionen += ",Size=";
+    if( opd->wertExistiert( "Größe" ) )
+        optionen += (int)*opd->zWert( "Größe" );
+    else
+    {
+        opd->addWert( "Größe", "1000" );
+        optionen += 1000;
+    }
+    optionen += ",Timer=";
+    if( opd->wertExistiert( "Timer" ) )
+        optionen += (int)*opd->zWert( "Timer" );
+    else
+    {
+        opd->addWert( "Timer", "5000" );
+        optionen += 5000;
+    }
+    optionen += ",Ship=";
+    if( opd->wertExistiert( "Ship" ) )
+        optionen += (int)*opd->zWert( "Ship" );
+    else
+    {
+        opd->addWert( "Ship", "0" );
+        optionen += "0";
+    }
+    optionen += ",Fortsetzen=";
+    if( opd->wertExistiert( "Fortsetzen" ) )
+        optionen += (int)*opd->zWert( "Fortsetzen" ) != 0;
+    else
+    {
+        opd->addWert( "Fortsetzen", "0" );
+        optionen += "0";
+    }
+    opd->speichern();
+    opd->release();
+    optionen += ",Seed=0";
+    map->reset( &optionen );
+    beendet = 0;
+    scoreT->setText( "Score: " );
+    scoreT->zText()->append( map->getScore() );
 }
 
 void MenüSpiel::doMausEreignis( MausEreignis &me )
 {
-	bool vera = me.verarbeitet;
-	beenden->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-	{
-		map->speichern();
-		beendet = 1;
-	}
-	map->doMausEreignis( me );
-	if( map->istBeendet() )
-	{
-		int ak = verloren->doMausEreignis( me );
-		if( ak == 1 )
-			reset();
-		if( ak == 2 )
-			beendet = 1;
-	}
+    bool vera = me.verarbeitet;
+    beenden->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+    {
+        map->speichern();
+        beendet = 1;
+    }
+    map->doMausEreignis( me );
+    if( map->istBeendet() )
+    {
+        int ak = verloren->doMausEreignis( me );
+        if( ak == 1 )
+            reset();
+        if( ak == 2 )
+            beendet = 1;
+    }
 }
 
 void MenüSpiel::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( map->istBeendet() )
-	{
-		if( te.id == TE_Release && te.taste == T_Enter )
-			reset();
-		if( te.id == TE_Release && te.taste == T_BackSpace )
-			beendet = 1;
-		return;
-	}
-	map->doTastaturEreignis( te );
+    if( map->istBeendet() )
+    {
+        if( te.id == TE_Release && te.taste == T_Enter )
+            reset();
+        if( te.id == TE_Release && te.taste == T_BackSpace )
+            beendet = 1;
+        return;
+    }
+    map->doTastaturEreignis( te );
 }
 
 bool MenüSpiel::tick( double tickVal )
 {
-	bool ret = beenden->tick( tickVal );
-	ret |= map->tick( tickVal );
-	if( map->istBeendet() )
-		ret |= verloren->tick( tickVal );
-	scoreT->setText( "Score: " );
-	scoreT->zText()->append( map->getScore() );
-	return ret;
+    timePuffer += tickVal;
+    bool ret = beenden->tick( tickVal );
+    while( timePuffer >= 0.01 )
+    {
+        ret |= map->tick( 0.01 );
+        timePuffer -= 0.01;
+    }
+    if( map->istBeendet() )
+        ret |= verloren->tick( tickVal );
+    scoreT->setText( "Score: " );
+    scoreT->zText()->append( map->getScore() );
+    return ret;
 }
 
 void MenüSpiel::render( Bild &zRObj )
 {
-	map->render( zRObj );
-	scoreT->render( zRObj );
-	beenden->render( zRObj );
-	if( map->istBeendet() )
-		verloren->render( zRObj );
+    map->render( zRObj );
+    scoreT->render( zRObj );
+    beenden->render( zRObj );
+    if( map->istBeendet() )
+        verloren->render( zRObj );
 }
 
 // constant
 bool MenüSpiel::istBeendet() const
 {
-	return beendet;
+    return beendet;
 }
 
 // Reference Counting
 MenüSpiel *MenüSpiel::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 MenüSpiel *MenüSpiel::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    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 )
+{
+    scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
+    beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
+    this->datei = datei;
+    if( !datei->istOffen() )
+        datei->open( Datei::Style::lesen );
+    __int64 seed;
+    datei->lese( (char*)&seed, 8 );
+    zOptionen->append( ",Fortsetzen=0,Seed=" );
+    zOptionen->append( seed );
+    map = new Map( 0 );
+    map->reset( zOptionen );
+    beendet = 0;
+    nowTime = 0;
+    nextTime = 0;
+    tastenStände = 0;
+    datei->lese( (char*)&nextTime, 8 );
+    timePuffer = 0;
+    ref = 1;
+}
+
+// Destruktor
+MenüWiederhohlung::~MenüWiederhohlung()
+{
+    scoreT->release();
+    beenden->release();
+    map->release();
+    datei->close();
+    datei->release();
+}
+
+// nicht constant
+void MenüWiederhohlung::doMausEreignis( MausEreignis &me )
+{
+    bool vera = me.verarbeitet;
+    beenden->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+        beendet = 1;
+    if( map->istBeendet() )
+        beendet = 1;
+}
+
+void MenüWiederhohlung::doTastaturEreignis( TastaturEreignis &te )
+{}
+
+bool MenüWiederhohlung::tick( double tickVal )
+{
+    bool ret = beenden->tick( tickVal );
+    // TODO Replay Activity
+    while( nextTime >= 0 && nowTime + tickVal >= nextTime )
+    {
+        while( nowTime < nextTime )
+        {
+            ret |= map->tick( 0.01 );
+            tickVal -= 0.01;
+            nowTime += 0.01;
+        }
+        char aktion;
+        datei->lese( &aktion, 1 );
+        if( datei->istEnde() )
+            nextTime = -1;
+        else
+            datei->lese( (char*)&nextTime, 8 );
+        TastaturEreignis te;
+        te.verarbeitet = 0;
+        if( ( aktion | 16 ) == aktion )
+        {
+            te.id = TE_Press;
+            te.taste = T_Space;
+        }
+        else if( aktion != tastenStände )
+        {
+            if( ( aktion & ~1 ) == ( tastenStände & ~1 ) )
+            {
+                te.taste = T_Oben;
+                te.id = ( ( aktion | 1 ) == aktion ) ? TE_Press : TE_Release;
+            }
+            if( ( aktion & ~2 ) == ( tastenStände & ~2 ) )
+            {
+                te.taste = T_Rechts;
+                te.id = ( ( aktion | 2 ) == aktion ) ? TE_Press : TE_Release;
+            }
+            if( ( aktion & ~4 ) == ( tastenStände & ~4 ) )
+            {
+                te.taste = T_Links;
+                te.id = ( ( aktion | 4 ) == aktion ) ? TE_Press : TE_Release;
+            }
+            if( ( aktion & ~8 ) == ( tastenStände & ~8 ) )
+            {
+                te.taste = T_Space;
+                te.id = ( ( aktion | 8 ) == aktion ) ? TE_Press : TE_Release;
+            }
+            tastenStände = aktion;
+        }
+        map->doTastaturEreignis( te );
+    }
+    timePuffer += tickVal;
+    while( timePuffer > 0 )
+    {
+        ret |= map->tick( 0.01 );
+        nowTime += 0.01;
+        timePuffer -= 0.01;
+    }
+    scoreT->setText( "Score: " );
+    scoreT->zText()->append( map->getScore() );
+    return ret;
+}
+
+void MenüWiederhohlung::render( Bild &zRObj )
+{
+    map->render( zRObj );
+    scoreT->render( zRObj );
+    beenden->render( zRObj );
+}
+
+// constant
+bool MenüWiederhohlung::istBeendet() const
+{
+    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 )
+MenüStatistik::MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient )
 {
-	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" );
-	gesammtT = initObjTabelle( 115, 40, 570, 420, zSchrift, ObjTabelle::Style::normal, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Höhe", 70, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-	optionenT = initObjTabelle( 115, 40, 570, 420, zSchrift, ObjTabelle::Style::normal, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Höhe", 70, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-	gesammtD = initLinienDiagramm( 100, 40, 600, 420, zSchrift, LDiag::Style::DatenRahmen, 0 );
-	optionenD = initLinienDiagramm( 100, 40, 600, 420, 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" );
-	schrift = zSchrift->getThis();
+    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();
 }
 
 // Destruktor
 MenüStatistik::~MenüStatistik()
 {
-	int anz = gesammtT->getZeilenAnzahl();
-	for( int i = 0; i < anz; i++ )
-	{
-		for( int j = 0; j < 7; j++ )
-			( (TextFeld*)gesammtT->zZeichnung( j, 0 ) )->release();
-		gesammtT->removeZeile( 0 );
-	}
-	for( int j = 0; j < 7; j++ )
-		( (TextFeld*)optionenT->zZeichnung( j, 0 ) )->release();
-	ansichtT->release();
-	ansicht->release();
-	optionen->release();
-	gesammtT->release();
-	optionenT->release();
-	gesammtD->release();
-	optionenD->release();
-	remove->release();
-	zurück->release();
-	schrift->release();
+    int anz = gesammtT->getZeilenAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        for( int j = 0; j < 7; j++ )
+            ( (TextFeld*)gesammtT->zZeichnung( j, 0 ) )->release();
+        gesammtT->removeZeile( 0 );
+    }
+    for( int j = 0; j < 7; j++ )
+        ( (TextFeld*)optionenT->zZeichnung( j, 0 ) )->release();
+    while( !asyncFinished )
+    {
+        Sleep( 100 );
+    }
+    anz = worldBestT->getZeilenAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        for( int j = 0; j < 8; j++ )
+        {
+            if( j == 2 )
+                ( (Knopf*)worldBestT->zZeichnung( j, 0 ) )->release();
+            else
+                ( (TextFeld*)worldBestT->zZeichnung( j, 0 ) )->release();
+        }
+        worldBestT->removeZeile( 0 );
+    }
+    worldBestT->release();
+    ansichtT->release();
+    ansicht->release();
+    optionen->release();
+    gesammtT->release();
+    optionenT->release();
+    gesammtD->release();
+    optionenD->release();
+    remove->release();
+    zurück->release();
+    schrift->release();
+    klient->release();
+    if( wiederH )
+        wiederH->release();
+    screen->release();
 }
 
 // nicht constant
 void MenüStatistik::reset()
 {
-	int anz = gesammtT->getZeilenAnzahl();
-	for( int i = 1; i < anz; i++ )
-	{
-		for( int j = 0; j < 7; j++ )
-			( (TextFeld*)gesammtT->zZeichnung( j, 1 ) )->release();
-		gesammtT->removeZeile( 1 );
-	}
-	anz = optionenT->getZeilenAnzahl();
-	for( int i = 1; i < anz; i++ )
-		optionenT->removeZeile( 1 );
-	InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-	opd->laden();
-	if( !opd->wertExistiert( "Breite" ) )
-		opd->addWert( "Breite", "800" );
-	if( !opd->wertExistiert( "Höhe" ) )
-		opd->addWert( "Höhe", "500" );
-	if( !opd->wertExistiert( "Größe" ) )
-		opd->addWert( "Größe", "1000" );
-	if( !opd->wertExistiert( "Timer" ) )
-		opd->addWert( "Timer", "5000" );
-	if( !opd->wertExistiert( "Ship" ) )
-		opd->addWert( "Ship", "0" );
-	if( !opd->wertExistiert( "Fortsetzen" ) )
-		opd->addWert( "Fortsetzen", "0" );
-	opd->speichern();
-	KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
-	stb->laden();
-	anz = stb->getZeilenAnzahl();
-	bool *fertig = new bool[ anz ];
-	ZeroMemory( fertig, anz );
-	int mS = 0;
-	int omS = 0;
-	int oAnz = 0;
-	for( int i = 0; i < anz; i++ )
-	{
-		int maxScore = -1;
-		int p = -1;
-		for( int j = 0; j < anz; j++ )
-		{
-			if( !fertig[ j ] && maxScore < (int)*stb->zFeld( j, 1 ) )
-			{
-				p = j;
-				maxScore = (int)*stb->zFeld( j, 1 );
-			}
-		}
-		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() );
-			int ship = *stb->zFeld( p, 6 );
-			switch( ship )
-			{
-			case 0:
-				shipT->setText( "Normal" );
-				break;
-			case 1:
-				shipT->setText( "Enterprise" );
-				break;
-			}
-			gesammtT->addZeile( Text() += p );
-			gesammtT->setZeichnungZ( 0, i + 1, scoreT );
-			gesammtT->setZeichnungZ( 1, i + 1, datumT );
-			gesammtT->setZeichnungZ( 2, i + 1, breiteT );
-			gesammtT->setZeichnungZ( 3, i + 1, höheT );
-			gesammtT->setZeichnungZ( 4, i + 1, größeT );
-			gesammtT->setZeichnungZ( 5, i + 1, timerT );
-			gesammtT->setZeichnungZ( 6, i + 1, shipT );
-			if( breiteT->zText()->istGleich( opd->zWert( "Breite" )->getText() ) &&
-				höheT->zText()->istGleich( opd->zWert( "Höhe" )->getText() ) &&
-				größeT->zText()->istGleich( opd->zWert( "Größe" )->getText() ) &&
-				timerT->zText()->istGleich( opd->zWert( "Timer" )->getText() ) &&
-				stb->zFeld( p, 6 )->istGleich( opd->zWert( "Ship" )->getText() ) )
-			{
-				optionenT->addZeile( Text() += p );
-				int n = optionenT->getZeilenNummer( Text() += p );
-				optionenT->setZeichnungZ( 0, n, scoreT );
-				optionenT->setZeichnungZ( 1, n, datumT );
-				optionenT->setZeichnungZ( 2, n, breiteT );
-				optionenT->setZeichnungZ( 3, n, höheT );
-				optionenT->setZeichnungZ( 4, n, größeT );
-				optionenT->setZeichnungZ( 5, n, timerT );
-				optionenT->setZeichnungZ( 6, n, shipT );
-				if( !omS )
-					omS = maxScore;
-				oAnz++;
-			}
-		}
-		if( !mS )
-			mS = maxScore;
-	}
-	delete[] fertig;
-	DiagDaten *gd = new DiagDaten();
-	gd->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
-	gd->hIntervallFarbe = 0xFFFFFFFF;
-	gd->hIntervallName->setText( "Spiel" );
-	gd->rasterDicke = 1;
-	gd->rasterFarbe = 0xFF505050;
-	gd->vIntervallFarbe = 0xFFFFFFFF;
-	gd->vIntervallName->setText( "Score" );
-	gesammtD->setDiagDatenZ( gd );
-	gesammtD->addVIntervallText( mS + 1, Text() += ( mS + 1 ) );
-	gesammtD->addVIntervallText( 0, "0" );
-	gesammtD->addHIntervallText( 0, "1" );
-	if( anz > 1 )
-		gesammtD->addHIntervallText( anz - 1, Text() += anz );
-	gesammtD->addWert( "Score" );
-	gesammtD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
-	gesammtD->setWertFarbe( 0, 0xFF00FF00 );
-	gesammtD->zDiagWert( 0 )->hintergrund = 0xFF205050;
-	DiagDaten *od = new DiagDaten();
-	od->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
-	od->hIntervallFarbe = 0xFFFFFFFF;
-	od->hIntervallName->setText( "Spiel" );
-	od->rasterDicke = 1;
-	od->rasterFarbe = 0xFF505050;
-	od->vIntervallFarbe = 0xFFFFFFFF;
-	od->vIntervallName->setText( "Score" );
-	optionenD->setDiagDatenZ( od );
-	optionenD->addVIntervallText( omS + 1, Text() += ( omS + 1 ) );
-	optionenD->addVIntervallText( 0, "0" );
-	optionenD->addHIntervallText( 0, "1" );
-	if( oAnz > 1 )
-		optionenD->addHIntervallText( oAnz - 1, Text() += oAnz );
-	optionenD->addWert( "Score" );
-	optionenD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
-	optionenD->setWertFarbe( 0, 0xFF00FF00 );
-	optionenD->zDiagWert( 0 )->hintergrund = 0xFF205050;
-	int j = 0;
-	for( int i = 0; i < anz; i++ )
-	{
-		gesammtD->addPunkt( 0, i, (int)*stb->zFeld( i, 1 ) );
-		if( (int)*stb->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
-			(int)*stb->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
-			(int)*stb->zFeld( i, 5 ) == (int)*opd->zWert( "Größe" ) &&
-			(int)*stb->zFeld( i, 4 ) == (int)*opd->zWert( "Timer" ) &&
-			(int)*stb->zFeld( i, 6 ) == (int)*opd->zWert( "Ship" ) )
-		{
-			optionenD->addPunkt( 0, j, (int)*stb->zFeld( i, 1 ) );
-			j++;
-		}
-	}
-	stb->release();
-	opd->release();
-	beendet = 0;
+    if( wiederH )
+        wiederH = wiederH->release();
+    int anz = gesammtT->getZeilenAnzahl();
+    for( int i = 1; i < anz; i++ )
+    {
+        for( int j = 0; j < 7; j++ )
+            ( (TextFeld*)gesammtT->zZeichnung( j, 1 ) )->release();
+        gesammtT->removeZeile( 1 );
+    }
+    anz = optionenT->getZeilenAnzahl();
+    for( int i = 1; i < anz; i++ )
+        optionenT->removeZeile( 1 );
+    anz = worldBestT->getZeilenAnzahl();
+    for( int i = 1; i < anz; i++ )
+    {
+        for( int j = 0; j < 8; j++ )
+        {
+            if( j == 2 )
+                ( (Knopf*)worldBestT->zZeichnung( j, 1 ) )->release();
+            else
+                ( (TextFeld*)worldBestT->zZeichnung( j, 1 ) )->release();
+        }
+        worldBestT->removeZeile( 1 );
+    }
+    ObjTabelle *tmpWBT = worldBestT->getThis();
+    MinigameKlientV *tmpKlient = klient->getThis();
+    Schrift *tmpSchrift = schrift->getThis();
+    new AsynchronCall( [ this, tmpWBT, tmpKlient, tmpSchrift ]()
+    {
+        Array< int > score;
+        RCArray< Text > player;
+        RCArray< Text > option;
+        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() );
+            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 ) );
+            Text *größe = optionen.getTeilText( optionen.positionVon( '=', 2 ) + 1, optionen.positionVon( ',', 2 ) );
+            Text *timer = optionen.getTeilText( optionen.positionVon( '=', 3 ) + 1, optionen.positionVon( ',', 3 ) );
+            Text *ship = optionen.getTeilText( optionen.positionVon( '=', 4 ) + 1 );
+            switch( (int)*ship )
+            {
+            case 0:
+                ship->setText( "Normal" );
+                break;
+            case 1:
+                ship->setText( "Enterprise" );
+                break;
+            }
+            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, tmpSchrift, 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() );
+            höhe->release();
+            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, tmpSchrift, 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() );
+            timer->release();
+            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, tmpSchrift, 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
+            {
+                if( me.id == ME_RLinks && !me.verarbeitet )
+                {
+                    ( (Knopf*)obj )->removeStyle( Knopf::Style::Erlaubt );
+                    getThis();
+                    new AsynchronCall( [ this, optionen, obj ]()
+                    {
+                        Datei *d = klient->downloadGameCapture( "Asteroids", optionen );
+                        ( (Knopf*)obj )->addStyle( Knopf::Style::Erlaubt );
+                        if( wiederH )
+                            wiederH = wiederH->release();
+                        Text options = optionen.getText();
+                        wiederH = new MenüWiederhohlung( schrift, screen, d, &options );
+                        release();
+                    } );
+                }
+                return 1;
+            } );
+            tmpWBT->addZeile( optionen.getText() );
+            tmpWBT->setZeichnungZ( 0, i + 1, scoreT );
+            tmpWBT->setZeichnungZ( 1, i + 1, spielerT );
+            tmpWBT->setZeichnungZ( 2, i + 1, ansehenK );
+            tmpWBT->setZeichnungZ( 3, i + 1, breiteT );
+            tmpWBT->setZeichnungZ( 4, i + 1, höheT );
+            tmpWBT->setZeichnungZ( 5, i + 1, größeT );
+            tmpWBT->setZeichnungZ( 6, i + 1, timerT );
+            tmpWBT->setZeichnungZ( 7, i + 1, shipT );
+        }
+        tmpKlient->release();
+        tmpWBT->release();
+        tmpSchrift->release();
+    }, &asyncFinished );
+    InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
+    opd->laden();
+    if( !opd->wertExistiert( "Breite" ) )
+        opd->addWert( "Breite", "800" );
+    if( !opd->wertExistiert( "Höhe" ) )
+        opd->addWert( "Höhe", "500" );
+    if( !opd->wertExistiert( "Größe" ) )
+        opd->addWert( "Größe", "1000" );
+    if( !opd->wertExistiert( "Timer" ) )
+        opd->addWert( "Timer", "5000" );
+    if( !opd->wertExistiert( "Ship" ) )
+        opd->addWert( "Ship", "0" );
+    if( !opd->wertExistiert( "Fortsetzen" ) )
+        opd->addWert( "Fortsetzen", "0" );
+    opd->speichern();
+    KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
+    stb->laden();
+    anz = stb->getZeilenAnzahl();
+    bool *fertig = new bool[ anz ];
+    ZeroMemory( fertig, anz );
+    int mS = 0;
+    int omS = 0;
+    int oAnz = 0;
+    for( int i = 0; i < anz; i++ )
+    {
+        int maxScore = -1;
+        int p = -1;
+        for( int j = 0; j < anz; j++ )
+        {
+            if( !fertig[ j ] && maxScore < (int)*stb->zFeld( j, 1 ) )
+            {
+                p = j;
+                maxScore = (int)*stb->zFeld( j, 1 );
+            }
+        }
+        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() );
+            int ship = *stb->zFeld( p, 6 );
+            switch( ship )
+            {
+            case 0:
+                shipT->setText( "Normal" );
+                break;
+            case 1:
+                shipT->setText( "Enterprise" );
+                break;
+            }
+            gesammtT->addZeile( Text() += p );
+            gesammtT->setZeichnungZ( 0, i + 1, scoreT );
+            gesammtT->setZeichnungZ( 1, i + 1, datumT );
+            gesammtT->setZeichnungZ( 2, i + 1, breiteT );
+            gesammtT->setZeichnungZ( 3, i + 1, höheT );
+            gesammtT->setZeichnungZ( 4, i + 1, größeT );
+            gesammtT->setZeichnungZ( 5, i + 1, timerT );
+            gesammtT->setZeichnungZ( 6, i + 1, shipT );
+            if( breiteT->zText()->istGleich( opd->zWert( "Breite" )->getText() ) &&
+                höheT->zText()->istGleich( opd->zWert( "Höhe" )->getText() ) &&
+                größeT->zText()->istGleich( opd->zWert( "Größe" )->getText() ) &&
+                timerT->zText()->istGleich( opd->zWert( "Timer" )->getText() ) &&
+                stb->zFeld( p, 6 )->istGleich( opd->zWert( "Ship" )->getText() ) )
+            {
+                optionenT->addZeile( Text() += p );
+                int n = optionenT->getZeilenNummer( Text() += p );
+                optionenT->setZeichnungZ( 0, n, scoreT );
+                optionenT->setZeichnungZ( 1, n, datumT );
+                optionenT->setZeichnungZ( 2, n, breiteT );
+                optionenT->setZeichnungZ( 3, n, höheT );
+                optionenT->setZeichnungZ( 4, n, größeT );
+                optionenT->setZeichnungZ( 5, n, timerT );
+                optionenT->setZeichnungZ( 6, n, shipT );
+                if( !omS )
+                    omS = maxScore;
+                oAnz++;
+            }
+        }
+        if( !mS )
+            mS = maxScore;
+    }
+    delete[] fertig;
+    DiagDaten *gd = new DiagDaten();
+    gd->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
+    gd->hIntervallFarbe = 0xFFFFFFFF;
+    gd->hIntervallName->setText( "Spiel" );
+    gd->rasterDicke = 1;
+    gd->rasterFarbe = 0xFF505050;
+    gd->vIntervallFarbe = 0xFFFFFFFF;
+    gd->vIntervallName->setText( "Score" );
+    gesammtD->setDiagDatenZ( gd );
+    gesammtD->addVIntervallText( mS + 1, Text() += ( mS + 1 ) );
+    gesammtD->addVIntervallText( 0, "0" );
+    gesammtD->addHIntervallText( 0, "1" );
+    if( anz > 1 )
+        gesammtD->addHIntervallText( anz - 1, Text() += anz );
+    gesammtD->addWert( "Score" );
+    gesammtD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
+    gesammtD->setWertFarbe( 0, 0xFF00FF00 );
+    gesammtD->zDiagWert( 0 )->hintergrund = 0xFF205050;
+    DiagDaten *od = new DiagDaten();
+    od->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
+    od->hIntervallFarbe = 0xFFFFFFFF;
+    od->hIntervallName->setText( "Spiel" );
+    od->rasterDicke = 1;
+    od->rasterFarbe = 0xFF505050;
+    od->vIntervallFarbe = 0xFFFFFFFF;
+    od->vIntervallName->setText( "Score" );
+    optionenD->setDiagDatenZ( od );
+    optionenD->addVIntervallText( omS + 1, Text() += ( omS + 1 ) );
+    optionenD->addVIntervallText( 0, "0" );
+    optionenD->addHIntervallText( 0, "1" );
+    if( oAnz > 1 )
+        optionenD->addHIntervallText( oAnz - 1, Text() += oAnz );
+    optionenD->addWert( "Score" );
+    optionenD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
+    optionenD->setWertFarbe( 0, 0xFF00FF00 );
+    optionenD->zDiagWert( 0 )->hintergrund = 0xFF205050;
+    int j = 0;
+    for( int i = 0; i < anz; i++ )
+    {
+        gesammtD->addPunkt( 0, i, (int)*stb->zFeld( i, 1 ) );
+        if( (int)*stb->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
+            (int)*stb->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
+            (int)*stb->zFeld( i, 5 ) == (int)*opd->zWert( "Größe" ) &&
+            (int)*stb->zFeld( i, 4 ) == (int)*opd->zWert( "Timer" ) &&
+            (int)*stb->zFeld( i, 6 ) == (int)*opd->zWert( "Ship" ) )
+        {
+            optionenD->addPunkt( 0, j, (int)*stb->zFeld( i, 1 ) );
+            j++;
+        }
+    }
+    stb->release();
+    opd->release();
+    beendet = 0;
 }
 
 void MenüStatistik::doMausEreignis( MausEreignis &me )
 {
-	ansicht->doMausEreignis( me );
-	optionen->doMausEreignis( me );
-	bool vera = me.verarbeitet;
-	remove->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-	{ // Statistik remove
-		if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
-		{ // nur bestimmte Statistik remove
-			InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-			opd->laden();
-			KSGTDatei *score = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
-			score->laden();
-			int zeilen = score->getZeilenAnzahl();
-			for( int i = 0; i < zeilen; i++ )
-			{
-				if( (int)*score->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
-					(int)*score->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
-					(int)*score->zFeld( i, 5 ) == (int)*opd->zWert( "Größe" ) &&
-					(int)*score->zFeld( i, 4 ) == (int)*opd->zWert( "Timer" ) &&
-					(int)*score->zFeld( i, 6 ) == (int)*opd->zWert( "Ship" ) )
-				{
-					score->removeZeile( i );
-					i--;
-					zeilen--;
-				}
-			}
-			score->speichern();
-			score->release();
-			opd->release();
-		}
-		else // alles remove
-			DateiRemove( "data/Minigames/Asteroids/data/score.ksgt" );
-		reset();
-	}
-	vera = me.verarbeitet;
-	zurück->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-		beendet = 1;
+    if( wiederH )
+    {
+        wiederH->doMausEreignis( me );
+        return;
+    }
+    ansicht->doMausEreignis( me );
+    optionen->doMausEreignis( me );
+    gesammtT->doMausEreignis( me );
+    optionenT->doMausEreignis( me );
+    worldBestT->doMausEreignis( me );
+    bool vera = me.verarbeitet;
+    remove->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+    { // Statistik remove
+        if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
+        { // nur bestimmte Statistik remove
+            InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
+            opd->laden();
+            KSGTDatei *score = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
+            score->laden();
+            int zeilen = score->getZeilenAnzahl();
+            for( int i = 0; i < zeilen; i++ )
+            {
+                if( (int)*score->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
+                    (int)*score->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
+                    (int)*score->zFeld( i, 5 ) == (int)*opd->zWert( "Größe" ) &&
+                    (int)*score->zFeld( i, 4 ) == (int)*opd->zWert( "Timer" ) &&
+                    (int)*score->zFeld( i, 6 ) == (int)*opd->zWert( "Ship" ) )
+                {
+                    score->removeZeile( i );
+                    i--;
+                    zeilen--;
+                }
+            }
+            score->speichern();
+            score->release();
+            opd->release();
+        }
+        else // alles remove
+            DateiRemove( "data/Minigames/Asteroids/data/score.ksgt" );
+        reset();
+    }
+    vera = me.verarbeitet;
+    zurück->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+        beendet = 1;
 }
 
 bool MenüStatistik::tick( double tickVal )
 {
-	bool ret = ansicht->tick( tickVal );
-	ret |= optionen->tick( tickVal );
-	ret |= remove->tick( tickVal );
-	ret |= zurück->tick( tickVal );
-	ret |= gesammtT->tick( tickVal );
-	ret |= optionenT->tick( tickVal );
-	ret |= gesammtD->tick( tickVal );
-	ret |= optionenD->tick( tickVal );
-	return ret;
+    if( wiederH )
+    {
+        bool ret = wiederH->tick( tickVal );
+        if( wiederH->istBeendet() )
+            wiederH = wiederH->release();
+        return ret;
+    }
+    bool ret = ansicht->tick( tickVal );
+    ret |= optionen->tick( tickVal );
+    ret |= remove->tick( tickVal );
+    ret |= zurück->tick( tickVal );
+    ret |= gesammtT->tick( tickVal );
+    ret |= optionenT->tick( tickVal );
+    ret |= gesammtD->tick( tickVal );
+    ret |= optionenD->tick( tickVal );
+    ret |= worldBestT->tick( tickVal );
+    return ret;
 }
 
 void MenüStatistik::render( Bild &zRObj )
 {
-	if( !ansicht->getAuswahl() )
-	{
-		if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
-			optionenT->render( zRObj );
-		else
-			gesammtT->render( zRObj );
-	}
-	else
-	{
-		if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
-			optionenD->render( zRObj );
-		else
-			gesammtD->render( zRObj );
-	}
-	ansichtT->render( zRObj );
-	ansicht->render( zRObj );
-	optionen->render( zRObj );
-	remove->render( zRObj );
-	zurück->render( zRObj );
+    if( wiederH )
+    {
+        wiederH->render( zRObj );
+        return;
+    }
+    schrift->setSchriftSize( 12 );
+    Text weltScore = "Welt Score:";
+    schrift->setDrawPosition( 10, 40 );
+    schrift->renderText( &weltScore, zRObj, 0xFFFFFFFF );
+    Text localScore = "Dein Score:";
+    schrift->setDrawPosition( 10, 170 );
+    schrift->renderText( &localScore, zRObj, 0xFFFFFFFF );
+    worldBestT->render( zRObj );
+    if( !ansicht->getAuswahl() )
+    {
+        if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
+            optionenT->render( zRObj );
+        else
+            gesammtT->render( zRObj );
+    }
+    else
+    {
+        if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
+            optionenD->render( zRObj );
+        else
+            gesammtD->render( zRObj );
+    }
+    ansichtT->render( zRObj );
+    ansicht->render( zRObj );
+    optionen->render( zRObj );
+    remove->render( zRObj );
+    zurück->render( zRObj );
 }
 
 // constant
 bool MenüStatistik::istBeendet() const
 {
-	return beendet;
+    return beendet;
+}
+
+bool MenüStatistik::istWiederhohlung() const
+{
+    return wiederH != 0;
 }
 
 // Reference Counting
 MenüStatistik *MenüStatistik::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 MenüStatistik *MenüStatistik::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
@@ -485,394 +831,395 @@ Men
 // Konstruktor
 MenüOptionen::MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen )
 {
-	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, "" );
-	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ö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öß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, "" );
-	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" } );
-	fortsetzen = initKontrollKnopf( 310, 320, 180, 20, zSchrift, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
-	abbrechen = initKnopf( 310, 360, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
-	ok = initKnopf( 405, 360, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Ok" );
-	beendet = 0;
-	ref = 1;
+    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, "" );
+    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ö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öß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, "" );
+    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" } );
+    fortsetzen = initKontrollKnopf( 310, 320, 180, 20, zSchrift, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
+    abbrechen = initKnopf( 310, 360, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
+    ok = initKnopf( 405, 360, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Ok" );
+    beendet = 0;
+    ref = 1;
 }
 
 // Destruktor
 MenüOptionen::~MenüOptionen()
 {
-	breiteT->release();
-	breite->release();
-	höheT->release();
-	höhe->release();
-	aGrößeT->release();
-	aGröße->release();
-	timerT->release();
-	timer->release();
-	shipT->release();
-	ship->release();
-	fortsetzen->release();
-	abbrechen->release();
-	ok->release();
+    breiteT->release();
+    breite->release();
+    höheT->release();
+    höhe->release();
+    aGrößeT->release();
+    aGröße->release();
+    timerT->release();
+    timer->release();
+    shipT->release();
+    ship->release();
+    fortsetzen->release();
+    abbrechen->release();
+    ok->release();
 }
 
 // nicht constant
 void MenüOptionen::reset()
 {
-	InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-	if( !opd->laden() )
-		DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
-	breite->setText( "800" );
-	if( opd->wertExistiert( "Breite" ) )
-		breite->setText( Text() += (int)*opd->zWert( "Breite" ) );
-	else
-		opd->addWert( "Breite", "800" );
-	höhe->setText( "500" );
-	if( opd->wertExistiert( "Höhe" ) )
-		höhe->setText( Text() += (int)*opd->zWert( "Höhe" ) );
-	else
-		opd->addWert( "Höhe", "500" );
-	aGröße->setText( "1000" );
-	if( opd->wertExistiert( "Größe" ) )
-		aGröße->setText( Text() += (int)*opd->zWert( "Größe" ) );
-	else
-		opd->addWert( "Größe", "1000" );
-	timer->setText( "5000" );
-	if( opd->wertExistiert( "Timer" ) )
-		timer->setText( Text() += (int)*opd->zWert( "Timer" ) );
-	else
-		opd->addWert( "Timer", "5000" );
-	ship->setAuswahl( 0 );
-	if( opd->wertExistiert( "Ship" ) )
-		ship->setAuswahl( *opd->zWert( "Ship" ) );
-	else
-		opd->addWert( "Ship", "0" );
-	fortsetzen->removeStyle( KontrollKnopf::Style::Selected );
-	if( opd->wertExistiert( "Fortsetzen" ) )
-		fortsetzen->setStyle( KontrollKnopf::Style::Selected, (int)*opd->zWert( "Fortsetzen" ) != 0 );
-	else
-		opd->addWert( "Fortsetzen", "0" );
-	beendet = 0;
-	opd->speichern();
-	opd->release();
+    InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
+    if( !opd->laden() )
+        DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
+    breite->setText( "800" );
+    if( opd->wertExistiert( "Breite" ) )
+        breite->setText( Text() += (int)*opd->zWert( "Breite" ) );
+    else
+        opd->addWert( "Breite", "800" );
+    höhe->setText( "500" );
+    if( opd->wertExistiert( "Höhe" ) )
+        höhe->setText( Text() += (int)*opd->zWert( "Höhe" ) );
+    else
+        opd->addWert( "Höhe", "500" );
+    aGröße->setText( "1000" );
+    if( opd->wertExistiert( "Größe" ) )
+        aGröße->setText( Text() += (int)*opd->zWert( "Größe" ) );
+    else
+        opd->addWert( "Größe", "1000" );
+    timer->setText( "5000" );
+    if( opd->wertExistiert( "Timer" ) )
+        timer->setText( Text() += (int)*opd->zWert( "Timer" ) );
+    else
+        opd->addWert( "Timer", "5000" );
+    ship->setAuswahl( 0 );
+    if( opd->wertExistiert( "Ship" ) )
+        ship->setAuswahl( *opd->zWert( "Ship" ) );
+    else
+        opd->addWert( "Ship", "0" );
+    fortsetzen->removeStyle( KontrollKnopf::Style::Selected );
+    if( opd->wertExistiert( "Fortsetzen" ) )
+        fortsetzen->setStyle( KontrollKnopf::Style::Selected, (int)*opd->zWert( "Fortsetzen" ) != 0 );
+    else
+        opd->addWert( "Fortsetzen", "0" );
+    beendet = 0;
+    opd->speichern();
+    opd->release();
 }
 
 void MenüOptionen::doMausEreignis( MausEreignis &me )
 {
-	breite->doMausEreignis( me );
-	höhe->doMausEreignis( me );
-	aGröße->doMausEreignis( me );
-	timer->doMausEreignis( me );
-	ship->doMausEreignis( me );
-	fortsetzen->doMausEreignis( me );
-	bool vera = me.verarbeitet;
-	abbrechen->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-		beendet = 1;
-	vera = me.verarbeitet;
-	ok->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-	{
-		InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-		if( !opd->laden() )
-			DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
-		if( (int)*breite->zText() > 10000 )
-			breite->setText( "10000" );
-		if( (int)*breite->zText() < 800 )
-			breite->setText( "80" );
-		if( opd->wertExistiert( "Breite" ) )
-			opd->setWert( "Breite", Text() += (int)*breite->zText() );
-		else
-			opd->addWert( "Breite", Text() += (int)*breite->zText() );
-		if( (int)*höhe->zText() > 10000 )
-			höhe->setText( "10000" );
-		if( (int)*höhe->zText() < 500 )
-			höhe->setText( "500" );
-		if( opd->wertExistiert( "Höhe" ) )
-			opd->setWert( "Höhe", Text() += (int)*höhe->zText() );
-		else
-			opd->addWert( "Höhe", Text() += (int)*höhe->zText() );
-		if( (int)*aGröße->zText() > 10000 )
-			aGröße->setText( "10000" );
-		if( (int)*aGröße->zText() < 10 )
-			aGröße->setText( "10" );
-		if( opd->wertExistiert( "Größe" ) )
-			opd->setWert( "Größe", Text() += (int)*aGröße->zText() );
-		else
-			opd->addWert( "Größe", Text() += (int)*aGröße->zText() );
-		if( (int)*timer->zText() < 500 )
-			timer->setText( "500" );
-		if( opd->wertExistiert( "Timer" ) )
-			opd->setWert( "Timer", Text() += (int)*timer->zText() );
-		else
-			opd->addWert( "Timer", Text() += (int)*timer->zText() );
-		if( opd->wertExistiert( "Ship" ) )
-			opd->setWert( "Ship", Text() += ship->getAuswahl() );
-		else
-			opd->addWert( "Ship", Text() += ship->getAuswahl() );
-		if( opd->wertExistiert( "Fortsetzen" ) )
-			opd->setWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
-		else
-			opd->addWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
-		opd->speichern();
-		opd->release();
-		beendet = 1;
-	}
+    breite->doMausEreignis( me );
+    höhe->doMausEreignis( me );
+    aGröße->doMausEreignis( me );
+    timer->doMausEreignis( me );
+    ship->doMausEreignis( me );
+    fortsetzen->doMausEreignis( me );
+    bool vera = me.verarbeitet;
+    abbrechen->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+        beendet = 1;
+    vera = me.verarbeitet;
+    ok->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+    {
+        InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
+        if( !opd->laden() )
+            DateiPfadErstellen( "data/Minigames/Asteroids/data/optionen.ini" );
+        if( (int)*breite->zText() > 10000 )
+            breite->setText( "10000" );
+        if( (int)*breite->zText() < 800 )
+            breite->setText( "80" );
+        if( opd->wertExistiert( "Breite" ) )
+            opd->setWert( "Breite", Text() += (int)*breite->zText() );
+        else
+            opd->addWert( "Breite", Text() += (int)*breite->zText() );
+        if( (int)*höhe->zText() > 10000 )
+            höhe->setText( "10000" );
+        if( (int)*höhe->zText() < 500 )
+            höhe->setText( "500" );
+        if( opd->wertExistiert( "Höhe" ) )
+            opd->setWert( "Höhe", Text() += (int)*höhe->zText() );
+        else
+            opd->addWert( "Höhe", Text() += (int)*höhe->zText() );
+        if( (int)*aGröße->zText() > 10000 )
+            aGröße->setText( "10000" );
+        if( (int)*aGröße->zText() < 10 )
+            aGröße->setText( "10" );
+        if( opd->wertExistiert( "Größe" ) )
+            opd->setWert( "Größe", Text() += (int)*aGröße->zText() );
+        else
+            opd->addWert( "Größe", Text() += (int)*aGröße->zText() );
+        if( (int)*timer->zText() < 500 )
+            timer->setText( "500" );
+        if( opd->wertExistiert( "Timer" ) )
+            opd->setWert( "Timer", Text() += (int)*timer->zText() );
+        else
+            opd->addWert( "Timer", Text() += (int)*timer->zText() );
+        if( opd->wertExistiert( "Ship" ) )
+            opd->setWert( "Ship", Text() += ship->getAuswahl() );
+        else
+            opd->addWert( "Ship", Text() += ship->getAuswahl() );
+        if( opd->wertExistiert( "Fortsetzen" ) )
+            opd->setWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
+        else
+            opd->addWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
+        opd->speichern();
+        opd->release();
+        beendet = 1;
+    }
 }
 
 void MenüOptionen::doTastaturEreignis( TastaturEreignis &te )
 {
-	breite->doTastaturEreignis( te );
-	höhe->doTastaturEreignis( te );
-	aGröße->doTastaturEreignis( te );
-	timer->doTastaturEreignis( te );
+    breite->doTastaturEreignis( te );
+    höhe->doTastaturEreignis( te );
+    aGröße->doTastaturEreignis( te );
+    timer->doTastaturEreignis( te );
 }
 
 bool MenüOptionen::tick( double tickVal )
 {
-	bool ret = breite->tick( tickVal );
-	ret |= höhe->tick( tickVal );
-	ret |= aGröße->tick( tickVal );
-	ret |= timer->tick( tickVal );
-	ret |= ship->tick( tickVal );
-	ret |= fortsetzen->tick( tickVal );
-	ret |= abbrechen->tick( tickVal );
-	ret |= ok->tick( tickVal );
-	return ret;
+    bool ret = breite->tick( tickVal );
+    ret |= höhe->tick( tickVal );
+    ret |= aGröße->tick( tickVal );
+    ret |= timer->tick( tickVal );
+    ret |= ship->tick( tickVal );
+    ret |= fortsetzen->tick( tickVal );
+    ret |= abbrechen->tick( tickVal );
+    ret |= ok->tick( tickVal );
+    return ret;
 }
 
 void MenüOptionen::render( Bild &zRObj )
 {
-	breiteT->render( zRObj );
-	breite->render( zRObj );
-	höheT->render( zRObj );
-	höhe->render( zRObj );
-	aGrößeT->render( zRObj );
-	aGröße->render( zRObj );
-	timerT->render( zRObj );
-	timer->render( zRObj );
-	shipT->render( zRObj );
-	fortsetzen->render( zRObj );
-	abbrechen->render( zRObj );
-	ok->render( zRObj );
-	ship->render( zRObj );
+    breiteT->render( zRObj );
+    breite->render( zRObj );
+    höheT->render( zRObj );
+    höhe->render( zRObj );
+    aGrößeT->render( zRObj );
+    aGröße->render( zRObj );
+    timerT->render( zRObj );
+    timer->render( zRObj );
+    shipT->render( zRObj );
+    fortsetzen->render( zRObj );
+    abbrechen->render( zRObj );
+    ok->render( zRObj );
+    ship->render( zRObj );
 }
 
 // constant
 bool MenüOptionen::istBeendet() const
 {
-	return beendet;
+    return beendet;
 }
 
 // Reference Counting
 MenüOptionen *MenüOptionen::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 MenüOptionen *MenüOptionen::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
 // Inhalt der Menü Klasse aus Menü.h
 // Konstruktor
-Menü::Menü( Schrift *zSchrift, Bildschirm *zScreen )
-{
-	spielen = initKnopf( 350, 180, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Spielen" );
-	spielenF = new MenüSpiel( zSchrift, zScreen );
-	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 );
-	beenden = initKnopf( 350, 300, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
-	ram = new LRahmen();
-	ram->setFarbe( 0xFFFFFFFF );
-	beendet = 0;
-	status = 0;
-	LTDBDatei *bgd = new LTDBDatei();
-	bgd->setDatei( new Text( "data/Minigames/Asteroids/bilder/hintergrund.ltdb" ) );
-	bgd->leseDaten( 0 );
-	hintergrund = bgd->laden( 0, new Text( "bg.jpg" ) );
-	bgd->release();
-	ref = 1;
+Menü::Menü( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient )
+{
+    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" );
+    ram = new LRahmen();
+    ram->setFarbe( 0xFFFFFFFF );
+    beendet = 0;
+    status = 0;
+    LTDBDatei *bgd = new LTDBDatei();
+    bgd->setDatei( new Text( "data/Minigames/Asteroids/bilder/hintergrund.ltdb" ) );
+    bgd->leseDaten( 0 );
+    hintergrund = bgd->laden( 0, new Text( "bg.jpg" ) );
+    bgd->release();
+    ref = 1;
 }
 
 // Destruktor
 Menü::~Menü()
 {
-	spielen->release();
-	spielenF->release();
-	optionen->release();
-	optionenF->release();
-	statistik->release();
-	statistikF->release();
-	beenden->release();
-	if( hintergrund )
-		hintergrund->release();
-	ram->release();
+    spielen->release();
+    spielenF->release();
+    optionen->release();
+    optionenF->release();
+    statistik->release();
+    statistikF->release();
+    beenden->release();
+    if( hintergrund )
+        hintergrund->release();
+    ram->release();
 }
 
 // nicht constant
 void Menü::reset()
 {
-	status = 0;
-	beendet = 0;
+    status = 0;
+    beendet = 0;
 }
 
 void Menü::doMausEreignis( MausEreignis &me )
 {
-	switch( status )
-	{
-	case 0:
-		if( 1 )
-		{
-			bool vera = me.verarbeitet;
-			spielen->doMausEreignis( me );
-			if( !vera && me.verarbeitet && me.id == ME_RLinks )
-			{
-				spielenF->reset();
-				status = 3;
-			}
-			vera = me.verarbeitet;
-			optionen->doMausEreignis( me );
-			if( !vera && me.verarbeitet && me.id == ME_RLinks )
-			{
-				optionenF->reset();
-				status = 1;
-			}
-			vera = me.verarbeitet;
-			statistik->doMausEreignis( me );
-			if( !vera && me.verarbeitet && me.id == ME_RLinks )
-			{
-				statistikF->reset();
-				status = 2;
-			}
-			vera = me.verarbeitet;
-			beenden->doMausEreignis( me );
-			if( !vera && me.verarbeitet && me.id == ME_RLinks )
-				beendet = 1;
-		}
-		break;
-	case 1:
-		optionenF->doMausEreignis( me );
-		break;
-	case 2:
-		statistikF->doMausEreignis( me );
-		break;
-	case 3:
-		spielenF->doMausEreignis( me );
-	}
+    switch( status )
+    {
+    case 0:
+        if( 1 )
+        {
+            bool vera = me.verarbeitet;
+            spielen->doMausEreignis( me );
+            if( !vera && me.verarbeitet && me.id == ME_RLinks )
+            {
+                spielenF->reset();
+                status = 3;
+            }
+            vera = me.verarbeitet;
+            optionen->doMausEreignis( me );
+            if( !vera && me.verarbeitet && me.id == ME_RLinks )
+            {
+                optionenF->reset();
+                status = 1;
+            }
+            vera = me.verarbeitet;
+            statistik->doMausEreignis( me );
+            if( !vera && me.verarbeitet && me.id == ME_RLinks )
+            {
+                statistikF->reset();
+                status = 2;
+            }
+            vera = me.verarbeitet;
+            beenden->doMausEreignis( me );
+            if( !vera && me.verarbeitet && me.id == ME_RLinks )
+                beendet = 1;
+        }
+        break;
+    case 1:
+        optionenF->doMausEreignis( me );
+        break;
+    case 2:
+        statistikF->doMausEreignis( me );
+        break;
+    case 3:
+        spielenF->doMausEreignis( me );
+    }
 }
 
 void Menü::doTastaturEreignis( TastaturEreignis &te )
 {
-	if( status == 1 )
-		optionenF->doTastaturEreignis( te );
-	if( status == 3 )
-		spielenF->doTastaturEreignis( te );
+    if( status == 1 )
+        optionenF->doTastaturEreignis( te );
+    if( status == 3 )
+        spielenF->doTastaturEreignis( te );
 }
 
 bool Menü::tick( double z )
 {
-	switch( status )
-	{
-	case 0:
-		if( 1 )
-		{
-			bool ret = spielen->tick( z );
-			ret |= statistik->tick( z );
-			ret |= optionen->tick( z );
-			ret |= beenden->tick( z );
-			return ret;
-		}
-	case 1:
-		if( optionenF->istBeendet() )
-		{
-			status = 0;
-			return 1;
-		}
-		return optionenF->tick( z );
-	case 2:
-		if( statistikF->istBeendet() )
-		{
-			status = 0;
-			return 1;
-		}
-		return statistikF->tick( z );
-	case 3:
-		if( spielenF->istBeendet() )
-		{
-			status = 0;
-			return 1;
-		}
-		return spielenF->tick( z );
-	}
-	return 0;
+    switch( status )
+    {
+    case 0:
+        if( 1 )
+        {
+            bool ret = spielen->tick( z );
+            ret |= statistik->tick( z );
+            ret |= optionen->tick( z );
+            ret |= beenden->tick( z );
+            return ret;
+        }
+    case 1:
+        if( optionenF->istBeendet() )
+        {
+            status = 0;
+            return 1;
+        }
+        return optionenF->tick( z );
+    case 2:
+        if( statistikF->istBeendet() )
+        {
+            status = 0;
+            return 1;
+        }
+        return statistikF->tick( z );
+    case 3:
+        if( spielenF->istBeendet() )
+        {
+            status = 0;
+            return 1;
+        }
+        return spielenF->tick( z );
+    }
+    return 0;
 }
 
 void Menü::render( Bild &zRObj )
 {
-	if( status != 3 )
-		zRObj.drawBild( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), *hintergrund );
-	switch( status )
-	{
-	case 0:
-		ram->setPosition( 300, 170 );
-		ram->setSize( 200, 160 );
-		zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
-		ram->render( zRObj );
-		spielen->render( zRObj );
-		statistik->render( zRObj );
-		optionen->render( zRObj );
-		beenden->render( zRObj );
-		break;
-	case 1:
-		ram->setPosition( 300, 110 );
-		ram->setSize( 200, 280 );
-		zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
-		ram->render( zRObj );
-		optionenF->render( zRObj );
-		break;
-	case 2:
-		zRObj.alphaRegion( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), 0xD0000000 );
-		statistikF->render( zRObj );
-		break;
-	case 3:
-		spielenF->render( zRObj );
-	}
+    if( status != 3 && ( status != 2 || !statistikF->istWiederhohlung() ) )
+        zRObj.drawBild( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), *hintergrund );
+    switch( status )
+    {
+    case 0:
+        ram->setPosition( 300, 170 );
+        ram->setSize( 200, 160 );
+        zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
+        ram->render( zRObj );
+        spielen->render( zRObj );
+        statistik->render( zRObj );
+        optionen->render( zRObj );
+        beenden->render( zRObj );
+        break;
+    case 1:
+        ram->setPosition( 300, 110 );
+        ram->setSize( 200, 280 );
+        zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
+        ram->render( zRObj );
+        optionenF->render( zRObj );
+        break;
+    case 2:
+        if( !statistikF->istWiederhohlung() )
+            zRObj.alphaRegion( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), 0xD0000000 );
+        statistikF->render( zRObj );
+        break;
+    case 3:
+        spielenF->render( zRObj );
+    }
 }
 
 // constant
 bool Menü::istBeendet() const
 {
-	return beendet;
+    return beendet;
 }
 
 // Reference Counting
 Menü *Menü::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Menü *Menü::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Asteroids/Menü.h

@@ -39,12 +39,13 @@ private:
 	Knopf *beenden;
 	Map *map;
 	MenüVerloren *verloren;
+    double timePuffer;
 	bool beendet;
 	int ref;
 
 public:
 	// Konstruktor
-	MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen );
+	MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient );
 	// Destruktor
 	~MenüSpiel();
 	// nicht constant
@@ -60,6 +61,37 @@ public:
 	MenüSpiel *release();
 };
 
+class MenüWiederhohlung
+{
+private:
+    TextFeld *scoreT;
+    Knopf *beenden;
+    Map *map;
+    Datei *datei;
+    double nowTime;
+    double nextTime;
+    bool beendet;
+    char tastenStände;
+    double timePuffer;
+    int ref;
+
+public:
+    // Konstruktor
+    MenüWiederhohlung( Schrift *zSchrift, Bildschirm *zScreen, Datei *datei, Text *zOptionen );
+    // Destruktor
+    ~MenüWiederhohlung();
+    // nicht constant
+    void doMausEreignis( MausEreignis &me );
+    void doTastaturEreignis( TastaturEreignis &te );
+    bool tick( double tickVal );
+    void render( Bild &zRObj );
+    // constant
+    bool istBeendet() const;
+    // Reference Counting
+    MenüWiederhohlung *getThis();
+    MenüWiederhohlung *release();
+};
+
 class MenüStatistik
 {
 private:
@@ -68,17 +100,22 @@ private:
 	KontrollKnopf *optionen;
 	ObjTabelle *gesammtT;
 	ObjTabelle *optionenT;
+    ObjTabelle *worldBestT;
 	LDiag *gesammtD;
 	LDiag *optionenD;
 	Knopf *remove;
 	Knopf *zurück;
 	Schrift *schrift;
+    MinigameKlientV *klient;
+    MenüWiederhohlung *wiederH;
+    Bildschirm *screen;
+    bool asyncFinished;
 	bool beendet;
 	int ref = 1;
 
 public:
 	// Konstruktor
-	MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen );
+	MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient );
 	// Destruktor
 	~MenüStatistik();
 	// nicht constant
@@ -88,6 +125,7 @@ public:
 	void render( Bild &zRObj );
 	// constant
 	bool istBeendet() const;
+    bool istWiederhohlung() const;
 	// Reference Counting
 	MenüStatistik *getThis();
 	MenüStatistik *release();
@@ -148,7 +186,7 @@ private:
 
 public:
 	// Konstruktor
-	Menü( Schrift *zSchrift, Bildschirm *zScreen );
+	Menü( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient );
 	// Destruktor
 	~Menü();
 	// nicht constant

Asteroids/Ship.cpp

@@ -5,6 +5,7 @@
 #include <FrameworkMath.h>
 #include "Schuss.h"
 #include "Asteroid.h"
+#include <iostream>
 
 // Inhalt der Ship Klasse aus Ship.h
 // Konstruktor
@@ -27,41 +28,41 @@ Ship::~Ship()
 }
 
 // nicht constant
-bool Ship::tick( double zeit, int breite, int höhe )
+bool Ship::tick( double zeit, int breite, int höhe, char tastenStände )
 {
 	Vertex minP = (Vertex)ship->zModel()->minP * ship->getSize() + ship->getPosition();
 	Vertex maxP = (Vertex)ship->zModel()->maxP * ship->getSize() + ship->getPosition();
 	if( maxP.x < 0 && speed.x < 0 )
-		pos.x = breite + ship->zModel()->maxP.x * ship->getSize();
+		pos.x += breite + ship->zModel()->maxP.x * ship->getSize();
 	if( maxP.y < 0 && speed.y < 0 )
-		pos.y = höhe + ship->zModel()->maxP.y * ship->getSize();
+        pos.y += höhe + ship->zModel()->maxP.y * ship->getSize();
 	if( minP.x > breite && speed.x > 0 )
-		pos.x = 0 - ship->zModel()->maxP.x * ship->getSize();
+		pos.x -= breite + ship->zModel()->maxP.x * ship->getSize();
 	if( minP.y > höhe && speed.y > 0 )
-		pos.y = 0 - ship->zModel()->maxP.y * ship->getSize();
+		pos.y -= höhe + ship->zModel()->maxP.y * ship->getSize();
 	ship->setPosition( pos );
-	if( getTastenStand( T_Oben ) || getTastenStand( 'w' ) || getTastenStand( 'W' ) )
+	if( ( tastenStände | 1 ) == tastenStände )
 	{
-		speed.x += (float)( 4.2 * cos( ship->getDrehung() ) );
-		speed.y += (float)( 4.2 * sin( ship->getDrehung() ) );
+		speed.x += (float)( 4.2 * cos( ship->getDrehung() ) ) * (float)zeit * 30;
+		speed.y += (float)( 4.2 * sin( ship->getDrehung() ) ) * (float)zeit * 30;
 	}
 	else
 	{
 		float movementAngle = atan2( speed.y, speed.x );
 		if( speed.x != 0 )
-			speed.x += 1.2f * cos( movementAngle + (float)PI );
+			speed.x += 1.2f * cos( movementAngle + (float)PI ) * (float)zeit * 30;
 		if( speed.y != 0 )
-			speed.y += 1.2f * sin( movementAngle + (float)PI );
+			speed.y += 1.2f * sin( movementAngle + (float)PI ) * (float)zeit * 30;
 		if( speed.x < 6.f && speed.x > -6.f )
 			speed.x = 0;
 		if( speed.y < 6.f && speed.y > -6.f )
 			speed.y = 0;
 	}
-	if( !getTastenStand( T_Space ) )
+	if( ( tastenStände | 8 ) != tastenStände )
 	{
-		if( getTastenStand( T_Rechts ) || getTastenStand( 'd' ) || getTastenStand( 'D' ) )
+		if( ( tastenStände | 2 ) == tastenStände )
 			ship->addDrehung( (float)zeit * 2 );
-		if( getTastenStand( T_Links ) || getTastenStand( 'a' ) || getTastenStand( 'A' ) )
+		if( ( tastenStände | 4 ) == tastenStände )
 			ship->addDrehung( (float)-zeit * 2 );
 	}
 	if( speed.x || speed.y )

Asteroids/Ship.h

@@ -23,7 +23,7 @@ public:
 	// Destruktor
 	~Ship();
 	// nicht constant
-	bool tick( double zeit, int breite, int höhe );
+	bool tick( double zeit, int breite, int höhe, char tastenStände );
 	void render( Bild &zRObj );
 	// constant
 	void save( Datei *zD ) const;