framework changes

Asteroids/Data.cpp

@@ -3,263 +3,263 @@
 #include <Textur2D.h>
 
 // Konstructor
-GameData::GameData( const char *shipM2, const char *asteroidsM2 )
-    : ReferenceCounter()
+GameData::GameData(const char* shipM2, const char* asteroidsM2)
+	: ReferenceCounter()
 {
-    world = new Welt2D();
-    //world->setAirResistance( 0.01f );
-    schuss = new RCArray< Schuss >();
-    ship = 0;
-    asteroid = new RCArray< Asteroid >();
-    aData = new Model2DData * [ 7 ]();
-    sData = new Model2DData * [ 2 ]();
-    M2Datei m2d( asteroidsM2 );
-    m2d.leseDaten();
-    for( int i = 0; i < 7; i++ )
-    {
-        Text name = "";
-        name.append( (char)( 'a' + i ) );
-        aData[ i ] = m2d.ladeModel( name );
-    }
-    m2d.setPfad( shipM2 );
-    m2d.leseDaten();
-    for( int i = 0; i < 2; i++ )
-    {
-        Text name = "";
-        name.append( (char)( 'a' + i ) );
-        sData[ i ] = m2d.ladeModel( name );
-    }
-    shipN = 0;
-    score = 0;
-    scoreCheck = score * 11197;
-    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;
+	world = new Welt2D();
+	//world->setAirResistance( 0.01f );
+	schuss = new RCArray< Schuss >();
+	ship = 0;
+	asteroid = new RCArray< Asteroid >();
+	aData = new Model2DData * [7]();
+	sData = new Model2DData * [2]();
+	M2Datei m2d(asteroidsM2);
+	m2d.leseDaten();
+	for (int i = 0; i < 7; i++)
+	{
+		Text name = "";
+		name.append((char)('a' + i));
+		aData[i] = m2d.ladeModel(name);
+	}
+	m2d.setPfad(shipM2);
+	m2d.leseDaten();
+	for (int i = 0; i < 2; i++)
+	{
+		Text name = "";
+		name.append((char)('a' + i));
+		sData[i] = m2d.ladeModel(name);
+	}
+	shipN = 0;
+	score = 0;
+	scoreCheck = score * 11197;
+	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;
 }
 
 // Destructor
 GameData::~GameData()
 {
-    schuss->release();
-    if( ship )
-        ship->release();
-    asteroid->release();
-    for( int i = 0; i < 7; i++ )
-        aData[ i ]->release();
-    for( int i = 0; i < 2; i++ )
-        sData[ i ]->release();
-    delete[] aData;
-    delete[] sData;
-    if( rGen )
-        rGen->release();
-    world->release();
+	schuss->release();
+	if (ship)
+		ship->release();
+	asteroid->release();
+	for (int i = 0; i < 7; i++)
+		aData[i]->release();
+	for (int i = 0; i < 2; i++)
+		sData[i]->release();
+	delete[] aData;
+	delete[] sData;
+	if (rGen)
+		rGen->release();
+	world->release();
 }
 
 // private
-Asteroid *GameData::createNewAsteroid()
+Asteroid* GameData::createNewAsteroid()
 {
-    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( (float)rGen->rand() * breite, (float)rGen->rand() * höhe );
-    if( ( ship->getPosition() - Vertex( (float)world->getWorldInfo().size.x, 0 ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() + Vertex( (float)world->getWorldInfo().size.x, 0 ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() - Vertex( 0, (float)world->getWorldInfo().size.y ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() + Vertex( 0, (float)world->getWorldInfo().size.y ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() - Vertex( (float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() + Vertex( (float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() + Vertex( (float)world->getWorldInfo().size.x, -(float)world->getWorldInfo().size.y ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() + Vertex( -(float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y ) - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 &&
-        ( ship->getPosition() - pos ).getLength() > world->getWorldInfo().size.getLength() / 3 )
-    {
-        if( speed.x < 0 )
-            pos.x = (float)( breite + 200 );
-        Asteroid *ast = new Asteroid( dynamic_cast<Model2DData *>( aData[ num ]->getThis() ), 0, pos, speed, (float)( rGen->rand() * 100 ) / 75.f, (float)sw, aGröße / 1000.f, num );
-        int aAnz = asteroid->getEintragAnzahl();
-        for( int i = 0; i < aAnz; i++ )
-        {
-            if( ast->istModelInnen( asteroid->z( i ) ) )
-            {
-                ast->release();
-                return 0;
-            }
-        }
-        return ast;
-    }
-    return 0;
+	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((float)rGen->rand() * breite, (float)rGen->rand() * höhe);
+	if ((ship->getPosition() - Vertex((float)world->getWorldInfo().size.x, 0) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() + Vertex((float)world->getWorldInfo().size.x, 0) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() - Vertex(0, (float)world->getWorldInfo().size.y) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() + Vertex(0, (float)world->getWorldInfo().size.y) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() - Vertex((float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() + Vertex((float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() + Vertex((float)world->getWorldInfo().size.x, -(float)world->getWorldInfo().size.y) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() + Vertex(-(float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y) - pos).getLength() > world->getWorldInfo().size.getLength() / 3 &&
+		(ship->getPosition() - pos).getLength() > world->getWorldInfo().size.getLength() / 3)
+	{
+		if (speed.x < 0)
+			pos.x = (float)(breite + 200);
+		Asteroid* ast = new Asteroid(dynamic_cast<Model2DData*>(aData[num]->getThis()), 0, pos, speed, (float)(rGen->rand() * 100) / 75.f, (float)sw, aGröße / 1000.f, num);
+		int aAnz = asteroid->getEintragAnzahl();
+		for (int i = 0; i < aAnz; i++)
+		{
+			if (ast->istModelInnen(asteroid->z(i)))
+			{
+				ast->release();
+				return 0;
+			}
+		}
+		return ast;
+	}
+	return 0;
 }
 
 // nicht constant
-void GameData::reset( Text *zOptionen )
+void GameData::reset(Text* zOptionen)
 {
-    gameTime = 0;
-    timer = 0;
-    beendet = 0;
-    score = 0;
-    scoreCheck = score * 11197;
-    tastenStände = 0;
-    if( ship )
-        ship = (Ship *)ship->release();
-    world->removeAll();
-    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();
-    Vec2< float > shipPos( (float)( breite / 2 ), (float)( höhe / 2 ) );
-    Vec2< float > shipSpeed( 0, 0 );
-    float shipR = (float)-PI / 2;
-    if( rGen )
-        rGen = (RandomGenerator *)rGen->release();
-    rGen = new RandomGenerator();
-    if( zOptionen->positionVon( '=', 7 ) >= 0 )
-    {
-        tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 7 ) + 1 );
-        rGen->setSeed( (__int64)*tmp );
-        tmp->release();
-    }
-    ship = new Ship( dynamic_cast<Model2DData *>( sData[ shipN ]->getThis() ), shipPos, shipSpeed, shipR );
-    world->addObject( ship );
+	gameTime = 0;
+	timer = 0;
+	beendet = 0;
+	score = 0;
+	scoreCheck = score * 11197;
+	tastenStände = 0;
+	if (ship)
+		ship = (Ship*)ship->release();
+	world->removeAll();
+	schuss->leeren();
+	asteroid->leeren();
+	Text* tmp = zOptionen->getTeilText(zOptionen->positionVon('=') + 1, zOptionen->positionVon(','));
+	breite = (int)*tmp;
+	tmp->release();
+	tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 1) + 1, zOptionen->positionVon(',', 1));
+	höhe = (int)*tmp;
+	tmp->release();
+	tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 2) + 1, zOptionen->positionVon(',', 2));
+	aGröße = (int)*tmp;
+	tmp->release();
+	tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 3) + 1, zOptionen->positionVon(',', 3));
+	maxTimer = (int)*tmp;
+	tmp->release();
+	mTimer = maxTimer;
+	tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 4) + 1, zOptionen->positionVon(',', 4));
+	shipN = (int)*tmp;
+	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 = (RandomGenerator*)rGen->release();
+	rGen = new RandomGenerator();
+	if (zOptionen->positionVon('=', 7) >= 0)
+	{
+		tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 7) + 1);
+		rGen->setSeed((__int64)*tmp);
+		tmp->release();
+	}
+	ship = new Ship(dynamic_cast<Model2DData*>(sData[shipN]->getThis()), shipPos, shipSpeed, shipR);
+	world->addObject(ship);
 }
 
-bool GameData::tick( double tickVal )
+bool GameData::tick(double tickVal)
 {
-    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() * 1 + 1; i++ )
-        {
-            Asteroid *newA = createNewAsteroid();
-            if( newA )
-            {
-                asteroid->add( newA );
-                world->addObject( dynamic_cast<Asteroid *>( newA->getThis() ) );
-            }
-        }
-    }
-    // Update
-    ship->setTastenstände( tastenStände );
-    int aAnz = asteroid->getEintragAnzahl();
-    int sAnz = schuss->getEintragAnzahl();
-    for( int i = aAnz - 1; i >= 0; i-- )
-    {
-        if( asteroid->z( i )->getSize() == 0 )
-        {
-            score += asteroid->z( i )->getScore();
-            scoreCheck = score * 11197;
-            world->removeObject( asteroid->z( i ) );
-            asteroid->remove( i );
-            aAnz--;
-        }
-    }
-    for( int i = sAnz - 1; i >= 0; i-- )
-    {
-        Vec2< float > pos = schuss->z( i )->getPosition();
-        if( pos.x < 0 || pos.y < 0 || pos.x > breite || pos.y > höhe )
-        {
-            sAnz--;
-            world->removeObject( schuss->z( i ) );
-            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++ )
-        {
-            Polygon2D ap;
-            Polygon2D bp;
-            Punkt pa;
-            Punkt pb;
-            if( asteroid->z( j )->istGetroffen( zs, ap, bp, pa, pb, rGen ) )
-            {
-                Array< Polygon2D > *npaA = new Array< Polygon2D >();
-                npaA->add( ap );
-                Model2DData *npdA = new Model2DData();
-                npdA->erstelleModell( npaA );
-                float rot = asteroid->z( j )->getDrehung();
-                char id = asteroid->z( j )->getId();
-                if( id >= 0 )
-                    id = -id - 1;
-                Asteroid *newA = new Asteroid( npdA, dynamic_cast<Bild *>( asteroid->z( j )->zTextur()->zTextur()->getThis() ), pa.rotation( rot ) + asteroid->z( j )->getPosition(), asteroid->z( j )->getSpeed(), asteroid->z( j )->getDrehungSpeed(), rot, asteroid->z( j )->getSize(), id );
-                asteroid->add( newA );
-                world->addObject( dynamic_cast<Asteroid *>( newA->getThis() ) );
-                Array< Polygon2D > *npaB = new Array< Polygon2D >();
-                npaB->add( bp );
-                Model2DData *npdB = new Model2DData();
-                npdB->erstelleModell( npaB );
-                newA = new Asteroid( npdB, dynamic_cast<Bild *>( asteroid->z( j )->zTextur()->zTextur()->getThis() ), pb.rotation( rot ) + asteroid->z( j )->getPosition(), asteroid->z( j )->getSpeed(), asteroid->z( j )->getDrehungSpeed(), rot, asteroid->z( j )->getSize(), id );
-                asteroid->add( newA );
-                world->addObject( dynamic_cast<Asteroid *>( newA->getThis() ) );
-                b = 1;
-                asteroid->z( j )->setSize( 0 );
-            }
-        }
-        if( !b )
-            b |= ship->istGetroffen( zs );
-        if( b )
-        {
-            world->removeObject( schuss->z( i ) );
-            schuss->remove( i );
-            sAnz--;
-        }
-    }
-    for( int i = 0; i < aAnz && !beendet; i++ )
-        beendet |= ship->istModelInnen( asteroid->z( i ) );
-    beendet |= ( score * 11197 != scoreCheck );
-    if( score * 11197 != scoreCheck )
-    {
-        score = 0;
-        scoreCheck = 0;
-    }
-    cs.unlock();
-    return 1;
+	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() * 1 + 1; i++)
+		{
+			Asteroid* newA = createNewAsteroid();
+			if (newA)
+			{
+				asteroid->add(newA);
+				world->addObject(dynamic_cast<Asteroid*>(newA->getThis()));
+			}
+		}
+	}
+	// Update
+	ship->setTastenstände(tastenStände);
+	int aAnz = asteroid->getEintragAnzahl();
+	int sAnz = schuss->getEintragAnzahl();
+	for (int i = aAnz - 1; i >= 0; i--)
+	{
+		if (asteroid->z(i)->getSize() == 0)
+		{
+			score += asteroid->z(i)->getScore();
+			scoreCheck = score * 11197;
+			world->removeObject(asteroid->z(i));
+			asteroid->remove(i);
+			aAnz--;
+		}
+	}
+	for (int i = sAnz - 1; i >= 0; i--)
+	{
+		Vec2< float > pos = schuss->z(i)->getPosition();
+		if (pos.x < 0 || pos.y < 0 || pos.x > breite || pos.y > höhe)
+		{
+			sAnz--;
+			world->removeObject(schuss->z(i));
+			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++)
+		{
+			Polygon2D ap;
+			Polygon2D bp;
+			Punkt pa;
+			Punkt pb;
+			if (asteroid->z(j)->istGetroffen(zs, ap, bp, pa, pb, rGen))
+			{
+				Array< Polygon2D >* npaA = new Array< Polygon2D >();
+				npaA->add(ap);
+				Model2DData* npdA = new Model2DData();
+				npdA->erstelleModell(npaA);
+				float rot = asteroid->z(j)->getDrehung();
+				char id = asteroid->z(j)->getId();
+				if (id >= 0)
+					id = -id - 1;
+				Asteroid* newA = new Asteroid(npdA, dynamic_cast<Bild*>(asteroid->z(j)->zTextur()->zTextur()->getThis()), pa.rotation(rot) + asteroid->z(j)->getPosition(), asteroid->z(j)->getSpeed(), asteroid->z(j)->getDrehungSpeed(), rot, asteroid->z(j)->getSize(), id);
+				asteroid->add(newA);
+				world->addObject(dynamic_cast<Asteroid*>(newA->getThis()));
+				Array< Polygon2D >* npaB = new Array< Polygon2D >();
+				npaB->add(bp);
+				Model2DData* npdB = new Model2DData();
+				npdB->erstelleModell(npaB);
+				newA = new Asteroid(npdB, dynamic_cast<Bild*>(asteroid->z(j)->zTextur()->zTextur()->getThis()), pb.rotation(rot) + asteroid->z(j)->getPosition(), asteroid->z(j)->getSpeed(), asteroid->z(j)->getDrehungSpeed(), rot, asteroid->z(j)->getSize(), id);
+				asteroid->add(newA);
+				world->addObject(dynamic_cast<Asteroid*>(newA->getThis()));
+				b = 1;
+				asteroid->z(j)->setSize(0);
+			}
+		}
+		if (!b)
+			b |= ship->istGetroffen(zs);
+		if (b)
+		{
+			world->removeObject(schuss->z(i));
+			schuss->remove(i);
+			sAnz--;
+		}
+	}
+	for (int i = 0; i < aAnz && !beendet; i++)
+		beendet |= ship->istModelInnen(asteroid->z(i));
+	beendet |= (score * 11197 != scoreCheck);
+	if (score * 11197 != scoreCheck)
+	{
+		score = 0;
+		scoreCheck = 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // constant
 int GameData::getScore() const
 {
-    return score;
+	return score;
 }
 
 bool GameData::istBeendet() const
 {
-    return beendet;
+	return beendet;
 }

Asteroids/Initialisierung.cpp

@@ -3,84 +3,84 @@
 #include <Textfeld.h>
 #include <MausEreignis.h>
 
-Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *titel )
+Knopf* initKnopf(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, const char* titel)
 {
-    Knopf *ret = uiFactory.createKnopf( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    ret->setText( titel );
-    return ret;
+	Knopf* ret = uiFactory.createKnopf(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	ret->setText(titel);
+	return ret;
 }
 
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt )
+KontrollKnopf* initKontrollKnopf(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, const char* txt)
 {
-    KontrollKnopf *ret = uiFactory.createKontrollKnopf( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setText( txt );
-    ret->setSText( txt );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    return ret;
+	KontrollKnopf* ret = uiFactory.createKontrollKnopf(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setText(txt);
+	ret->setSText(txt);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	return ret;
 }
 
-TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt )
+TextFeld* initTextFeld(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, const char* txt)
 {
-    TextFeld *ret = uiFactory.createTextFeld( uiFactory.initParam );
-    ret->setStyle( style );
-    ret->setText( txt );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    return ret;
+	TextFeld* ret = uiFactory.createTextFeld(uiFactory.initParam);
+	ret->setStyle(style);
+	ret->setText(txt);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	return ret;
 }
 
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values )
+AuswahlBox* initAuswahlBox(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, std::initializer_list< const char* > values)
 {
-    AuswahlBox *ret = uiFactory.createAuswahlBox( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    for( auto i = values.begin(); i != values.end(); i++ )
-    {
-        ret->addEintrag( *i );
-    }
-    return ret;
+	AuswahlBox* ret = uiFactory.createAuswahlBox(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	for (auto i = values.begin(); i != values.end(); i++)
+	{
+		ret->addEintrag(*i);
+	}
+	return ret;
 }
 
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe )
+ObjTabelle* initObjTabelle(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe)
 {
-    ObjTabelle *ret = uiFactory.createObjTabelle( uiFactory.initParam );
-    ret->addStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    for( auto i = spalten.begin(); i != spalten.end(); i++ )
-    {
-        ret->addSpalte( i->name );
-        ret->setSpaltenBreite( i->name, i->breite );
-        if( ( style | ObjTabelle::Style::SpaltenBreiteMin ) == style )
-            ret->setMinSpaltenBreite( i->name, i->minBreite );
-        if( ( style | ObjTabelle::Style::SpaltenBreiteMax ) == style )
-            ret->setMaxSpaltenBreite( i->name, i->maxBreite );
-        if( überschriftHöhe )
-        {
-            if( ret->getZeilenNummer( "Überschrift" ) < 0 )
-            {
-                ret->addZeile( 0, "Überschrift" );
-                ret->setZeilenHeight( 0, 20 );
-            }
-            ret->setZeichnungZ( i->name, "Überschrift", initTextFeld( 0, 0, i->breite, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, i->name ) );
-        }
-    }
-    return ret;
+	ObjTabelle* ret = uiFactory.createObjTabelle(uiFactory.initParam);
+	ret->addStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	for (auto i = spalten.begin(); i != spalten.end(); i++)
+	{
+		ret->addSpalte(i->name);
+		ret->setSpaltenBreite(i->name, i->breite);
+		if ((style | ObjTabelle::Style::SpaltenBreiteMin) == style)
+			ret->setMinSpaltenBreite(i->name, i->minBreite);
+		if ((style | ObjTabelle::Style::SpaltenBreiteMax) == style)
+			ret->setMaxSpaltenBreite(i->name, i->maxBreite);
+		if (überschriftHöhe)
+		{
+			if (ret->getZeilenNummer("Überschrift") < 0)
+			{
+				ret->addZeile(0, "Überschrift");
+				ret->setZeilenHeight(0, 20);
+			}
+			ret->setZeichnungZ(i->name, "Überschrift", initTextFeld(0, 0, i->breite, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, i->name));
+		}
+	}
+	return ret;
 }
 
-LDiag *initLinienDiagramm( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, DiagDaten *data )
+LDiag* initLinienDiagramm(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, DiagDaten* data)
 {
-    LDiag *ret = uiFactory.createLDiag( uiFactory.initParam );
-    ret->setStyle( style );
-    ret->setPosition( x, y );
-    ret->setSize( br, hö );
-    if( data )
-        ret->setDiagDatenZ( data );
-    return ret;
+	LDiag* ret = uiFactory.createLDiag(uiFactory.initParam);
+	ret->setStyle(style);
+	ret->setPosition(x, y);
+	ret->setSize(br, hö);
+	if (data)
+		ret->setDiagDatenZ(data);
+	return ret;
 }

Asteroids/Initialisierung.h

@@ -13,17 +13,17 @@ using namespace Framework;
 
 struct OBJTabelleSpalteIni
 {
-    char *name;
-    int breite;
-    int minBreite;
-    int maxBreite;
+	const char* name;
+	int breite;
+	int minBreite;
+	int maxBreite;
 };
 
-Knopf *initKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *titel );
-KontrollKnopf *initKontrollKnopf( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt );
-TextFeld *initTextFeld( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, char *txt );
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< char * > values );
-ObjTabelle *initObjTabelle( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
-LDiag *initLinienDiagramm( int x, int y, int br, int hö, UIInit &uiFactory, __int64 style, DiagDaten *data );
+Knopf* initKnopf(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, const char* titel);
+KontrollKnopf* initKontrollKnopf(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, const char* txt);
+TextFeld* initTextFeld(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, const char* txt);
+AuswahlBox* initAuswahlBox(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, std::initializer_list< const char* > values);
+ObjTabelle* initObjTabelle(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe);
+LDiag* initLinienDiagramm(int x, int y, int br, int hö, UIInit& uiFactory, __int64 style, DiagDaten* data);
 
 #endif

Asteroids/Map.cpp

@@ -14,489 +14,489 @@
 
 // Inhalt der Map Klasse aus Map.h
 // Konstruktor
-Map::Map( KSGClient::MinigameServerClient *klient )
-    : GameData( "data/Minigames/Asteroids/models/ship.m2", "data/Minigames/Asteroids/models/asteroids.m2" )
+Map::Map(KSGClient::MinigameServerClient* klient)
+	: GameData("data/Minigames/Asteroids/models/ship.m2", "data/Minigames/Asteroids/models/asteroids.m2")
 {
-    kamera = new Kamera2D();
-    kamera->setWelt( dynamic_cast<Welt2D *>( world->getThis() ), 1 );
-    kamera->setSize( 800, 500 );
-    mapKamera = new Kamera2D();
-    mapKamera->setWelt( dynamic_cast<Welt2D *>( world->getThis() ), 0 );
-    this->klient = klient;
-    aTextur = new Bild * [ 7 ]();
-    sTextur = new Bild * [ 2 ]();
-    // lade Flammen animation
-    LTDBDatei flammenStartLTDB;
-    flammenStartLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_start.ltdb" ) );
-    flammenStartLTDB.leseDaten( 0 );
-    Animation2DData *flammenStart = new Animation2DData();
-    flammenStart->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenStartLTDB.getThis() ) );
-    flammenStart->setFPS( 60 );
-    flammenStart->setWiederhohlend( 0 );
-    LTDBDatei flammenLTDB;
-    flammenLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_burn.ltdb" ) );
-    Animation2DData *flammenBurn = new Animation2DData();
-    flammenBurn->ladeAnimation( dynamic_cast<LTDBDatei *>( flammenLTDB.getThis() ) );
-    flammenBurn->setFPS( 60 );
-    flammenBurn->setWiederhohlend( 1 );
-    flammenM = new Textur2D();
-    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart->getThis() ) );
-    flammenM->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn->getThis() ) );
-    flammenL = new Textur2D();
-    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart->getThis() ) );
-    flammenL->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn->getThis() ) );
-    flammenR = new Textur2D();
-    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( flammenStart ) );
-    flammenR->addAnimationZ( dynamic_cast<Animation2DData *>( flammenBurn ) );
-    LTDBDatei td;
-    td.setDatei( new Text( "data/Minigames/Asteroids/bilder/asteroids.ltdb" ) );
-    td.leseDaten( 0 );
-    for( int i = 0; i < 7; i++ )
-    {
-        Text name = "";
-        name.append( (char)( 'a' + i ) );
-        aTextur[ i ] = td.laden( 0, new Text( (char *)( Text( name ) += ".png" ) ) );
-    }
-    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 ) );
-        sTextur[ i ] = td.laden( 0, new Text( (char *)( Text( name ) += ".png" ) ) );
-    }
-    map = new LRahmen();
-    map->setFarbe( 0xFFFFFFFF );
-    map->setPosition( 10, 10 );
-    map->setSize( 200, 200 );
-    mapKamera->setPosition( 10, 10 );
-    mapKamera->setSize( 200, 200 );
-    autoKam = 0;
+	kamera = new Kamera2D();
+	kamera->setWelt(dynamic_cast<Welt2D*>(world->getThis()), 1);
+	kamera->setSize(800, 500);
+	mapKamera = new Kamera2D();
+	mapKamera->setWelt(dynamic_cast<Welt2D*>(world->getThis()), 0);
+	this->klient = klient;
+	aTextur = new Bild * [7]();
+	sTextur = new Bild * [2]();
+	// lade Flammen animation
+	LTDBDatei flammenStartLTDB;
+	flammenStartLTDB.setDatei(new Text("data/Minigames/Asteroids/bilder/f_start.ltdb"));
+	flammenStartLTDB.leseDaten(0);
+	Animation2DData* flammenStart = new Animation2DData();
+	flammenStart->ladeAnimation(dynamic_cast<LTDBDatei*>(flammenStartLTDB.getThis()));
+	flammenStart->setFPS(60);
+	flammenStart->setWiederhohlend(0);
+	LTDBDatei flammenLTDB;
+	flammenLTDB.setDatei(new Text("data/Minigames/Asteroids/bilder/f_burn.ltdb"));
+	Animation2DData* flammenBurn = new Animation2DData();
+	flammenBurn->ladeAnimation(dynamic_cast<LTDBDatei*>(flammenLTDB.getThis()));
+	flammenBurn->setFPS(60);
+	flammenBurn->setWiederhohlend(1);
+	flammenM = new Textur2D();
+	flammenM->addAnimationZ(dynamic_cast<Animation2DData*>(flammenStart->getThis()));
+	flammenM->addAnimationZ(dynamic_cast<Animation2DData*>(flammenBurn->getThis()));
+	flammenL = new Textur2D();
+	flammenL->addAnimationZ(dynamic_cast<Animation2DData*>(flammenStart->getThis()));
+	flammenL->addAnimationZ(dynamic_cast<Animation2DData*>(flammenBurn->getThis()));
+	flammenR = new Textur2D();
+	flammenR->addAnimationZ(dynamic_cast<Animation2DData*>(flammenStart));
+	flammenR->addAnimationZ(dynamic_cast<Animation2DData*>(flammenBurn));
+	LTDBDatei td;
+	td.setDatei(new Text("data/Minigames/Asteroids/bilder/asteroids.ltdb"));
+	td.leseDaten(0);
+	for (int i = 0; i < 7; i++)
+	{
+		Text name = "";
+		name.append((char)('a' + i));
+		aTextur[i] = td.laden(0, new Text(name + ".png"));
+	}
+	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));
+		sTextur[i] = td.laden(0, new Text(name + ".png"));
+	}
+	map = new LRahmen();
+	map->setFarbe(0xFFFFFFFF);
+	map->setPosition(10, 10);
+	map->setSize(200, 200);
+	mapKamera->setPosition(10, 10);
+	mapKamera->setSize(200, 200);
+	autoKam = 0;
 }
 
 // Destruktor
 Map::~Map()
 {
-    for( int i = 0; i < 7; i++ )
-        aTextur[ i ]->release();
-    for( int i = 0; i < 2; i++ )
-        sTextur[ i ]->release();
-    delete[] aTextur;
-    delete[] sTextur;
-    map->release();
-    if( klient )
-        klient->release();
-    flammenM->release();
-    flammenL->release();
-    flammenR->release();
-    if( kamera )
-        kamera->release();
-    if( mapKamera )
-        mapKamera->release();
+	for (int i = 0; i < 7; i++)
+		aTextur[i]->release();
+	for (int i = 0; i < 2; i++)
+		sTextur[i]->release();
+	delete[] aTextur;
+	delete[] sTextur;
+	map->release();
+	if (klient)
+		klient->release();
+	flammenM->release();
+	flammenL->release();
+	flammenR->release();
+	if (kamera)
+		kamera->release();
+	if (mapKamera)
+		mapKamera->release();
 }
 
-Asteroid *Map::createNewAsteroid()
+Asteroid* Map::createNewAsteroid()
 {
-    Asteroid *a = __super::createNewAsteroid();
-    if( a )
-    {
-        Textur2D *text = new Textur2D();
-        text->setTexturZ( dynamic_cast<Bild *>( aTextur[ a->getId() ]->getThis() ) );
-        a->setTextur( text );
-    }
-    return a;
+	Asteroid* a = __super::createNewAsteroid();
+	if (a)
+	{
+		Textur2D* text = new Textur2D();
+		text->setTexturZ(dynamic_cast<Bild*>(aTextur[a->getId()]->getThis()));
+		a->setTextur(text);
+	}
+	return a;
 }
 
 // nicht constant
-void Map::reset( Text *zOptionen )
+void Map::reset(Text* zOptionen)
 {
-    flammenL->setAnimation( -1 );
-    flammenR->setAnimation( -1 );
-    flammenM->setAnimation( -1 );
-    __super::reset( zOptionen );
-    world->setSize( breite, höhe );
-    world->setSize( 1 );
-    world->setCircular( 1 );
-    Text *tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 5 ) + 1, zOptionen->positionVon( ',', 5 ) );
-    bool fortsetzen = (int)*tmp != 0;
-    tmp->release();
-    tmp = zOptionen->getTeilText( zOptionen->positionVon( '=', 6 ) + 1, zOptionen->positionVon( ',', 6 ) > 0 ? zOptionen->positionVon( ',', 6 ) : zOptionen->getLength() );
-    autoKam = (int)*tmp != 0;
-    if( !autoKam )
-        kamera->setDrehung( 0 );
-    tmp->release();
-    if( fortsetzen && DateiExistiert( "data/Minigames/Asteroids/data/game.save" ) && klient )
-    {
-        M2Datei sad;
-        int index = 0;
-        int sadI = 0;
-        Text pfad = "data/Minigames/Asteroids/data/sasave_";
-        pfad += sadI;
-        pfad += ".m2";
-        sad.setPfad( pfad );
-        sad.leseDaten();
-        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;
-        if( rGen )
-            rGen = (RandomGenerator *)rGen->release();
-        save->lese( (char *)&seed, 8 );
-        rGen = new RandomGenerator();
-        rGen->setSeed( seed );
-        save->lese( (char *)&gameTime, 8 );
-        save->lese( (char *)&br, 4 );
-        save->lese( (char *)&hö, 4 );
-        save->lese( (char *)&gr, 4 );
-        save->lese( (char *)&shn, 4 );
-        if( br == breite && hö == höhe && gr == aGröße && shn == shipN )
-        {
-            save->lese( (char *)&score, 4 );
-            scoreCheck = score * 11197;
-            save->lese( (char *)&mTimer, 4 );
-            // Schiff laden
-            Vec2< float > shipPos( (float)( breite / 2 ), (float)( höhe / 2 ) );
-            Vec2< float > shipSpeed( 0, 0 );
-            float shipR = (float)-PI / 2;
-            float shipRSpeed = 0;
-            save->lese( (char *)&shipPos.x, 4 );
-            save->lese( (char *)&shipPos.y, 4 );
-            save->lese( (char *)&shipSpeed.x, 4 );
-            save->lese( (char *)&shipSpeed.y, 4 );
-            save->lese( (char *)&shipR, 4 );
-            save->lese( (char *)&shipRSpeed, 4 );
-            ship->setPRS( shipPos, shipSpeed, shipR, shipRSpeed );
-            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 );
-                Bild *at = 0;
-                Model2DData *ad = 0;
-                if( n < 0 )
-                {
-                    at = dynamic_cast<Bild *>( aTextur[ -n - 1 ]->getThis() );
-                    ad = sad.ladeModel( sad.zModelName( index++ )->getText() );
-                    if( index == 120 )
-                    {
-                        index = 0;
-                        sadI++;
-                        Text pfad = "data/Minigames/Asteroids/data/sasave_";
-                        pfad += sadI;
-                        pfad += ".m2";
-                        sad = M2Datei();
-                        sad.setPfad( pfad );
-                        sad.leseDaten();
-                    }
-                }
-                else
-                {
-                    at = dynamic_cast<Bild *>( aTextur[ n ]->getThis() );
-                    ad = dynamic_cast<Model2DData *>( aData[ n ]->getThis() );
-                }
-                asteroid->add( new Asteroid( ad, at,
-                                             Vec2< float >( x, y ), Vec2< float >( xs, ys ), rs, r, gr, n ) );
-            }
-            save->lese( (char *)&anz, 4 );
-            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 );
-                if( schuss->getEintragAnzahl() > 100 )
-                {
-                    Schuss *newS = new Schuss( Vec2< float >( x, y ), Vec2< float >( xs, ys ) );
-                    schuss->add( newS );
-                    world->addObject( dynamic_cast<Object2D *>( newS->getThis() ) );
-                }
-            }
-        }
-        save->close();
-        save->release();
-    }
-    else
-    {
-        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 );
-        }
-    }
-    ship->setTexture( flammenM, flammenL, flammenR, dynamic_cast<Bild *>( sTextur[ shipN ]->getThis() ) );
+	flammenL->setAnimation(-1);
+	flammenR->setAnimation(-1);
+	flammenM->setAnimation(-1);
+	__super::reset(zOptionen);
+	world->setSize(breite, höhe);
+	world->setSize(1);
+	world->setCircular(1);
+	Text* tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 5) + 1, zOptionen->positionVon(',', 5));
+	bool fortsetzen = (int)*tmp != 0;
+	tmp->release();
+	tmp = zOptionen->getTeilText(zOptionen->positionVon('=', 6) + 1, zOptionen->positionVon(',', 6) > 0 ? zOptionen->positionVon(',', 6) : zOptionen->getLength());
+	autoKam = (int)*tmp != 0;
+	if (!autoKam)
+		kamera->setDrehung(0);
+	tmp->release();
+	if (fortsetzen && DateiExistiert("data/Minigames/Asteroids/data/game.save") && klient)
+	{
+		M2Datei sad;
+		int index = 0;
+		int sadI = 0;
+		Text pfad = "data/Minigames/Asteroids/data/sasave_";
+		pfad += sadI;
+		pfad += ".m2";
+		sad.setPfad(pfad);
+		sad.leseDaten();
+		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;
+		if (rGen)
+			rGen = (RandomGenerator*)rGen->release();
+		save->lese((char*)&seed, 8);
+		rGen = new RandomGenerator();
+		rGen->setSeed(seed);
+		save->lese((char*)&gameTime, 8);
+		save->lese((char*)&br, 4);
+		save->lese((char*)&hö, 4);
+		save->lese((char*)&gr, 4);
+		save->lese((char*)&shn, 4);
+		if (br == breite && hö == höhe && gr == aGröße && shn == shipN)
+		{
+			save->lese((char*)&score, 4);
+			scoreCheck = score * 11197;
+			save->lese((char*)&mTimer, 4);
+			// Schiff laden
+			Vec2< float > shipPos((float)(breite / 2), (float)(höhe / 2));
+			Vec2< float > shipSpeed(0, 0);
+			float shipR = (float)-PI / 2;
+			float shipRSpeed = 0;
+			save->lese((char*)&shipPos.x, 4);
+			save->lese((char*)&shipPos.y, 4);
+			save->lese((char*)&shipSpeed.x, 4);
+			save->lese((char*)&shipSpeed.y, 4);
+			save->lese((char*)&shipR, 4);
+			save->lese((char*)&shipRSpeed, 4);
+			ship->setPRS(shipPos, shipSpeed, shipR, shipRSpeed);
+			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);
+				Bild* at = 0;
+				Model2DData* ad = 0;
+				if (n < 0)
+				{
+					at = dynamic_cast<Bild*>(aTextur[-n - 1]->getThis());
+					ad = sad.ladeModel(sad.zModelName(index++)->getText());
+					if (index == 120)
+					{
+						index = 0;
+						sadI++;
+						Text pfad = "data/Minigames/Asteroids/data/sasave_";
+						pfad += sadI;
+						pfad += ".m2";
+						sad = M2Datei();
+						sad.setPfad(pfad);
+						sad.leseDaten();
+					}
+				}
+				else
+				{
+					at = dynamic_cast<Bild*>(aTextur[n]->getThis());
+					ad = dynamic_cast<Model2DData*>(aData[n]->getThis());
+				}
+				asteroid->add(new Asteroid(ad, at,
+					Vec2< float >(x, y), Vec2< float >(xs, ys), rs, r, gr, n));
+			}
+			save->lese((char*)&anz, 4);
+			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);
+				if (schuss->getEintragAnzahl() > 100)
+				{
+					Schuss* newS = new Schuss(Vec2< float >(x, y), Vec2< float >(xs, ys));
+					schuss->add(newS);
+					world->addObject(dynamic_cast<Object2D*>(newS->getThis()));
+				}
+			}
+		}
+		save->close();
+		save->release();
+	}
+	else
+	{
+		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);
+		}
+	}
+	ship->setTexture(flammenM, flammenL, flammenR, dynamic_cast<Bild*>(sTextur[shipN]->getThis()));
 }
 
-void Map::doPublicMausEreignis( MausEreignis &me )
+void Map::doPublicMausEreignis(MausEreignis& me)
 {}
 
-void Map::doTastaturEreignis( TastaturEreignis &te )
+void Map::doTastaturEreignis(TastaturEreignis& te)
 {
-    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 )
-            {
-                if( ( tastenStände | 1 ) != tastenStände )
-                    flammenM->setAnimation( 0 );
-                tastenStände |= 1;
-            }
-            else
-            {
-                tastenStände &= ~1;
-                flammenM->setAnimation( -1 );
-            }
-        }
-        if( te.taste == 'd' || te.taste == 'D' || te.taste == T_Rechts )
-        {
-            if( te.id == TE_Press )
-            {
-                if( ( tastenStände | 2 ) != tastenStände )
-                    flammenL->setAnimation( 0 );
-                tastenStände |= 2;
-            }
-            else
-            {
-                tastenStände &= ~2;
-                flammenL->setAnimation( -1 );
-            }
-        }
-        if( te.taste == 'a' || te.taste == 'A' || te.taste == T_Links )
-        {
-            if( te.id == TE_Press )
-            {
-                if( ( tastenStände | 4 ) != tastenStände )
-                    flammenR->setAnimation( 0 );
-                tastenStände |= 4;
-            }
-            else
-            {
-                tastenStände &= ~4;
-                flammenR->setAnimation( -1 );
-            }
-        }
-        if( te.taste == T_Space )
-        {
-            if( te.id == TE_Press )
-            {
-                if( ( tastenStände | 8 ) != tastenStände )
-                    ok = 0;
-                tastenStände |= 8;
-            }
-            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 );
-        }
-        if( schuss->getEintragAnzahl() < 100 )
-        {
-            Schuss *newS = ship->getSchuss();
-            schuss->add( newS );
-            world->addObject( dynamic_cast<Object2D *>( newS->getThis() ) );
-        }
-    }
-    cs.unlock();
+	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)
+			{
+				if ((tastenStände | 1) != tastenStände)
+					flammenM->setAnimation(0);
+				tastenStände |= 1;
+			}
+			else
+			{
+				tastenStände &= ~1;
+				flammenM->setAnimation(-1);
+			}
+		}
+		if (te.taste == 'd' || te.taste == 'D' || te.taste == T_Rechts)
+		{
+			if (te.id == TE_Press)
+			{
+				if ((tastenStände | 2) != tastenStände)
+					flammenL->setAnimation(0);
+				tastenStände |= 2;
+			}
+			else
+			{
+				tastenStände &= ~2;
+				flammenL->setAnimation(-1);
+			}
+		}
+		if (te.taste == 'a' || te.taste == 'A' || te.taste == T_Links)
+		{
+			if (te.id == TE_Press)
+			{
+				if ((tastenStände | 4) != tastenStände)
+					flammenR->setAnimation(0);
+				tastenStände |= 4;
+			}
+			else
+			{
+				tastenStände &= ~4;
+				flammenR->setAnimation(-1);
+			}
+		}
+		if (te.taste == T_Space)
+		{
+			if (te.id == TE_Press)
+			{
+				if ((tastenStände | 8) != tastenStände)
+					ok = 0;
+				tastenStände |= 8;
+			}
+			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);
+		}
+		if (schuss->getEintragAnzahl() < 100)
+		{
+			Schuss* newS = ship->getSchuss();
+			schuss->add(newS);
+			world->addObject(dynamic_cast<Object2D*>(newS->getThis()));
+		}
+	}
+	cs.unlock();
 }
 
-bool Map::tick( double t )
+bool Map::tick(double t)
 {
-    if( beendet )
-        return 0;
-    bool ret = __super::tick( t );
-    ret |= kamera->tick( t );
-    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;
-        KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
-        new AsynchronCall( [tmpScore, tmpKlient]()
-        {
-            InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-            opd->laden();
-            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();
-            Datei d;
-            d.setDatei( "data/Minigames/Asteroids/data/upload.mgc" );
-            tmpKlient->reportEndOfGame( "Asteroids", optionen, tmpScore, &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" );
-    }
-    ret |= flammenM->tick( t );
-    ret |= flammenL->tick( t );
-    ret |= flammenR->tick( t );
-    return ret;
+	if (beendet)
+		return 0;
+	bool ret = __super::tick(t);
+	ret |= kamera->tick(t);
+	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;
+		KSGClient::MinigameServerClient* tmpKlient = dynamic_cast<KSGClient::MinigameServerClient*>(klient->getThis());
+		new AsynchronCall([tmpScore, tmpKlient]()
+			{
+				InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
+				opd->laden();
+				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();
+				Datei d;
+				d.setDatei("data/Minigames/Asteroids/data/upload.mgc");
+				tmpKlient->reportEndOfGame("Asteroids", optionen, tmpScore, &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");
+	}
+	ret |= flammenM->tick(t);
+	ret |= flammenL->tick(t);
+	ret |= flammenR->tick(t);
+	return ret;
 }
 
-void Map::render( Bild &zRObj )
+void Map::render(Bild& zRObj)
 {
-    cs.lock();
-    kamera->lookAtWorldPos( ship->getPosition().x, ship->getPosition().y );
-    if( autoKam )
-        kamera->setDrehung( -ship->getDrehung() );
-    kamera->render( zRObj );
-    if( breite >= 800 || höhe >= 500 )
-    { // Minimap
-        zRObj.setAlpha( 50 );
-        if( breite > höhe )
-            mapKamera->setSize( 200, (int)( ( 200.0 / world->getWorldInfo().size.x ) * world->getWorldInfo().size.y ) );
-        else
-            mapKamera->setSize( (int)( ( 200.0 / world->getWorldInfo().size.y ) * world->getWorldInfo().size.x ), 200 );
-        mapKamera->lookAtWorldPos( world->getWorldInfo().size.x / 2.f, world->getWorldInfo().size.y / 2.f );
-        mapKamera->lookAtWorldArea( (float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y );
-        mapKamera->render( zRObj );
-        map->setSize( mapKamera->getBreite(), mapKamera->getHeight() );
-        map->render( zRObj );
-        zRObj.releaseAlpha();
-    }
-    cs.unlock();
+	cs.lock();
+	kamera->lookAtWorldPos(ship->getPosition().x, ship->getPosition().y);
+	if (autoKam)
+		kamera->setDrehung(-ship->getDrehung());
+	kamera->render(zRObj);
+	if (breite >= 800 || höhe >= 500)
+	{ // Minimap
+		zRObj.setAlpha(50);
+		if (breite > höhe)
+			mapKamera->setSize(200, (int)((200.0 / world->getWorldInfo().size.x) * world->getWorldInfo().size.y));
+		else
+			mapKamera->setSize((int)((200.0 / world->getWorldInfo().size.y) * world->getWorldInfo().size.x), 200);
+		mapKamera->lookAtWorldPos(world->getWorldInfo().size.x / 2.f, world->getWorldInfo().size.y / 2.f);
+		mapKamera->lookAtWorldArea((float)world->getWorldInfo().size.x, (float)world->getWorldInfo().size.y);
+		mapKamera->render(zRObj);
+		map->setSize(mapKamera->getBreite(), mapKamera->getHeight());
+		map->render(zRObj);
+		zRObj.releaseAlpha();
+	}
+	cs.unlock();
 }
 
 void Map::speichern()
 {
-    if( !beendet && klient )
-    {
-        if( capture.istOffen() )
-            capture.close();
-        cs.lock();
-        int anz = asteroid->getEintragAnzahl();
-        int index = 0;
-        for( int i = 0; index < anz; i++ )
-        {
-            M2Datei sad;
-            Text pfad = "data/Minigames/Asteroids/data/sasave_";
-            pfad += i;
-            pfad += ".m2";
-            DateiRemove( pfad );
-            sad.setPfad( pfad );
-            sad.leseDaten();
-            char name[ 2 ];
-            name[ 1 ] = 0;
-            for( char n = 1; n <= 120 && index < anz; n++ )
-            {
-                name[ 0 ] = n;
-                if( asteroid->z( index++ )->getId() < 0 )
-                    sad.saveModel( asteroid->z( index - 1 )->zModel(), name );
-                else
-                    n--;
-            }
-        }
-        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 );
-        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();
-        cs.unlock();
-    }
-    else if( klient )
-        DateiRemove( "data/Minigames/Asteroids/data/game.save" );
+	if (!beendet && klient)
+	{
+		if (capture.istOffen())
+			capture.close();
+		cs.lock();
+		int anz = asteroid->getEintragAnzahl();
+		int index = 0;
+		for (int i = 0; index < anz; i++)
+		{
+			M2Datei sad;
+			Text pfad = "data/Minigames/Asteroids/data/sasave_";
+			pfad += i;
+			pfad += ".m2";
+			DateiRemove(pfad);
+			sad.setPfad(pfad);
+			sad.leseDaten();
+			char name[2];
+			name[1] = 0;
+			for (char n = 1; n <= 120 && index < anz; n++)
+			{
+				name[0] = n;
+				if (asteroid->z(index++)->getId() < 0)
+					sad.saveModel(asteroid->z(index - 1)->zModel(), name);
+				else
+					n--;
+			}
+		}
+		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);
+		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();
+		cs.unlock();
+	}
+	else if (klient)
+		DateiRemove("data/Minigames/Asteroids/data/game.save");
 }

Asteroids/Menü.cpp

@@ -15,1099 +15,1099 @@
 
 // Inhalt der MenüVerloren Klasse aus Menü.h
 // Kontruktor
-MenüVerloren::MenüVerloren( UIInit &uiFactory )
-    : ReferenceCounter()
+MenüVerloren::MenüVerloren(UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    ram = new LRahmen();
-    ram->setSize( 160, 100 );
-    ram->setPosition( 320, 200 );
-    ram->setFarbe( 0xFFFFFFFF );
-    verloren = initTextFeld( 325, 210, 150, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
-    neu = initKnopf( 350, 240, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
-    beenden = initKnopf( 350, 270, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
+	ram = new LRahmen();
+	ram->setSize(160, 100);
+	ram->setPosition(320, 200);
+	ram->setFarbe(0xFFFFFFFF);
+	verloren = initTextFeld(325, 210, 150, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren.");
+	neu = initKnopf(350, 240, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel");
+	beenden = initKnopf(350, 270, 100, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück");
 }
 
 // Destruktor
 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::doPublicMausEreignis( MausEreignis &me )
+int MenüVerloren::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    int ret = 0;
-    neu->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet && me.id == ME_RLinks )
-        ret = 1;
-    beenden->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet && !ret && me.id == ME_RLinks )
-        ret = 2;
-    return ret;
+	bool vera = me.verarbeitet;
+	int ret = 0;
+	neu->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet && me.id == ME_RLinks)
+		ret = 1;
+	beenden->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet && !ret && me.id == ME_RLinks)
+		ret = 2;
+	return ret;
 }
 
-bool MenüVerloren::tick( double tickVal )
+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 )
+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);
 }
 
 
 // Inhalt der MenüSpiel Klasse aus Menü.h
 // Konstruktor
-MenüSpiel::MenüSpiel( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
-    : ReferenceCounter()
+MenüSpiel::MenüSpiel(UIInit& uiFactory, KSGClient::MinigameServerClient* klient)
+	: ReferenceCounter()
 {
-    scoreT = initTextFeld( 690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0" );
-    beenden = initKnopf( 690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
-    map = new Map( klient );
-    verloren = new MenüVerloren( uiFactory );
-    beendet = 0;
-    timePuffer = 0;
+	scoreT = initTextFeld(690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0");
+	beenden = initKnopf(690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden");
+	map = new Map(klient);
+	verloren = new MenüVerloren(uiFactory);
+	beendet = 0;
+	timePuffer = 0;
 }
 
 // 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()
 {
-    timePuffer = 0;
-    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", "1600" );
-        optionen += "1600";
-    }
-    optionen += ",Height=";
-    if( opd->wertExistiert( "Höhe" ) )
-        optionen += (int)*opd->zWert( "Höhe" );
-    else
-    {
-        opd->addWert( "Höhe", "1000" );
-        optionen += "1000";
-    }
-    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;
-    }
-    optionen += ",AutoKam=";
-    if( opd->wertExistiert( "AutoKam" ) )
-        optionen += (int)*opd->zWert( "AutoKam" ) != 0;
-    else
-    {
-        opd->addWert( "AutoKam", "0" );
-        optionen += 0;
-    }
-    opd->speichern();
-    opd->release();
-    map->reset( &optionen );
-    beendet = 0;
-    scoreT->setText( "Score: " );
-    scoreT->zText()->append( map->getScore() );
+	timePuffer = 0;
+	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", "1600");
+		optionen += "1600";
+	}
+	optionen += ",Height=";
+	if (opd->wertExistiert("Höhe"))
+		optionen += (int)*opd->zWert("Höhe");
+	else
+	{
+		opd->addWert("Höhe", "1000");
+		optionen += "1000";
+	}
+	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;
+	}
+	optionen += ",AutoKam=";
+	if (opd->wertExistiert("AutoKam"))
+		optionen += (int)*opd->zWert("AutoKam") != 0;
+	else
+	{
+		opd->addWert("AutoKam", "0");
+		optionen += 0;
+	}
+	opd->speichern();
+	opd->release();
+	map->reset(&optionen);
+	beendet = 0;
+	scoreT->setText("Score: ");
+	scoreT->zText()->append(map->getScore());
 }
 
-void MenüSpiel::doPublicMausEreignis( MausEreignis &me )
+void MenüSpiel::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    beenden->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet && me.id == ME_RLinks )
-    {
-        map->speichern();
-        beendet = 1;
-    }
-    map->doPublicMausEreignis( me );
-    if( map->istBeendet() )
-    {
-        int ak = verloren->doPublicMausEreignis( me );
-        if( ak == 1 )
-            reset();
-        if( ak == 2 )
-            beendet = 1;
-    }
+	bool vera = me.verarbeitet;
+	beenden->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet && me.id == ME_RLinks)
+	{
+		map->speichern();
+		beendet = 1;
+	}
+	map->doPublicMausEreignis(me);
+	if (map->istBeendet())
+	{
+		int ak = verloren->doPublicMausEreignis(me);
+		if (ak == 1)
+			reset();
+		if (ak == 2)
+			beendet = 1;
+	}
 }
 
-void MenüSpiel::doTastaturEreignis( TastaturEreignis &te )
+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 MenüSpiel::tick(double tickVal)
 {
-    timePuffer += tickVal;
+	timePuffer += tickVal;
 
-    bool ret = beenden->tick( tickVal );
-    while( timePuffer >= 0.02 )
-    {
-        ret |= map->tick( 0.02 );
-        timePuffer -= 0.02;
-    }
-    if( map->istBeendet() )
-        ret |= verloren->tick( tickVal );
-    scoreT->setText( "Score: " );
-    scoreT->zText()->append( map->getScore() );
-    return ret;
+	bool ret = beenden->tick(tickVal);
+	while (timePuffer >= 0.02)
+	{
+		ret |= map->tick(0.02);
+		timePuffer -= 0.02;
+	}
+	if (map->istBeendet())
+		ret |= verloren->tick(tickVal);
+	scoreT->setText("Score: ");
+	scoreT->zText()->append(map->getScore());
+	return ret;
 }
 
-void MenüSpiel::render( Bild &zRObj )
+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;
 }
 
 
 // Inhalt der MenüWiederhohlung Klasse
 // Konstruktor
-MenüWiederhohlung::MenüWiederhohlung( UIInit &uiFactory, Datei *datei, Text *zOptionen )
-    : ReferenceCounter()
+MenüWiederhohlung::MenüWiederhohlung(UIInit& uiFactory, Datei* datei, Text* zOptionen)
+	: ReferenceCounter()
 {
-    scoreT = initTextFeld( 690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0" );
-    beenden = initKnopf( 690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
-    this->datei = datei;
-    if( !datei->istOffen() )
-        datei->open( Datei::Style::lesen );
-    __int64 seed;
-    datei->lese( (char *)&seed, 8 );
-    zOptionen->append( ",Fortsetzen=0,AutoKam=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;
+	scoreT = initTextFeld(690, 10, 100, 20, uiFactory, TextFeld::Style::Text, "Score: 0");
+	beenden = initKnopf(690, 40, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden");
+	this->datei = datei;
+	if (!datei->istOffen())
+		datei->open(Datei::Style::lesen);
+	__int64 seed;
+	datei->lese((char*)&seed, 8);
+	zOptionen->append(",Fortsetzen=0,AutoKam=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;
 }
 
 // Destruktor
 MenüWiederhohlung::~MenüWiederhohlung()
 {
-    scoreT->release();
-    beenden->release();
-    map->release();
-    datei->close();
-    datei->release();
+	scoreT->release();
+	beenden->release();
+	map->release();
+	datei->close();
+	datei->release();
 }
 
 // nicht constant
-void MenüWiederhohlung::doPublicMausEreignis( MausEreignis &me )
+void MenüWiederhohlung::doPublicMausEreignis(MausEreignis& me)
 {
-    bool vera = me.verarbeitet;
-    beenden->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet && me.id == ME_RLinks )
-        beendet = 1;
-    if( map->istBeendet() )
-        beendet = 1;
+	bool vera = me.verarbeitet;
+	beenden->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet && me.id == ME_RLinks)
+		beendet = 1;
+	if (map->istBeendet())
+		beendet = 1;
 }
 
-void MenüWiederhohlung::doTastaturEreignis( TastaturEreignis &te )
+void MenüWiederhohlung::doTastaturEreignis(TastaturEreignis& te)
 {}
 
-bool MenüWiederhohlung::tick( double tickVal )
+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.02 );
-            tickVal -= 0.02;
-            nowTime += 0.02;
-        }
-        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.02 );
-        nowTime += 0.02;
-        timePuffer -= 0.02;
-    }
-    scoreT->setText( "Score: " );
-    scoreT->zText()->append( map->getScore() );
-    return ret;
+	bool ret = beenden->tick(tickVal);
+	// TODO Replay Activity
+	while (nextTime >= 0 && nowTime + tickVal >= nextTime)
+	{
+		while (nowTime < nextTime)
+		{
+			ret |= map->tick(0.02);
+			tickVal -= 0.02;
+			nowTime += 0.02;
+		}
+		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.02);
+		nowTime += 0.02;
+		timePuffer -= 0.02;
+	}
+	scoreT->setText("Score: ");
+	scoreT->zText()->append(map->getScore());
+	return ret;
 }
 
-void MenüWiederhohlung::render( Bild &zRObj )
+void MenüWiederhohlung::render(Bild& zRObj)
 {
-    map->render( zRObj );
-    scoreT->render( zRObj );
-    beenden->render( zRObj );
+	map->render(zRObj);
+	scoreT->render(zRObj);
+	beenden->render(zRObj);
 }
 
 // constant
 bool MenüWiederhohlung::istBeendet() const
 {
-    return beendet;
+	return beendet;
 }
 
 
 // Inhalt der MenüStatistik Klasse aus Menü.h
 // Konstruktor
-MenüStatistik::MenüStatistik( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
+MenüStatistik::MenüStatistik(UIInit& uiFactory, KSGClient::MinigameServerClient* klient)
 {
-    this->klient = klient;
-    wiederH = 0;
-    ansichtT = initTextFeld( 245, 10, 50, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
-    ansicht = initAuswahlBox( 295, 10, 120, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
-    optionen = initKontrollKnopf( 425, 10, 130, 20, uiFactory, KontrollKnopf::Style::Normal, "Optionen beachten" );
-    worldBestT = initObjTabelle( 115, 40, 570, 120, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, {"Ansehen", 55, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-    gesammtT = initObjTabelle( 115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-    optionenT = initObjTabelle( 115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20 );
-    gesammtD = initLinienDiagramm( 100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0 );
-    optionenD = initLinienDiagramm( 100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0 );
-    remove = initKnopf( 10, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurücksetzen" );
-    zurück = initKnopf( 350, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurück" );
-    this->uiFactory = uiFactory;
-    tr = new TextRenderer( dynamic_cast<Schrift *>( uiFactory.initParam.schrift->getThis() ) );
-    asyncFinished = 1;
+	this->klient = klient;
+	wiederH = 0;
+	ansichtT = initTextFeld(245, 10, 50, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:");
+	ansicht = initAuswahlBox(295, 10, 120, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" });
+	optionen = initKontrollKnopf(425, 10, 130, 20, uiFactory, KontrollKnopf::Style::Normal, "Optionen beachten");
+	worldBestT = initObjTabelle(115, 40, 570, 120, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 }, { "Spieler", 100, 0, 0 }, {"Ansehen", 55, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20);
+	gesammtT = initObjTabelle(115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20);
+	optionenT = initObjTabelle(115, 170, 570, 290, uiFactory, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 60, 0, 0 }, { "Höhe", 60, 0, 0 }, { "Größe", 70, 0, 0 }, { "Timer", 70, 0, 0 }, { "Ship", 70, 0, 0 } }, 20);
+	gesammtD = initLinienDiagramm(100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0);
+	optionenD = initLinienDiagramm(100, 170, 600, 290, uiFactory, LDiag::Style::DatenRahmen, 0);
+	remove = initKnopf(10, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurücksetzen");
+	zurück = initKnopf(350, 470, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Zurück");
+	this->uiFactory = uiFactory;
+	tr = new TextRenderer(dynamic_cast<Schrift*>(uiFactory.initParam.schrift->getThis()));
+	asyncFinished = 1;
 }
 
 // Destruktor
 MenüStatistik::~MenüStatistik()
 {
-    while( !asyncFinished )
-        Sleep( 100 );
-    tr->release();
-    worldBestT->release();
-    ansichtT->release();
-    ansicht->release();
-    optionen->release();
-    gesammtT->release();
-    optionenT->release();
-    gesammtD->release();
-    optionenD->release();
-    remove->release();
-    zurück->release();
-    klient->release();
-    if( wiederH )
-        wiederH->release();
+	while (!asyncFinished)
+		Sleep(100);
+	tr->release();
+	worldBestT->release();
+	ansichtT->release();
+	ansicht->release();
+	optionen->release();
+	gesammtT->release();
+	optionenT->release();
+	gesammtD->release();
+	optionenD->release();
+	remove->release();
+	zurück->release();
+	klient->release();
+	if (wiederH)
+		wiederH->release();
 }
 
 // nicht constant
 void MenüStatistik::reset()
 {
-    if( wiederH )
-        wiederH = (MenüWiederhohlung *)wiederH->release();
-    ObjTabelle *tmpWBT = dynamic_cast<ObjTabelle *>( worldBestT->getThis() );
-    KSGClient::MinigameServerClient *tmpKlient = dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() );
-    asyncFinished = 0;
-    new AsynchronCall( [this, tmpWBT, tmpKlient]()
-    {
-        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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
-            TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
-            Text optionen = option.z( i )->getText();
-            Text *breite = optionen.getTeilText( optionen.positionVon( '=' ) + 1, optionen.positionVon( ',' ) );
-            Text *höhe = optionen.getTeilText( optionen.positionVon( '=', 1 ) + 1, optionen.positionVon( ',', 1 ) );
-            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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
-            breite->release();
-            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
-            höhe->release();
-            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, größe->getText() );
-            größe->release();
-            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, timer->getText() );
-            timer->release();
-            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, ship->getText() );
-            ship->release();
-            Knopf *ansehenK = initKnopf( 0, 0, 0, 0, uiFactory, Knopf::Style::Normal, "Ansehen" );
-            ansehenK->setMausEreignis( [this, optionen]( void *p, void *obj, MausEreignis me ) -> bool
-            {
-                if( me.id == ME_RLinks && !me.verarbeitet )
-                {
-                    ( (Knopf *)obj )->removeStyle( Knopf::Style::Erlaubt );
-                    getThis();
-                    new AsynchronCall( [this, optionen, obj]()
-                    {
-                        Datei *d = klient->downloadGameCapture( "Asteroids", optionen );
-                        ( (Knopf *)obj )->addStyle( Knopf::Style::Erlaubt );
-                        if( wiederH )
-                            wiederH = (MenüWiederhohlung *)wiederH->release();
-                        Text options = optionen.getText();
-                        wiederH = new MenüWiederhohlung( uiFactory, 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();
-    }, &asyncFinished );
-    InitDatei *opd = new InitDatei( "data/Minigames/Asteroids/data/optionen.ini" );
-    opd->laden();
-    if( !opd->wertExistiert( "Breite" ) )
-        opd->addWert( "Breite", "1600" );
-    if( !opd->wertExistiert( "Höhe" ) )
-        opd->addWert( "Höhe", "1000" );
-    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" );
-    if( !opd->wertExistiert( "AutoKam" ) )
-        opd->addWert( "AutoKam", "0" );
-    opd->speichern();
-    KSGTDatei *stb = new KSGTDatei( "data/Minigames/Asteroids/data/score.ksgt" );
-    stb->laden();
-    int 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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
-            TextFeld *datumT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
-            TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
-            TextFeld *höheT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
-            TextFeld *größeT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
-            TextFeld *timerT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
-            TextFeld *shipT = initTextFeld( 0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 6 )->getText() );
-            int ship = *stb->zFeld( p, 6 );
-            switch( ship )
-            {
-            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, dynamic_cast<Zeichnung *>( scoreT->getThis() ) );
-                optionenT->setZeichnungZ( 1, n, dynamic_cast<Zeichnung *>( datumT->getThis() ) );
-                optionenT->setZeichnungZ( 2, n, dynamic_cast<Zeichnung *>( breiteT->getThis() ) );
-                optionenT->setZeichnungZ( 3, n, dynamic_cast<Zeichnung *>( höheT->getThis() ) );
-                optionenT->setZeichnungZ( 4, n, dynamic_cast<Zeichnung *>( größeT->getThis() ) );
-                optionenT->setZeichnungZ( 5, n, dynamic_cast<Zeichnung *>( timerT->getThis() ) );
-                optionenT->setZeichnungZ( 6, n, dynamic_cast<Zeichnung *>( shipT->getThis() ) );
-                if( !omS )
-                    omS = maxScore;
-                oAnz++;
-            }
-        }
-        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 = (MenüWiederhohlung*)wiederH->release();
+	ObjTabelle* tmpWBT = dynamic_cast<ObjTabelle*>(worldBestT->getThis());
+	KSGClient::MinigameServerClient* tmpKlient = dynamic_cast<KSGClient::MinigameServerClient*>(klient->getThis());
+	asyncFinished = 0;
+	new AsynchronCall([this, tmpWBT, tmpKlient]()
+		{
+			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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, Text(score.get(i)));
+				TextFeld* spielerT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z(i)->getText());
+				Text optionen = option.z(i)->getText();
+				Text* breite = optionen.getTeilText(optionen.positionVon('=') + 1, optionen.positionVon(','));
+				Text* höhe = optionen.getTeilText(optionen.positionVon('=', 1) + 1, optionen.positionVon(',', 1));
+				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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText());
+				breite->release();
+				TextFeld* höheT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText());
+				höhe->release();
+				TextFeld* größeT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, größe->getText());
+				größe->release();
+				TextFeld* timerT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, timer->getText());
+				timer->release();
+				TextFeld* shipT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, ship->getText());
+				ship->release();
+				Knopf* ansehenK = initKnopf(0, 0, 0, 0, uiFactory, Knopf::Style::Normal, "Ansehen");
+				ansehenK->setMausEreignis([this, optionen](void* p, void* obj, MausEreignis me) -> bool
+					{
+						if (me.id == ME_RLinks && !me.verarbeitet)
+						{
+							((Knopf*)obj)->removeStyle(Knopf::Style::Erlaubt);
+							getThis();
+							new AsynchronCall([this, optionen, obj]()
+								{
+									Datei* d = klient->downloadGameCapture("Asteroids", optionen);
+									((Knopf*)obj)->addStyle(Knopf::Style::Erlaubt);
+									if (wiederH)
+										wiederH = (MenüWiederhohlung*)wiederH->release();
+									Text options = optionen.getText();
+									wiederH = new MenüWiederhohlung(uiFactory, 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();
+		}, &asyncFinished);
+	InitDatei* opd = new InitDatei("data/Minigames/Asteroids/data/optionen.ini");
+	opd->laden();
+	if (!opd->wertExistiert("Breite"))
+		opd->addWert("Breite", "1600");
+	if (!opd->wertExistiert("Höhe"))
+		opd->addWert("Höhe", "1000");
+	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");
+	if (!opd->wertExistiert("AutoKam"))
+		opd->addWert("AutoKam", "0");
+	opd->speichern();
+	KSGTDatei* stb = new KSGTDatei("data/Minigames/Asteroids/data/score.ksgt");
+	stb->laden();
+	int 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, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 1)->getText());
+			TextFeld* datumT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 0)->getText());
+			TextFeld* breiteT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 2)->getText());
+			TextFeld* höheT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 3)->getText());
+			TextFeld* größeT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 5)->getText());
+			TextFeld* timerT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 4)->getText());
+			TextFeld* shipT = initTextFeld(0, 0, 0, 0, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld(p, 6)->getText());
+			int ship = (int)*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, dynamic_cast<Zeichnung*>(scoreT->getThis()));
+				optionenT->setZeichnungZ(1, n, dynamic_cast<Zeichnung*>(datumT->getThis()));
+				optionenT->setZeichnungZ(2, n, dynamic_cast<Zeichnung*>(breiteT->getThis()));
+				optionenT->setZeichnungZ(3, n, dynamic_cast<Zeichnung*>(höheT->getThis()));
+				optionenT->setZeichnungZ(4, n, dynamic_cast<Zeichnung*>(größeT->getThis()));
+				optionenT->setZeichnungZ(5, n, dynamic_cast<Zeichnung*>(timerT->getThis()));
+				optionenT->setZeichnungZ(6, n, dynamic_cast<Zeichnung*>(shipT->getThis()));
+				if (!omS)
+					omS = maxScore;
+				oAnz++;
+			}
+		}
+		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::doPublicMausEreignis( MausEreignis &me )
+void MenüStatistik::doPublicMausEreignis(MausEreignis& me)
 {
-    if( wiederH )
-    {
-        wiederH->doPublicMausEreignis( me );
-        return;
-    }
-    ansicht->doPublicMausEreignis( me );
-    optionen->doPublicMausEreignis( me );
-    gesammtT->doPublicMausEreignis( me );
-    optionenT->doPublicMausEreignis( me );
-    worldBestT->doPublicMausEreignis( me );
-    bool vera = me.verarbeitet;
-    remove->doPublicMausEreignis( 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->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet && me.id == ME_RLinks )
-        beendet = 1;
+	if (wiederH)
+	{
+		wiederH->doPublicMausEreignis(me);
+		return;
+	}
+	ansicht->doPublicMausEreignis(me);
+	optionen->doPublicMausEreignis(me);
+	gesammtT->doPublicMausEreignis(me);
+	optionenT->doPublicMausEreignis(me);
+	worldBestT->doPublicMausEreignis(me);
+	bool vera = me.verarbeitet;
+	remove->doPublicMausEreignis(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->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet && me.id == ME_RLinks)
+		beendet = 1;
 }
 
-bool MenüStatistik::tick( double tickVal )
+bool MenüStatistik::tick(double tickVal)
 {
-    if( wiederH )
-    {
-        bool ret = wiederH->tick( tickVal );
-        if( wiederH->istBeendet() )
-            wiederH = (MenüWiederhohlung *)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;
+	if (wiederH)
+	{
+		bool ret = wiederH->tick(tickVal);
+		if (wiederH->istBeendet())
+			wiederH = (MenüWiederhohlung*)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 )
+void MenüStatistik::render(Bild& zRObj)
 {
-    if( wiederH )
-    {
-        wiederH->render( zRObj );
-        return;
-    }
-    tr->setSchriftSize( 12 );
-    Text weltScore = "Welt Score:";
-    tr->renderText( 10, 40, weltScore, zRObj, 0xFFFFFFFF );
-    Text localScore = "Dein Score:";
-    tr->renderText( 10, 170, 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 );
+	if (wiederH)
+	{
+		wiederH->render(zRObj);
+		return;
+	}
+	tr->setSchriftSize(12);
+	Text weltScore = "Welt Score:";
+	tr->renderText(10, 40, weltScore, zRObj, 0xFFFFFFFF);
+	Text localScore = "Dein Score:";
+	tr->renderText(10, 170, 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;
+	return wiederH != 0;
 }
 
 
 // Inhalt der MenüOptionen aus Menü.h
 // Konstruktor
-MenüOptionen::MenüOptionen( UIInit &uiFactory )
-    : ReferenceCounter()
+MenüOptionen::MenüOptionen(UIInit& uiFactory)
+	: ReferenceCounter()
 {
-    breiteT = initTextFeld( 310, 120, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
-    breite = initTextFeld( 440, 120, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    breite->setTastaturEreignis( _nurNummernTE );
-    höheT = initTextFeld( 310, 160, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Höhe:" );
-    höhe = initTextFeld( 440, 160, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    höhe->setTastaturEreignis( _nurNummernTE );
-    aGrößeT = initTextFeld( 310, 200, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Asteroiden Größe:" );
-    aGröße = initTextFeld( 440, 200, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    aGröße->setTastaturEreignis( _nurNummernTE );
-    timerT = initTextFeld( 310, 240, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
-    timer = initTextFeld( 440, 240, 50, 20, uiFactory, TextFeld::Style::TextFeld, "" );
-    timer->setTastaturEreignis( _nurNummernTE );
-    shipT = initTextFeld( 310, 280, 80, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Raumschiff:" );
-    ship = initAuswahlBox( 390, 280, 100, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Normal", "Enterprise" } );
-    autoKam = initKontrollKnopf( 310, 320, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Kamera drehen" );
-    fortsetzen = initKontrollKnopf( 310, 360, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
-    abbrechen = initKnopf( 310, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Abbrechen" );
-    ok = initKnopf( 405, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Ok" );
-    beendet = 0;
+	breiteT = initTextFeld(310, 120, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:");
+	breite = initTextFeld(440, 120, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	breite->setTastaturEreignis(_nurNummernTE);
+	höheT = initTextFeld(310, 160, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Höhe:");
+	höhe = initTextFeld(440, 160, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	höhe->setTastaturEreignis(_nurNummernTE);
+	aGrößeT = initTextFeld(310, 200, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Asteroiden Größe:");
+	aGröße = initTextFeld(440, 200, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	aGröße->setTastaturEreignis(_nurNummernTE);
+	timerT = initTextFeld(310, 240, 130, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:");
+	timer = initTextFeld(440, 240, 50, 20, uiFactory, TextFeld::Style::TextFeld, "");
+	timer->setTastaturEreignis(_nurNummernTE);
+	shipT = initTextFeld(310, 280, 80, 20, uiFactory, TextFeld::Style::Text | TextFeld::Style::VCenter, "Raumschiff:");
+	ship = initAuswahlBox(390, 280, 100, 20, uiFactory, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Normal", "Enterprise" });
+	autoKam = initKontrollKnopf(310, 320, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Kamera drehen");
+	fortsetzen = initKontrollKnopf(310, 360, 180, 25, uiFactory, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen");
+	abbrechen = initKnopf(310, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Abbrechen");
+	ok = initKnopf(405, 400, 85, 20, uiFactory, Knopf::Style::Sichtbar, "Ok");
+	beendet = 0;
 }
 
 // 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();
-    autoKam->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();
+	autoKam->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( "1600" );
-    if( opd->wertExistiert( "Breite" ) )
-        breite->setText( Text() += (int)*opd->zWert( "Breite" ) );
-    else
-        opd->addWert( "Breite", "1600" );
-    höhe->setText( "1000" );
-    if( opd->wertExistiert( "Höhe" ) )
-        höhe->setText( Text() += (int)*opd->zWert( "Höhe" ) );
-    else
-        opd->addWert( "Höhe", "1000" );
-    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" );
-    autoKam->removeStyle( KontrollKnopf::Style::Selected );
-    if( opd->wertExistiert( "AutoKam" ) )
-        autoKam->setStyle( KontrollKnopf::Style::Selected, (int)*opd->zWert( "AutoKam" ) != 0 );
-    else
-        opd->addWert( "AutoKam", "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("1600");
+	if (opd->wertExistiert("Breite"))
+		breite->setText(Text() += (int)*opd->zWert("Breite"));
+	else
+		opd->addWert("Breite", "1600");
+	höhe->setText("1000");
+	if (opd->wertExistiert("Höhe"))
+		höhe->setText(Text() += (int)*opd->zWert("Höhe"));
+	else
+		opd->addWert("Höhe", "1000");
+	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((int)*opd->zWert("Ship"));
+	else
+		opd->addWert("Ship", "0");
+	autoKam->removeStyle(KontrollKnopf::Style::Selected);
+	if (opd->wertExistiert("AutoKam"))
+		autoKam->setStyle(KontrollKnopf::Style::Selected, (int)*opd->zWert("AutoKam") != 0);
+	else
+		opd->addWert("AutoKam", "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::doPublicMausEreignis( MausEreignis &me )
+void MenüOptionen::doPublicMausEreignis(MausEreignis& me)
 {
-    breite->doPublicMausEreignis( me );
-    höhe->doPublicMausEreignis( me );
-    aGröße->doPublicMausEreignis( me );
-    timer->doPublicMausEreignis( me );
-    ship->doPublicMausEreignis( me );
-    autoKam->doPublicMausEreignis( me );
-    fortsetzen->doPublicMausEreignis( me );
-    bool vera = me.verarbeitet;
-    abbrechen->doPublicMausEreignis( me );
-    if( !vera && me.verarbeitet && me.id == ME_RLinks )
-        beendet = 1;
-    vera = me.verarbeitet;
-    ok->doPublicMausEreignis( 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( "800" );
-        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( "AutoKam" ) )
-            opd->setWert( "AutoKam", Text() += (int)autoKam->hatStyle( KontrollKnopf::Style::Selected ) );
-        else
-            opd->addWert( "AutoKam", Text() += (int)autoKam->hatStyle( KontrollKnopf::Style::Selected ) );
-        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->doPublicMausEreignis(me);
+	höhe->doPublicMausEreignis(me);
+	aGröße->doPublicMausEreignis(me);
+	timer->doPublicMausEreignis(me);
+	ship->doPublicMausEreignis(me);
+	autoKam->doPublicMausEreignis(me);
+	fortsetzen->doPublicMausEreignis(me);
+	bool vera = me.verarbeitet;
+	abbrechen->doPublicMausEreignis(me);
+	if (!vera && me.verarbeitet && me.id == ME_RLinks)
+		beendet = 1;
+	vera = me.verarbeitet;
+	ok->doPublicMausEreignis(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("800");
+		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("AutoKam"))
+			opd->setWert("AutoKam", Text() += (int)autoKam->hatStyle(KontrollKnopf::Style::Selected));
+		else
+			opd->addWert("AutoKam", Text() += (int)autoKam->hatStyle(KontrollKnopf::Style::Selected));
+		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 )
+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 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 |= autoKam->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 |= autoKam->tick(tickVal);
+	ret |= fortsetzen->tick(tickVal);
+	ret |= abbrechen->tick(tickVal);
+	ret |= ok->tick(tickVal);
+	return ret;
 }
 
-void MenüOptionen::render( Bild &zRObj )
+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 );
-    autoKam->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);
+	autoKam->render(zRObj);
+	fortsetzen->render(zRObj);
+	abbrechen->render(zRObj);
+	ok->render(zRObj);
+	ship->render(zRObj);
 }
 
 // constant
 bool MenüOptionen::istBeendet() const
 {
-    return beendet;
+	return beendet;
 }
 
 
 // Inhalt der Menü Klasse aus Menü.h
 // Konstruktor
-Menü::Menü( UIInit &uiFactory, KSGClient::MinigameServerClient *klient )
-    : ReferenceCounter()
+Menü::Menü(UIInit& uiFactory, KSGClient::MinigameServerClient* klient)
+	: ReferenceCounter()
 {
-    spielen = initKnopf( 350, 180, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Spielen" );
-    spielenF = new MenüSpiel( uiFactory, dynamic_cast<KSGClient::MinigameServerClient *>( klient->getThis() ) );
-    optionen = initKnopf( 350, 220, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Optionen" );
-    optionenF = new MenüOptionen( uiFactory );
-    statistik = initKnopf( 350, 260, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Statistik" );
-    statistikF = new MenüStatistik( uiFactory, klient );
-    beenden = initKnopf( 350, 300, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden" );
-    ram = new LRahmen();
-    ram->setFarbe( 0xFFFFFFFF );
-    beendet = 0;
-    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();
+	spielen = initKnopf(350, 180, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Spielen");
+	spielenF = new MenüSpiel(uiFactory, dynamic_cast<KSGClient::MinigameServerClient*>(klient->getThis()));
+	optionen = initKnopf(350, 220, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Optionen");
+	optionenF = new MenüOptionen(uiFactory);
+	statistik = initKnopf(350, 260, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Statistik");
+	statistikF = new MenüStatistik(uiFactory, klient);
+	beenden = initKnopf(350, 300, 100, 20, uiFactory, Knopf::Style::Sichtbar, "Beenden");
+	ram = new LRahmen();
+	ram->setFarbe(0xFFFFFFFF);
+	beendet = 0;
+	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();
 }
 
 // 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ü::doPublicMausEreignis( MausEreignis &me )
+void Menü::doPublicMausEreignis(MausEreignis& me)
 {
-    switch( status )
-    {
-    case 0:
-        if( 1 )
-        {
-            bool vera = me.verarbeitet;
-            spielen->doPublicMausEreignis( me );
-            if( !vera && me.verarbeitet && me.id == ME_RLinks )
-            {
-                spielenF->reset();
-                status = 3;
-            }
-            vera = me.verarbeitet;
-            optionen->doPublicMausEreignis( me );
-            if( !vera && me.verarbeitet && me.id == ME_RLinks )
-            {
-                optionenF->reset();
-                status = 1;
-            }
-            vera = me.verarbeitet;
-            statistik->doPublicMausEreignis( me );
-            if( !vera && me.verarbeitet && me.id == ME_RLinks )
-            {
-                statistikF->reset();
-                status = 2;
-            }
-            vera = me.verarbeitet;
-            beenden->doPublicMausEreignis( me );
-            if( !vera && me.verarbeitet && me.id == ME_RLinks )
-                beendet = 1;
-        }
-        break;
-    case 1:
-        optionenF->doPublicMausEreignis( me );
-        break;
-    case 2:
-        statistikF->doPublicMausEreignis( me );
-        break;
-    case 3:
-        spielenF->doPublicMausEreignis( me );
-    }
+	switch (status)
+	{
+	case 0:
+		if (1)
+		{
+			bool vera = me.verarbeitet;
+			spielen->doPublicMausEreignis(me);
+			if (!vera && me.verarbeitet && me.id == ME_RLinks)
+			{
+				spielenF->reset();
+				status = 3;
+			}
+			vera = me.verarbeitet;
+			optionen->doPublicMausEreignis(me);
+			if (!vera && me.verarbeitet && me.id == ME_RLinks)
+			{
+				optionenF->reset();
+				status = 1;
+			}
+			vera = me.verarbeitet;
+			statistik->doPublicMausEreignis(me);
+			if (!vera && me.verarbeitet && me.id == ME_RLinks)
+			{
+				statistikF->reset();
+				status = 2;
+			}
+			vera = me.verarbeitet;
+			beenden->doPublicMausEreignis(me);
+			if (!vera && me.verarbeitet && me.id == ME_RLinks)
+				beendet = 1;
+		}
+		break;
+	case 1:
+		optionenF->doPublicMausEreignis(me);
+		break;
+	case 2:
+		statistikF->doPublicMausEreignis(me);
+		break;
+	case 3:
+		spielenF->doPublicMausEreignis(me);
+	}
 }
 
-void Menü::doTastaturEreignis( TastaturEreignis &te )
+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 )
+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 )
+void Menü::render(Bild& 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, 320 );
-        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 );
-    }
+	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, 320);
+		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;
 }