Asteroiden hinzugefügt

Asteroids/Asteroids.vcxproj

@@ -187,6 +187,8 @@
     <ClInclude Include="SpielStatistik\SpielStatistikDaten.h" />
     <ClInclude Include="SpielStatistik\Tabelle\StatistikTabelle.h" />
     <ClInclude Include="Netzwerk\STKNachricht.h" />
+    <ClInclude Include="Spiel\Asteroid\Asteroid.h" />
+    <ClInclude Include="Spiel\Asteroid\Pixel.h" />
     <ClInclude Include="Spiel\Bestenliste\Bestenliste.h" />
     <ClInclude Include="Spiel\Chat\Chat.h" />
     <ClInclude Include="Spiel\Define.h" />
@@ -218,6 +220,8 @@
     <ClCompile Include="SpielStatistik\Chat\StatistikChat.cpp" />
     <ClCompile Include="SpielStatistik\SpielStatistik.cpp" />
     <ClCompile Include="SpielStatistik\Tabelle\StatistikTabelle.cpp" />
+    <ClCompile Include="Spiel\Asteroid\Asteroid.cpp" />
+    <ClCompile Include="Spiel\Asteroid\Pixel.cpp" />
     <ClCompile Include="Spiel\Bestenliste\Bestenliste.cpp" />
     <ClCompile Include="Spiel\Chat\Chat.cpp" />
     <ClCompile Include="Spiel\Ende\Ende.cpp" />

Asteroids/Asteroids.vcxproj.filters

@@ -108,6 +108,12 @@
     <ClInclude Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="Spiel\Asteroid\Asteroid.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel\Asteroid\Pixel.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Initialisierung\Initialisierung.cpp">
@@ -200,5 +206,11 @@
     <ClCompile Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Spiel\Asteroid\Asteroid.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel\Asteroid\Pixel.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Asteroids/Spiel/Asteroid/Asteroid.cpp

@@ -0,0 +1,92 @@
+#include "Asteroid.h"
+#include <Random.h>
+
+Asteroid::Asteroid( int id, Vertex pos, Vertex speed, float rot, float rotS, Model2DData *m2d, Textur2D *textur )
+    : Model2DObject()
+{
+    this->id = id;
+    setPosition( pos );
+    setSpeed( speed );
+    setDrehung( rot );
+    setDrehungSpeed( rotS );
+    setModel( m2d );
+    setTextur( textur );
+    alive = true;
+    save();
+}
+
+bool Asteroid::tick( const WeltInfo &info, double zeit )
+{
+    if( !alive )
+        size -= (float)zeit;
+    return __super::tick( info, zeit );
+}
+
+Asteroid *Asteroid::split( Vertex pos, Vertex speed, __int64 seed, int asteroidId )
+{
+    Polygon2D a, b;
+    Punkt pa, pb;
+    Vertex hp;
+    RandomGenerator randG;
+    randG.setSeed( seed );
+    if( calcHitPoint( pos - speed, speed, hp ) )
+    {
+        if( zModel()->split( getObjectPos( hp ), getObjectDir( speed ) * 0.1f, ( char* )"", a, b, pa, pb, [ &randG ]() -> double
+        {
+            return randG.rand();
+        } ) )
+        {
+            impuls( pos - speed, speed * 0.05f );
+            hp = ( hp * getSize() ).rotation( getDrehung() ) + getPosition();
+            Vertex pav = ( (Vertex)pa ).rotation( getDrehung() ) + getPosition();
+            Vertex pbv = ( (Vertex)pb ).rotation( getDrehung() ) + getPosition();
+            Array< Polygon2D > *npaA = new Array< Polygon2D >();
+            npaA->add( a );
+            Model2DData *npdA = new Model2DData();
+            npdA->erstelleModell( npaA );
+            Array< Polygon2D > *npaB = new Array< Polygon2D >();
+            npaB->add( b );
+            Model2DData *npdB = new Model2DData();
+            npdB->erstelleModell( npaB );
+            Asteroid *astr = new Asteroid( asteroidId, pav, getSpeed() * (float)randG.rand(), getDrehung(), getDrehungSpeed() * (float)randG.rand(), npdA, getTextur() );
+            setSpeed( getSpeed() * (float)randG.rand() );
+            setDrehungSpeed( getDrehungSpeed() * (float)randG.rand() );
+            setModel( npdB );
+            setPosition( pbv );
+            return astr;
+        }
+    }
+    return 0;
+}
+
+void Asteroid::save()
+{
+    backup.pos = getPosition();
+    backup.speed = getSpeed();
+    backup.rotation = getDrehung();
+    backup.rSpeed = getDrehungSpeed();
+}
+
+void Asteroid::load()
+{
+    setPosition( backup.pos );
+    setSpeed( backup.speed );
+    setDrehung( backup.rotation );
+    setDrehungSpeed( backup.rSpeed );
+}
+
+void Asteroid::setDead()
+{
+    alive = false;
+    collision = false;
+}
+
+bool Asteroid::isDead() const
+{
+    return size <= 0;
+}
+
+int Asteroid::getId() const
+{
+    return id;
+}

Asteroids/Spiel/Asteroid/Asteroid.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <Model2D.h>
+
+using namespace Framework;
+
+class Asteroid : public Model2DObject
+{
+private:
+    int id;
+    struct AsteroidDataSave
+    {
+        float rSpeed;
+        Vertex pos;
+        Vertex speed;
+        float rotation;
+    };
+    AsteroidDataSave backup;
+    bool alive;
+public:
+    Asteroid( int id, Vertex pos, Vertex speed, float rot, float rotS, Model2DData *m2d, Textur2D *textur );
+    Asteroid *split( Vertex pos, Vertex speed, __int64 seed, int asteroidId );
+    bool tick( const WeltInfo &info, double zeit ) override;
+    void save();
+    void load();
+    void setDead();
+    bool isDead() const;
+    int getId() const;
+};

Asteroids/Spiel/Asteroid/Pixel.cpp

@@ -0,0 +1,67 @@
+#include "Pixel.h"
+#include <Bild.h>
+
+Pixel::Pixel( Vertex pos, Vertex speed, float ep, int id )
+    : Object2D()
+{
+    setPosition( pos );
+    setSpeed( speed );
+    this->ep = ep;
+    pixelId = id;
+    collision = false;
+    save();
+}
+
+bool Pixel::tick( const WeltInfo &info, double zeit )
+{
+    ep -= (float)zeit;
+    return __super::tick( info, zeit ) || 1;
+}
+
+void Pixel::render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName )
+{
+    Mat3< float > mat = kamMat * getObjectMatrix();
+    Vertex p = mat * Vertex( 0, 0 );
+    Vertex p2 = mat * Vertex( ep / 5, 0 );
+    zRObj.fillCircle( (int)p.x, (int)p.y, (int)( p2 - p ).getLength() + 1, 0xFFFFFFFF );
+}
+
+Rect2< float > Pixel::getBoundingBox() const
+{
+    Rect2< float > r = Rect2< float >();
+    r.topLeft.x = -(ep / 5 + 1);
+    r.topLeft.y = -(ep / 5 + 1);
+    r.bottomRight.x = ep / 5 + 1;
+    r.bottomRight.y = ep / 5 + 1;
+    r.topLeft = getWorldPos( r.topLeft );
+    r.bottomRight = getWorldPos( r.bottomRight );
+    return r;
+}
+
+float Pixel::getEp() const
+{
+    return ep;
+}
+
+int Pixel::getId() const
+{
+    return pixelId;
+}
+
+void Pixel::save()
+{
+    backup.pos = getPosition();
+    backup.speed = getSpeed();
+    backup.rotation = getDrehung();
+    backup.rSpeed = getDrehungSpeed();
+    backup.oldEp = ep;
+}
+
+void Pixel::load()
+{
+    setPosition( backup.pos );
+    setSpeed( backup.speed );
+    setDrehung( backup.rotation );
+    setDrehungSpeed( backup.rSpeed );
+    ep = backup.oldEp;
+}

Asteroids/Spiel/Asteroid/Pixel.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <Welt2D.h>
+
+using namespace Framework;
+
+class Pixel : public Object2D
+{
+private:
+    float ep;
+    int pixelId;
+    struct PixelDataSave
+    {
+        float rSpeed;
+        Vertex pos;
+        Vertex speed;
+        float rotation;
+        float oldEp;
+    };
+    PixelDataSave backup;
+
+public:
+    Pixel( Vertex pos, Vertex speed, float ep, int id );
+    bool tick( const WeltInfo &info, double zeit ) override;
+    void render( Mat3< float > &kamMat, Bild &zRObj, const char *kamName ) override;
+    Rect2< float > getBoundingBox() const override;
+    float getEp() const;
+    int getId() const;
+    bool isDead() const;
+    void save();
+    void load();
+};

Asteroids/Spiel/Chat/Chat.cpp

@@ -17,7 +17,7 @@ SpielChat::SpielChat()
 	rahmen->setSize( 450, 200 );
 	rahmen->setPosition( 10, BildschirmGröße().y - 210 );
 	verlauf = new TextFeld();
-	verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen ) );
+	verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund ) );
 	verlauf->setText( "" );
 	verlauf->setSchriftFarbe( 0xFFFFFFFF );
 	verlauf->setSchriftSize( 12 );

Asteroids/Spiel/Karte/Karte.cpp

@@ -79,7 +79,7 @@ void Karte::ladeMap( Datei *zDatei, int mapId, KSGClient::SpielServerClient *zSp
     for( int i = 0; i < ressourceAnz; i++ )
     {
         ressources->add( new RessourceStr( zDatei, mapId, zGamePath ) );
-        zSpielKlient->setLadenProzent( 15 + (int)( 65 * ( (double)( i + 1 ) / ressourceAnz ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 15 + (int)( 35 * ( (double)( i + 1 ) / ressourceAnz ) + 0.5 ) );
     }
     zDatei->lese( (char*)&größe.x, 4 );
     zDatei->lese( (char*)&größe.y, 4 );
@@ -88,17 +88,17 @@ void Karte::ladeMap( Datei *zDatei, int mapId, KSGClient::SpielServerClient *zSp
     for( int i = 0; i < objektAnzahl; i++ )
     {
         objekte->add( new ObjektStr( zDatei ) );
-        zSpielKlient->setLadenProzent( 70 + (int)( 10 * ( (double)( i + 1 ) / objektAnzahl ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 50 + (int)( 10 * ( (double)( i + 1 ) / objektAnzahl ) + 0.5 ) );
     }
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         spieler->add( new SpielerStr( zDatei ) );
-        zSpielKlient->setLadenProzent( 80 + (int)( 5 * ( (double)( i + 1 ) / spielerAnzahl ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 60 + (int)( 5 * ( (double)( i + 1 ) / spielerAnzahl ) + 0.5 ) );
     }
     for( int i = 0; i < teamAnzahl; i++ )
     {
         teams->add( new TeamStr( zDatei ) );
-        zSpielKlient->setLadenProzent( 85 + (int)( 5 * ( (double)( i + 1 ) / teamAnzahl ) + 0.5 ) );
+        zSpielKlient->setLadenProzent( 65 + (int)( 5 * ( (double)( i + 1 ) / teamAnzahl ) + 0.5 ) );
     }
 }
 

Asteroids/Spiel/SpielKlasse.cpp

@@ -8,27 +8,29 @@
 #include "SpielerGUI/SpielerGUI.h"
 #include "Define.h"
 #include <Animation.h>
+#include <Textur2D.h>
 
 // Inhalt der SpielKlasse Klasse aus SpielKlasse.h
 // Konstruktor
 SpielKlasse::SpielKlasse()
 {
-	spielZeit = -1;
-	rZeit = 0;
-	rendern = 0;
-	stkn = new RCArray< STKNachricht >();
-	stkna = 0;
-	schrift = 0;
-	time_t t;
-	time( &t );
-	srand( (unsigned int)t );
-	infoKlient = 0;
-	spielKlient = 0;
-	spieler = new RCArray< Spieler >();
-	teams = new RCArray< Team >();
-	objekte = new RCArray< SpielObjekt >();
+    spielZeit = -1;
+    rZeit = 0;
+    rendern = 0;
+    stkn = new RCArray< STKNachricht >();
+    stkna = 0;
+    schrift = 0;
+    time_t t;
+    time( &t );
+    srand( (unsigned int)t );
+    infoKlient = 0;
+    spielKlient = 0;
+    spieler = new RCArray< Spieler >();
+    asteroids = new RCArray< Asteroid >();
+    teams = new RCArray< Team >();
+    objekte = new RCArray< SpielObjekt >();
     deads = new RCArray< DeadPlayer >();
-	screen = 0;
+    screen = 0;
     welt = new Welt2D();
     welt->setCircular( 1 );
     welt->setAirResistance( 0.001f );
@@ -40,22 +42,25 @@ SpielKlasse::SpielKlasse()
     minimap->setStyle( ZeichnungHintergrund::Style::Sichtbar | ZeichnungHintergrund::Style::Rahmen );
     minimap->setLinienRahmenFarbe( 0xFFFFFFFF );
     minimap->setName( "minimap" );
-	spielerAnzahl = 0;
-	karteId = 0;
-	ladenProzent = 0;
-	spielerNummer = 0;
-	map = 0;
-	end = 0;
-	chat = new SpielChat();
-	tasten = new char[ 256 ];
-	for( int i = 0; i < 256; i++ )
-		tasten[ i ] = 0;
-	bestenliste = 0;
-	schüsse = new RCArray< Laser >();
-	shipGUI = 0;
-	spielPause = 1;
+    spielerAnzahl = 0;
+    karteId = 0;
+    ladenProzent = 0;
+    spielerNummer = 0;
+    map = 0;
+    end = 0;
+    chat = new SpielChat();
+    tasten = new char[ 256 ];
+    for( int i = 0; i < 256; i++ )
+        tasten[ i ] = 0;
+    bestenliste = 0;
+    schüsse = new RCArray< Laser >();
+    shipGUI = 0;
+    spielPause = 1;
     setKam = 0;
-	ref = 1;
+    asteroidModels = new RCArray< Model2DData >();
+    asteroidTextures = new RCArray< Textur2D >();
+    pixel = new RCArray< Pixel >();
+    ref = 1;
     save();
 }
 
@@ -71,40 +76,44 @@ SpielKlasse::~SpielKlasse()
     minimap->release();
     welt->release();
     deads->release();
-	stkn->release();
-	if( schrift )
-		schrift->release();
-	if( infoKlient )
-		infoKlient->release();
-	if( spielKlient )
-		spielKlient->release();
-	if( kam )
-		kam->release();
-	if( end )
-		end->release();
-	if( bestenliste )
-		bestenliste->release();
-	if( shipGUI )
-		shipGUI->release();
-	chat->relese();
-	spieler->release();
-	teams->release();
-	objekte->release();
-	if( screen )
-		screen->release();
-	schüsse->release();
-	delete[] tasten;
+    stkn->release();
+    if( schrift )
+        schrift->release();
+    if( infoKlient )
+        infoKlient->release();
+    if( spielKlient )
+        spielKlient->release();
+    if( kam )
+        kam->release();
+    if( end )
+        end->release();
+    if( bestenliste )
+        bestenliste->release();
+    if( shipGUI )
+        shipGUI->release();
+    chat->relese();
+    spieler->release();
+    asteroids->release();
+    asteroidModels->release();
+    asteroidTextures->release();
+    teams->release();
+    objekte->release();
+    if( screen )
+        screen->release();
+    schüsse->release();
+    pixel->release();
+    delete[] tasten;
 }
 
 // privat
 bool SpielKlasse::istAmLeben() const
 {
-	for( int i = 0; i < spielerAnzahl; i++ )
-	{
-		if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-			return spieler->z( i )->istAmLeben();
-	}
-	return 0;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+            return spieler->z( i )->istAmLeben();
+    }
+    return 0;
 }
 
 void SpielKlasse::goBackInTime( int zeit )
@@ -130,6 +139,10 @@ void SpielKlasse::load()
         i->load();
     for( auto i = schüsse->getIterator(); i; i++ )
         i->load();
+    for( auto i = asteroids->getIterator(); i; i++ )
+        i->load();
+    for( auto i = pixel->getIterator(); i; i++ )
+        i->load();
 }
 
 void SpielKlasse::save()
@@ -139,67 +152,82 @@ void SpielKlasse::save()
         i->save();
     for( auto i = schüsse->getIterator(); i; i++ )
         i->save();
+    for( auto i = asteroids->getIterator(); i; i++ )
+        i->save();
+    for( auto i = pixel->getIterator(); i; i++ )
+        i->save();
 }
 
 void SpielKlasse::tick()
 {
     spielZeit++;
     kam->tick( TICK );
+    int asteroidAnz = asteroids->getEintragAnzahl();
+    for( int i = 0; i < asteroidAnz; i++ )
+    {
+        Asteroid *p = asteroids->z( i );
+        if( p->isDead() )
+        {
+            welt->removeObject( p );
+            asteroids->remove( i-- );
+            asteroidAnz--;
+        }
+    }
 }
 
 // nicht constant
 void SpielKlasse::lock()
 {
-	if( screen )
-		screen->lock();
+    if( screen )
+        screen->lock();
 }
 
 void SpielKlasse::unlock()
 {
-	if( screen )
-		screen->unlock();
+    if( screen )
+        screen->unlock();
 }
 
 void SpielKlasse::setSchrift( Schrift *schrift )
 {
-	if( this->schrift )
-		this->schrift->release();
-	this->schrift = schrift;
-	chat->setSchrift( schrift );
-	if( !bestenliste )
-		bestenliste = new Bestenliste( schrift->getThis() );
-	if( !shipGUI )
-		shipGUI = new SpielerGUI( schrift );
+    if( this->schrift )
+        this->schrift->release();
+    this->schrift = schrift;
+    chat->setSchrift( schrift );
+    if( !bestenliste )
+        bestenliste = new Bestenliste( schrift->getThis() );
+    if( !shipGUI )
+        shipGUI = new SpielerGUI( schrift );
 }
 
 void SpielKlasse::setBildschirm( Bildschirm *screen )
 {
-	this->screen = screen;
+    this->screen = screen;
 }
 
 void SpielKlasse::nachricht( int län, char *bytes )
 {
-	if( !län )
-		return;
-	lock();
-	stkn->add( new STKNachricht( län, bytes ), stkna );
-	stkna++;
-	unlock();
+    if( !län )
+        return;
+    lock();
+    stkn->add( new STKNachricht( län, bytes ), stkna );
+    stkna++;
+    unlock();
 }
 
 void SpielKlasse::setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient )
 {
-	if( this->infoKlient )
-		this->infoKlient->release();
-	this->infoKlient = infoKlient;
-	if( this->spielKlient )
-		this->spielKlient->release();
-	this->spielKlient = spielKlient;
+    if( this->infoKlient )
+        this->infoKlient->release();
+    this->infoKlient = infoKlient;
+    if( this->spielKlient )
+        this->spielKlient->release();
+    this->spielKlient = spielKlient;
 }
 
 void SpielKlasse::setKarteId( int karteId )
 {
-	this->karteId = karteId;
+    this->karteId = karteId;
 }
 
 void SpielKlasse::ladeDaten()
@@ -235,25 +263,25 @@ void SpielKlasse::ladeDaten()
     flammenBurn->ladeAnimation( flammenLTDB.getThis() );
     flammenBurn->setFPS( 60 );
     flammenBurn->setWiederhohlend( 1 );
-	map = new Karte();
+    map = new Karte();
     Text *mapPf = new Text( "data/tmp/Karten/" );
     mapPf->append( karteId );
     mapPf->append( "/spiel/data/data.sts" );
-	Datei *stsD = new Datei();
-	stsD->setDatei( mapPf->getText() );
-	stsD->open( Datei::Style::lesen );
-	map->ladeSts( stsD );
-	stsD->close();
-	stsD->release();
-	spielKlient->setLadenProzent( 15 );
-	mapPf->ersetzen( mapPf->getLength() - 3, mapPf->getLength(), "map" );
-	Datei *mapD = new Datei();
-	mapD->setDatei( mapPf->getText() );
-	mapD->open( Datei::Style::lesen );
-	map->ladeMap( mapD, karteId, spielKlient, gamePath );
-	mapD->close();
-	mapD->release();
-	mapPf->release();
+    Datei *stsD = new Datei();
+    stsD->setDatei( mapPf->getText() );
+    stsD->open( Datei::Style::lesen );
+    map->ladeSts( stsD );
+    stsD->close();
+    stsD->release();
+    spielKlient->setLadenProzent( 15 );
+    mapPf->ersetzen( mapPf->getLength() - 3, mapPf->getLength(), "map" );
+    Datei *mapD = new Datei();
+    mapD->setDatei( mapPf->getText() );
+    mapD->open( Datei::Style::lesen );
+    map->ladeMap( mapD, karteId, spielKlient, gamePath );
+    mapD->close();
+    mapD->release();
+    mapPf->release();
     for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
     {
         Spieler *s = map->createSpieler( i, schrift, infoKlient, flammenStart, flammenBurn );
@@ -261,508 +289,373 @@ void SpielKlasse::ladeDaten()
     }
     flammenStart->release();
     flammenBurn->release();
-	spielKlient->setLadenProzent( 95 );
+    spielKlient->setLadenProzent( 75 );
     for( int i = 0; i < map->getZeichnungAnzahl(); i++ )
     {
         SpielObjekt *obj = map->createObjekt( i, schrift );
         welt->addObject( obj->getThis() );
         objekte->set( obj, i );
     }
-	bestenliste->setTeamAnzahl( map->getMaxTeamAnzahl() );
+    bestenliste->setTeamAnzahl( map->getMaxTeamAnzahl() );
     welt->setSize( map->getSize().x, map->getSize().y );
     welt->setSize( 1 );
-	spielKlient->setLadenProzent( 100 );
+    spielKlient->setLadenProzent( 80 );
+    M2Datei astroidModels;
+    Text aModelPath = gamePath->getText();
+    aModelPath += "/models/asteroids.m2";
+    astroidModels.setPfad( aModelPath );
+    astroidModels.leseDaten();
+    int anz = astroidModels.getModelAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        this->asteroidModels->add( astroidModels.ladeModel( astroidModels.zModelName( i )->getText() ) );
+    }
+    spielKlient->setLadenProzent( 85 );
+    LTDBDatei asteroidTexturD;
+    Text aTexturPfad = gamePath->getText();
+    aTexturPfad += "/bilder/asteroids.ltdb";
+    asteroidTexturD.setDatei( aTexturPfad.getThis() );
+    asteroidTexturD.leseDaten( 0 );
+    for( int i = 0; i < anz; i++ )
+    {
+        Text *name = new Text( astroidModels.zModelName( i )->getText() );
+        name->append( ".png" );
+        Textur2D *txt = new Textur2D();
+        txt->setTexturZ( asteroidTexturD.laden( 0, name ) );
+        asteroidTextures->add( txt );
+    }
+    spielKlient->setLadenProzent( 100 );
 }
 
 void SpielKlasse::doMausEreignis( MausEreignis &me )
 {
-	if( end )
-	{
-		end->doMausEreignis( me );
-		return;
-	}
-	if( !istAmLeben() )
-		me.verarbeitet = 1;
-	int skill = shipGUI->doMausEreignis( me );
-	if( skill >= 0 )
-	{
-		char *bytes = new char[ 2 ];
-		bytes[ 0 ] = 9;
-		bytes[ 1 ] = (char)skill;
-		spielKlient->spielNachricht( 2, bytes );
-	}
-	chat->doMausEreignis( me );
-	if( bestenliste )
-		bestenliste->doMausEreignis( me );
+    if( end )
+    {
+        end->doMausEreignis( me );
+        return;
+    }
+    if( !istAmLeben() )
+        me.verarbeitet = 1;
+    int skill = shipGUI->doMausEreignis( me );
+    if( skill >= 0 )
+    {
+        char *bytes = new char[ 2 ];
+        bytes[ 0 ] = 9;
+        bytes[ 1 ] = (char)skill;
+        spielKlient->spielNachricht( 2, bytes );
+    }
+    chat->doMausEreignis( me );
+    if( bestenliste )
+        bestenliste->doMausEreignis( me );
 }
 
 void SpielKlasse::doTastaturEreignis( TastaturEreignis &te )
 {
-	bestenliste->doTastaturEreignis( te );
+    bestenliste->doTastaturEreignis( te );
     if( end )
     {
         end->doTastaturEreignis( te );
         return;
     }
-	if( !chat->istAktiv() )
-	{
-		if( istAmLeben() )
-		{
-			if( te.id == TE_Press )
-			{
-				switch( te.taste )
-				{
-				case 'w':
-				case 'W':
-				case T_Oben:
-					if( !tasten[ T_Oben ] )
-					{
-						tasten[ T_Oben ] = 1;
-						char byte = 0;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				case 'a':
-				case 'A':
-				case T_Links:
-					if( !tasten[ T_Links ] )
-					{
-						tasten[ T_Links ] = 1;
-						char byte = 2;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				case 'd':
-				case 'D':
-				case T_Rechts:
-					if( !tasten[ T_Rechts ] )
-					{
-						tasten[ T_Rechts ] = 1;
-						char byte = 4;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				case T_Space:
-					if( !tasten[ T_Space ] )
-					{
-						tasten[ T_Space ] = 1;
-						char byte = 6;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				}
-			}
-			if( te.id == TE_Release )
-			{
-				switch( te.taste )
-				{
-				case 'w':
-				case 'W':
-				case T_Oben:
-					if( tasten[ T_Oben ] )
-					{
-						tasten[ T_Oben ] = 0;
-						char byte = 1;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				case 'a':
-				case 'A':
-				case T_Links:
-					if( tasten[ T_Links ] )
-					{
-						tasten[ T_Links ] = 0;
-						char byte = 3;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				case 'd':
-				case 'D':
-				case T_Rechts:
-					if( tasten[ T_Rechts ] )
-					{
-						tasten[ T_Rechts ] = 0;
-						char byte = 5;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				case T_Space:
-					if( tasten[ T_Space ] )
-					{
-						tasten[ T_Space ] = 0;
-						char byte = 7;
-						spielKlient->spielNachricht( 1, &byte );
-						te.verarbeitet = 1;
-					}
-					break;
-				}
-			}
-		}
-		else
-		{
-			if( te.id == TE_Press )
-			{
-				switch( te.taste )
-				{
-				case T_Links:
-					kam->setPosition( kam->getPosition() + Vertex( -2, 0 ) );
-					te.verarbeitet = 1;
-					break;
-				case T_Oben:
+    if( !chat->istAktiv() )
+    {
+        if( istAmLeben() )
+        {
+            if( te.id == TE_Press )
+            {
+                switch( te.taste )
+                {
+                case 'w':
+                case 'W':
+                case T_Oben:
+                    if( !tasten[ T_Oben ] )
+                    {
+                        tasten[ T_Oben ] = 1;
+                        char byte = 0;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                case 'a':
+                case 'A':
+                case T_Links:
+                    if( !tasten[ T_Links ] )
+                    {
+                        tasten[ T_Links ] = 1;
+                        char byte = 2;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                case 'd':
+                case 'D':
+                case T_Rechts:
+                    if( !tasten[ T_Rechts ] )
+                    {
+                        tasten[ T_Rechts ] = 1;
+                        char byte = 4;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                case T_Space:
+                    if( !tasten[ T_Space ] )
+                    {
+                        tasten[ T_Space ] = 1;
+                        char byte = 6;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                }
+            }
+            if( te.id == TE_Release )
+            {
+                switch( te.taste )
+                {
+                case 'w':
+                case 'W':
+                case T_Oben:
+                    if( tasten[ T_Oben ] )
+                    {
+                        tasten[ T_Oben ] = 0;
+                        char byte = 1;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                case 'a':
+                case 'A':
+                case T_Links:
+                    if( tasten[ T_Links ] )
+                    {
+                        tasten[ T_Links ] = 0;
+                        char byte = 3;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                case 'd':
+                case 'D':
+                case T_Rechts:
+                    if( tasten[ T_Rechts ] )
+                    {
+                        tasten[ T_Rechts ] = 0;
+                        char byte = 5;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                case T_Space:
+                    if( tasten[ T_Space ] )
+                    {
+                        tasten[ T_Space ] = 0;
+                        char byte = 7;
+                        spielKlient->spielNachricht( 1, &byte );
+                        te.verarbeitet = 1;
+                    }
+                    break;
+                }
+            }
+        }
+        else
+        {
+            if( te.id == TE_Press )
+            {
+                switch( te.taste )
+                {
+                case T_Links:
+                    kam->setPosition( kam->getPosition() + Vertex( -2, 0 ) );
+                    te.verarbeitet = 1;
+                    break;
+                case T_Oben:
                     kam->setPosition( kam->getPosition() + Vertex( 0, -2 ) );
-					te.verarbeitet = 1;
-					break;
-				case T_Rechts:
+                    te.verarbeitet = 1;
+                    break;
+                case T_Rechts:
                     kam->setPosition( kam->getPosition() + Vertex( 2, 0 ) );
-					te.verarbeitet = 1;
-					break;
-				case T_Unten:
+                    te.verarbeitet = 1;
+                    break;
+                case T_Unten:
                     kam->setPosition( kam->getPosition() + Vertex( 0, 2 ) );
-					te.verarbeitet = 1;
-					break;
-				}
-			}
-		}
-	}
-	if( !te.verarbeitet )
-		chat->doTastaturEreignis( te, spielKlient );
+                    te.verarbeitet = 1;
+                    break;
+                }
+            }
+        }
+    }
+    if( !te.verarbeitet )
+        chat->doTastaturEreignis( te, spielKlient );
 }
 
 void SpielKlasse::stknVerarbeitung()
 {
-	lock();
-	for( int i = 0; i < stkna; i++ )
-	{
-		STKNachricht *n = stkn->z( i );
-		int zeit = n->getSpielZeit();
+    lock();
+    for( int i = 0; i < stkna; i++ )
+    {
+        STKNachricht *n = stkn->z( i );
+        int zeit = n->getSpielZeit();
         while( zeit > spielZeit )
             tick();
-		int län = n->getLength();
-		char *bytes = n->getNachricht();
-		län--;
-		int sNum = 0;
+        int län = n->getLength();
+        char *bytes = n->getNachricht();
+        län--;
+        int sNum = 0;
         int presence = spielZeit;
-        Vertex pos;
-        Vertex speed;
-        float rot;
-        float rotS;
         if( presence > zeit + 10 )
             presence = zeit + 10; // maximale zeitdifferenz von client und server
-		switch( bytes[ 0 ] )
-		{
-		case 0: // spieler drückt gas
-			bytes++;
-			sNum = *(int*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rot = *(float*)bytes;
-            bytes += 4;
+        switch( bytes[ 0 ] )
+        {
+        case 0: // spieler drückt gas
+            bytes++;
+            sNum = *(int*)bytes;
             län -= 4;
-            rotS = *(float*)bytes;
-			län -= 4;
             goBackInTime( zeit );
-			for( auto i = spieler->getIterator(); i; i++ )
-			{
-				if( i->getSpielerNummer() == sNum )
+            for( auto i = spieler->getIterator(); i; i++ )
+            {
+                if( i->getSpielerNummer() == sNum )
                 {
-                    if( i->getPosition() != pos )
-                        chat->addNachricht( Text( "asynchrony detected, position difference: " ) += ( i->getPosition() - pos ).getLength(), 0xFFFF0000 );
-                    if( i->getSpeed() != speed )
-                        chat->addNachricht( Text( "asynchrony detected, speed difference: " ) += ( i->getSpeed() - speed ).getLength(), 0xFFFF0000 );
-                    if( i->getDrehung() != rot )
-                        chat->addNachricht( Text( "asynchrony detected, rot difference: " ) += ( i->getDrehung() - rot ), 0xFFFF0000 );
-                    if( i->getDrehungSpeed() != rotS )
-                        chat->addNachricht( Text( "asynchrony detected, rotS difference: " ) += ( i->getDrehungSpeed() - rotS ), 0xFFFF0000 );
                     i->setTastataturStatus( T_GAS, 1 );
                 }
-			}
+            }
             goToPresence( presence );
-			break;
-		case 1: // spieler lässt gas los
-			bytes++;
-			sNum = *(int*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rot = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rotS = *(float*)bytes;
+            break;
+        case 1: // spieler lässt gas los
+            bytes++;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             for( auto i = spieler->getIterator(); i; i++ )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
-                    if( i->getPosition() != pos )
-                        chat->addNachricht( Text( "asynchrony detected, position difference: " ) += ( i->getPosition() - pos ).getLength(), 0xFFFF0000 );
-                    if( i->getSpeed() != speed )
-                        chat->addNachricht( Text( "asynchrony detected, speed difference: " ) += ( i->getSpeed() - speed ).getLength(), 0xFFFF0000 );
-                    if( i->getDrehung() != rot )
-                        chat->addNachricht( Text( "asynchrony detected, rot difference: " ) += ( i->getDrehung() - rot ), 0xFFFF0000 );
-                    if( i->getDrehungSpeed() != rotS )
-                        chat->addNachricht( Text( "asynchrony detected, rotS difference: " ) += ( i->getDrehungSpeed() - rotS ), 0xFFFF0000 );
                     i->setTastataturStatus( T_GAS, 0 );
                 }
             }
             goToPresence( presence );
-			break;
-		case 2: // spieler drückt rotl
-			bytes++;
-			sNum = *(int*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rot = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rotS = *(float*)bytes;
+            break;
+        case 2: // spieler drückt rotl
+            bytes++;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             for( auto i = spieler->getIterator(); i; i++ )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
-                    if( i->getPosition() != pos )
-                        chat->addNachricht( Text( "asynchrony detected, position difference: " ) += ( i->getPosition() - pos ).getLength(), 0xFFFF0000 );
-                    if( i->getSpeed() != speed )
-                        chat->addNachricht( Text( "asynchrony detected, speed difference: " ) += ( i->getSpeed() - speed ).getLength(), 0xFFFF0000 );
-                    if( i->getDrehung() != rot )
-                        chat->addNachricht( Text( "asynchrony detected, rot difference: " ) += ( i->getDrehung() - rot ), 0xFFFF0000 );
-                    if( i->getDrehungSpeed() != rotS )
-                        chat->addNachricht( Text( "asynchrony detected, rotS difference: " ) += ( i->getDrehungSpeed() - rotS ), 0xFFFF0000 );
                     i->setTastataturStatus( T_ROT_L, 1 );
                 }
             }
             goToPresence( presence );
-			break;
-		case 3: // spieler lässt rotl los
-			bytes++;
-			sNum = *(int*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rot = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rotS = *(float*)bytes;
+            break;
+        case 3: // spieler lässt rotl los
+            bytes++;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             for( auto i = spieler->getIterator(); i; i++ )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
-                    if( i->getPosition() != pos )
-                        chat->addNachricht( Text( "asynchrony detected, position difference: " ) += ( i->getPosition() - pos ).getLength(), 0xFFFF0000 );
-                    if( i->getSpeed() != speed )
-                        chat->addNachricht( Text( "asynchrony detected, speed difference: " ) += ( i->getSpeed() - speed ).getLength(), 0xFFFF0000 );
-                    if( i->getDrehung() != rot )
-                        chat->addNachricht( Text( "asynchrony detected, rot difference: " ) += ( i->getDrehung() - rot ), 0xFFFF0000 );
-                    if( i->getDrehungSpeed() != rotS )
-                        chat->addNachricht( Text( "asynchrony detected, rotS difference: " ) += ( i->getDrehungSpeed() - rotS ), 0xFFFF0000 );
                     i->setTastataturStatus( T_ROT_L, 0 );
                 }
             }
             goToPresence( presence );
-			break;
-		case 4: // spieler drückt rotr
-			bytes++;
-			sNum = *(int*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rot = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rotS = *(float*)bytes;
+            break;
+        case 4: // spieler drückt rotr
+            bytes++;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             for( auto i = spieler->getIterator(); i; i++ )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
-                    if( i->getPosition() != pos )
-                        chat->addNachricht( Text( "asynchrony detected, position difference: " ) += ( i->getPosition() - pos ).getLength(), 0xFFFF0000 );
-                    if( i->getSpeed() != speed )
-                        chat->addNachricht( Text( "asynchrony detected, speed difference: " ) += ( i->getSpeed() - speed ).getLength(), 0xFFFF0000 );
-                    if( i->getDrehung() != rot )
-                        chat->addNachricht( Text( "asynchrony detected, rot difference: " ) += ( i->getDrehung() - rot ), 0xFFFF0000 );
-                    if( i->getDrehungSpeed() != rotS )
-                        chat->addNachricht( Text( "asynchrony detected, rotS difference: " ) += ( i->getDrehungSpeed() - rotS ), 0xFFFF0000 );
                     i->setTastataturStatus( T_ROT_R, 1 );
                 }
             }
             goToPresence( presence );
-			break;
-		case 5: // spieler lässt rotr los
-			bytes++;
-			sNum = *(int*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            pos.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.x = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            speed.y = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rot = *(float*)bytes;
-            bytes += 4;
-            län -= 4;
-            rotS = *(float*)bytes;
+            break;
+        case 5: // spieler lässt rotr los
+            bytes++;
+            sNum = *(int*)bytes;
             län -= 4;
             goBackInTime( zeit );
             for( auto i = spieler->getIterator(); i; i++ )
             {
                 if( i->getSpielerNummer() == sNum )
                 {
-                    if( i->getPosition() != pos )
-                        chat->addNachricht( Text( "asynchrony detected, position difference: " ) += ( i->getPosition() - pos ).getLength(), 0xFFFF0000 );
-                    if( i->getSpeed() != speed )
-                        chat->addNachricht( Text( "asynchrony detected, speed difference: " ) += ( i->getSpeed() - speed ).getLength(), 0xFFFF0000 );
-                    if( i->getDrehung() != rot )
-                        chat->addNachricht( Text( "asynchrony detected, rot difference: " ) += ( i->getDrehung() - rot ), 0xFFFF0000 );
-                    if( i->getDrehungSpeed() != rotS )
-                        chat->addNachricht( Text( "asynchrony detected, rotS difference: " ) += ( i->getDrehungSpeed() - rotS ), 0xFFFF0000 );
                     i->setTastataturStatus( T_ROT_R, 0 );
                 }
             }
             goToPresence( presence );
-			break;
-		case 6: // Init Spieler
-			if( 1 )
-			{
-				bytes++;
-				spielerAnzahl = (int)*bytes;
-				bytes++;
-				län--;
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					int sNum = *(int*)bytes;
-					Spieler *tmp = spieler->z( sNum - 1 );
-					bytes += 4;
-					län -= 4;
-					tmp->setAccountId( *(int*)bytes );
-					bytes += 4;
-					län -= 4;
-					if( !teams->z( map->getTeamNummer( sNum ) ) )
-						teams->set( map->createTeam( map->getTeamNummer( sNum ) ), map->getTeamNummer( sNum ) );
-					tmp->setTeam( teams->get( map->getTeamNummer( sNum ) ) );
-					tmp->zTeam()->spieler->add( (Spieler*)tmp->getThis() );
-					bestenliste->addSpieler( tmp );
-					bestenliste->updateSpieler( tmp );
-					bestenliste->updateTeam( tmp->zTeam() );
+            break;
+        case 6: // Init Spieler
+            if( 1 )
+            {
+                bytes++;
+                spielerAnzahl = (int)*bytes;
+                bytes++;
+                län--;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    int sNum = *(int*)bytes;
+                    Spieler *tmp = spieler->z( sNum - 1 );
+                    bytes += 4;
+                    län -= 4;
+                    tmp->setAccountId( *(int*)bytes );
+                    bytes += 4;
+                    län -= 4;
+                    if( !teams->z( map->getTeamNummer( sNum ) ) )
+                        teams->set( map->createTeam( map->getTeamNummer( sNum ) ), map->getTeamNummer( sNum ) );
+                    tmp->setTeam( teams->get( map->getTeamNummer( sNum ) ) );
+                    tmp->zTeam()->spieler->add( (Spieler*)tmp->getThis() );
+                    bestenliste->addSpieler( tmp );
+                    bestenliste->updateSpieler( tmp );
+                    bestenliste->updateTeam( tmp->zTeam() );
                     welt->addObject( tmp->getThis() );
-				}
-				int max = map->getMaxSpielerAnzahl();
-				for( int i = 0; i < max; i++ )
-				{
-					if( !spieler->z( i )->zTeam() )
-					{
-						spieler->remove( i );
-						i--;
-						max--;
-					}
-				}
-			}
-			break;
-		case 0x8: // Chat Nachricht
-			if( 1 )
-			{
-				bytes++;
-				Text *txt = new Text( "" );
-				txt->append( bytes, län );
-				chat->addNachricht( txt->getText() );
-				txt->release();
-				län = 0;
-			}
-			break;
-		case 0x9: // Spieler Nummer
-			bytes++;
-			spielerNummer = *(int*)bytes;
-			län -= 4;
-			for( int i = 0; i < spielerAnzahl; i++ )
-			{
-				if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-				{
-					shipGUI->update( spieler->z( i ) );
-					break;
-				}
-			}
-			break;
-		case 0xA: // Start
-			spielPause = 0;
-			rendern = 1;
-			break;
-		case 0xB: // Ende
+                }
+                int max = map->getMaxSpielerAnzahl();
+                for( int i = 0; i < max; i++ )
+                {
+                    if( !spieler->z( i )->zTeam() )
+                    {
+                        spieler->remove( i );
+                        i--;
+                        max--;
+                    }
+                }
+            }
+            break;
+        case 0x8: // Chat Nachricht
+            if( 1 )
+            {
+                bytes++;
+                Text *txt = new Text( "" );
+                txt->append( bytes, län );
+                chat->addNachricht( txt->getText() );
+                txt->release();
+                län = 0;
+            }
+            break;
+        case 0x9: // Spieler Nummer
+            bytes++;
+            spielerNummer = *(int*)bytes;
+            län -= 4;
+            for( int i = 0; i < spielerAnzahl; i++ )
+            {
+                if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                {
+                    shipGUI->update( spieler->z( i ) );
+                    break;
+                }
+            }
+            break;
+        case 0xA: // Start
+            spielPause = 0;
+            rendern = 1;
+            break;
+        case 0xB: // Ende
             //chat->addNachricht( "Spiel beendet", 0xFF909090 );
             csv.schreibe( "\n\nSpielernummer;Kills;Tode;Schaden gemacht;Schaden bekommen;Schüsse;Treffer\n", 2 );
             for( int i = 0; i < spielerAnzahl; i++ )
@@ -785,146 +678,146 @@ void SpielKlasse::stknVerarbeitung()
                 csv.schreibe( line, line.getLength() );
             }
             csv.close();
-			end = new Ende( schrift );
-			bytes++;
-			län--;
-			end->setGewonnen( *bytes );
-			break;
-		case 0xC: // Skill
-			if( 1 )
-			{
-				bytes++;
-				sNum = *(int*)bytes;
-				bytes += 4;
-				län -= 4;
-				char art = *bytes;
-				län--;
+            end = new Ende( schrift );
+            bytes++;
+            län--;
+            end->setGewonnen( *bytes );
+            break;
+        case 0xC: // Skill
+            if( 1 )
+            {
+                bytes++;
+                sNum = *(int*)bytes;
+                bytes += 4;
+                län -= 4;
+                char art = *bytes;
+                län--;
                 Text line = sNum;
                 line += ";";
                 line += art;
                 line += "\n";
                 csv.schreibe( line, line.getLength() );
                 goBackInTime( zeit );
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == sNum )
-					{
-						Team *tmp = spieler->z( i )->zTeam();
-						spieler->z( i )->setSkill( art );
-						tmp->akkuLeistung = tmp->getAkkuLeistungBonus();
-						tmp->beschleunigung = tmp->getBeschleunigungBonus();
-						tmp->laserEffizienz = tmp->getLaserEffizienzBonus();
-						tmp->laserIntensität = tmp->getLaserIntensitätBonus();
-						tmp->laserTempo = tmp->getLaserTempoBonus();
-						tmp->maxEnergie = tmp->getMaxEnergieBonus();
-						tmp->maxStabilität = tmp->getMaxStabilitätBonus();
-						tmp->reparatur = tmp->getReperaturBonus();
-						tmp->wendigkeit = tmp->getWendigkeitBonus();
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == sNum )
+                    {
+                        Team *tmp = spieler->z( i )->zTeam();
+                        spieler->z( i )->setSkill( art );
+                        tmp->akkuLeistung = tmp->getAkkuLeistungBonus();
+                        tmp->beschleunigung = tmp->getBeschleunigungBonus();
+                        tmp->laserEffizienz = tmp->getLaserEffizienzBonus();
+                        tmp->laserIntensität = tmp->getLaserIntensitätBonus();
+                        tmp->laserTempo = tmp->getLaserTempoBonus();
+                        tmp->maxEnergie = tmp->getMaxEnergieBonus();
+                        tmp->maxStabilität = tmp->getMaxStabilitätBonus();
+                        tmp->reparatur = tmp->getReperaturBonus();
+                        tmp->wendigkeit = tmp->getWendigkeitBonus();
                         tmp->antriebEffizienz = tmp->getAntriebEffizienzBonus();
                         tmp->energieSchild = tmp->getEnergieSchildBonus();
                         tmp->energieSchildEffizienz = tmp->getEnergieSchildEffizienzBonus();
-						break;
-					}
-				}
+                        break;
+                    }
+                }
                 goToPresence( presence );
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-					{
-						shipGUI->update( spieler->z( i ) );
-						break;
-					}
-				}
-			}
-			break;
-		case 0xD: // Schuss
-			if( 1 )
-			{
- 				bytes++;
-				int id = *(int*)bytes;
-				bytes += 4;
-				län -= 4;
-				sNum = *(int*)bytes;
-				bytes += 4;
-				län -= 4;
-				float xPos = *(float*)bytes;
-				bytes += 4;
-				län -= 4;
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                    {
+                        shipGUI->update( spieler->z( i ) );
+                        break;
+                    }
+                }
+            }
+            break;
+        case 0xD: // Schuss
+            if( 1 )
+            {
+                bytes++;
+                int id = *(int*)bytes;
+                bytes += 4;
+                län -= 4;
+                sNum = *(int*)bytes;
+                bytes += 4;
+                län -= 4;
+                float xPos = *(float*)bytes;
+                bytes += 4;
+                län -= 4;
                 float yPos = *(float*)bytes;
-				bytes += 4;
-				län -= 4;
+                bytes += 4;
+                län -= 4;
                 float xSpeed = *(float*)bytes;
-				bytes += 4;
-				län -= 4;
+                bytes += 4;
+                län -= 4;
                 float ySpeed = *(float*)bytes;
-				bytes += 4;
-				län -= 4;
-				double intensität = *(double*)bytes;
-				län -= 8;
-				int farbe = 0;
+                bytes += 4;
+                län -= 4;
+                double intensität = *(double*)bytes;
+                län -= 8;
+                int farbe = 0;
                 goBackInTime( zeit );
-				for( int i = 0; i < spielerAnzahl; i++ )
-				{
-					if( spieler->z( i )->getSpielerNummer() == sNum )
-					{
+                for( int i = 0; i < spielerAnzahl; i++ )
+                {
+                    if( spieler->z( i )->getSpielerNummer() == sNum )
+                    {
                         if( spieler->z( i )->getPosition() != Vertex( xPos, yPos ) )
                             chat->addNachricht( Text( "asynchrony detected difference: " ) += ( spieler->z( i )->getPosition() - Vertex( xPos, yPos ) ).getLength(), 0xFFFF0000 );
-						spieler->z( i )->setPosition( Vertex( xPos, yPos ) );
-						spieler->z( i )->hatGeschossen();
-						farbe = spieler->z( i )->zTeam()->farbe;
-						break;
-					}
-				}
+                        spieler->z( i )->setPosition( Vertex( xPos, yPos ) );
+                        spieler->z( i )->hatGeschossen();
+                        farbe = spieler->z( i )->zTeam()->farbe;
+                        break;
+                    }
+                }
                 Laser *l = new Laser( id, Vertex( xPos, yPos ), Vertex( xSpeed, ySpeed ), sNum, intensität, farbe );
                 welt->addObject( l->getThis() );
                 schüsse->add( l );
                 goToPresence( presence );
-				if( sNum == spielerNummer )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-						{
-							shipGUI->update( spieler->z( i ) );
-							bestenliste->updateSpieler( spieler->z( i ) );
-							break;
-						}
-					}
-				}
-			}
-			break;
-		case 0xE: // Treffer
-			if( 1 )
-			{
-				bytes++;
-				int schuss = *(int*)bytes;
-				bytes += 4;
-				län -= 4;
-				int sNum = *(int*)bytes;
-				län -= 4;
+                if( sNum == spielerNummer )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                        {
+                            shipGUI->update( spieler->z( i ) );
+                            bestenliste->updateSpieler( spieler->z( i ) );
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+        case 0xE: // Treffer
+            if( 1 )
+            {
+                bytes++;
+                int schuss = *(int*)bytes;
+                bytes += 4;
+                län -= 4;
+                int sNum = *(int*)bytes;
+                län -= 4;
                 goBackInTime( zeit );
                 int sAnz = schüsse->getEintragAnzahl();
-				for( int i = 0; i < sAnz; i++ )
-				{
+                for( int i = 0; i < sAnz; i++ )
+                {
                     Laser *tmp = schüsse->z( i );
-					if( tmp && tmp->getId() == schuss )
-					{
-						if( sNum >= 0 )
-						{
+                    if( tmp && tmp->getId() == schuss )
+                    {
+                        if( sNum >= 0 )
+                        {
                             double intens = 0;
-							for( auto s = spieler->getIterator(); s; s++ )
-							{
-								if( s->getSpielerNummer() == sNum )
-								{
+                            for( auto s = spieler->getIterator(); s; s++ )
+                            {
+                                if( s->getSpielerNummer() == sNum )
+                                {
                                     intens = tmp->getIntensität( s->getSpeed() );
-									s->nimmSchaden( intens );
+                                    s->nimmSchaden( intens );
                                     if( tmp->getSpeed().getLengthSq() > 0 )
                                         s->impuls( tmp->getPosition() - tmp->getSpeed(), tmp->getSpeed() * 0.3f );
                                     s->calcDeadPlayerObject( schüsse->z( i ) );
-									bestenliste->updateSpieler( s );
+                                    bestenliste->updateSpieler( s );
                                     break;
-								}
-							}
+                                }
+                            }
                             for( auto s = spieler->getIterator(); s; s++ )
                             {
                                 if( s->getSpielerNummer() == tmp->getSpieler() )
@@ -934,135 +827,284 @@ void SpielKlasse::stknVerarbeitung()
                                     break;
                                 }
                             }
-						}
+                        }
                         welt->removeObject( tmp );
-						schüsse->remove( i );
-						break;
-					}
-				}
+                        schüsse->remove( i );
+                        break;
+                    }
+                }
                 goToPresence( presence );
-				if( sNum == spielerNummer )
-				{
+                if( sNum == spielerNummer )
+                {
                     for( auto s = spieler->getIterator(); s; s++ )
-					{
-						if( s->getSpielerNummer() == spielerNummer )
-						{
-							shipGUI->update( s );
-							break;
-						}
-					}
-				}
-			}
-			break;
-		case 0xF: // Wiederbelebung
-			if( 1 )
-			{
-				bytes++;
-				int sNum = *(int*)bytes;
-				län -= 4;
+                    {
+                        if( s->getSpielerNummer() == spielerNummer )
+                        {
+                            shipGUI->update( s );
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+        case 0xF: // Wiederbelebung
+            if( 1 )
+            {
+                bytes++;
+                int sNum = *(int*)bytes;
+                län -= 4;
                 goBackInTime( zeit );
                 for( auto s = spieler->getIterator(); s; s++ )
-				{
-					if( s->getSpielerNummer() == sNum )
-					{
-						s->wiederbelebung();
-						break;
-					}
-				}
+                {
+                    if( s->getSpielerNummer() == sNum )
+                    {
+                        s->wiederbelebung();
+                        break;
+                    }
+                }
                 goToPresence( presence );
-				if( sNum == spielerNummer )
-				{
+                if( sNum == spielerNummer )
+                {
                     for( auto s = spieler->getIterator(); s; s++ )
-					{
-						if( s->getSpielerNummer() == spielerNummer )
-						{
-							shipGUI->update( s );
-							break;
-						}
-					}
-				}
-			}
-			break;
-		case 0x10: // Tod
-			if( 1 )
-			{
-				bytes++;
-				sNum = *(int*)bytes;
-				bytes += 4;
-				län -= 4;
-				int killer = *(int*)bytes;
-				län -= 4;
+                    {
+                        if( s->getSpielerNummer() == spielerNummer )
+                        {
+                            shipGUI->update( s );
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+        case 0x10: // Tod
+            if( 1 )
+            {
+                bytes++;
+                sNum = *(int*)bytes;
+                bytes += 4;
+                län -= 4;
+                int killer = *(int*)bytes;
+                län -= 4;
                 goBackInTime( zeit );
                 for( auto s = spieler->getIterator(); s; s++ )
-				{
-					if( s->getSpielerNummer() == sNum )
-					{
-						DeadPlayer *dp = s->sterben();
+                {
+                    if( s->getSpielerNummer() == sNum )
+                    {
+                        DeadPlayer *dp = s->sterben();
                         if( dp )
                         {
                             welt->addObject( dp->getThis() );
                             deads->add( dp );
                         }
-						bestenliste->updateSpieler( s );
-					}
-					if( s->getSpielerNummer() == killer )
-					{
-						s->addKill();
-						s->zTeam()->punkte++;
-						bestenliste->updateTeam( s->zTeam() );
-						bestenliste->updateSpieler( s );
-					}
-				}
+                        bestenliste->updateSpieler( s );
+                    }
+                    if( s->getSpielerNummer() == killer )
+                    {
+                        s->addKill();
+                        s->zTeam()->punkte++;
+                        bestenliste->updateTeam( s->zTeam() );
+                        bestenliste->updateSpieler( s );
+                    }
+                }
                 goToPresence( presence );
-				if( sNum == spielerNummer )
-				{
-					for( int i = 0; i < spielerAnzahl; i++ )
-					{
-						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-						{
-							shipGUI->update( spieler->z( i ) );
-							break;
-						}
-					}
-				}
-			}
-			break;
-		default:
-			// Fehler beim verarbeiten
-			break;
-		}
-		if( län != 0 )
-		{
-			// Fehler beim verarbeiten
-			chat->addNachricht( "Es ist ein Fehler beim verarbeiten einer Nachricht aufgetreten.", 0xFFFF0000 );
-		}
-		n->setVerarbeitet();
-	}
-	for( int i = stkna; i > 0; i-- )
-	{
-		if( !stkn->z( 0 ) || !stkn->z( 0 )->istVerarbeitet() )
-			break;
-		stkna--;
-		stkn->remove( 0 );
-	}
-	unlock();
+                if( sNum == spielerNummer )
+                {
+                    for( int i = 0; i < spielerAnzahl; i++ )
+                    {
+                        if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                        {
+                            shipGUI->update( spieler->z( i ) );
+                            break;
+                        }
+                    }
+                }
+            }
+            break;
+        case 0x11: // neuer Asteroid
+        {
+            Vertex pos, speed;
+            float rot, rotS;
+            bytes++;
+            int id = *(int*)bytes;
+            bytes += 4;
+            län -= 4;
+            pos.x = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            pos.y = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            speed.x = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            speed.y = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            rot = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            rotS = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            int index = *(int*)bytes;
+            län -= 4;
+            goBackInTime( zeit );
+            Asteroid *na = new Asteroid( id, pos, speed, rot, rotS, asteroidModels->get( index ), asteroidTextures->get( index ) );
+            welt->addObject( na->getThis() );
+            asteroids->add( na );
+            goToPresence( presence );
+            break;
+        }
+        case 0x12: // Asteroid Treffer
+        {
+            Vertex pos;
+            bytes++;
+            int schuss = *(int*)bytes;
+            bytes += 4;
+            län -= 4;
+            int asteroid = *(int*)bytes;
+            bytes += 4;
+            län -= 4;
+            pos.x = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            pos.y = *(float*)bytes;
+            bytes += 4;
+            län -= 4;
+            __int64 seed = *(__int64*)bytes;
+            bytes += 8;
+            län -= 8;
+            int newAsteroid = *(int*)bytes;
+            län -= 4;
+            goBackInTime( zeit );
+            int aAnz = asteroids->getEintragAnzahl();
+            for( int i = 0; i < aAnz; i++ )
+            {
+                Asteroid *a = asteroids->z( i );
+                if( a->getId() == asteroid )
+                {
+                    int sAnz = schüsse->getEintragAnzahl();
+                    for( int j = 0; j < sAnz; j++ )
+                    {
+                        Laser *tmp = schüsse->z( j );
+                        if( tmp && tmp->getId() == schuss )
+                        {
+                            for( auto s = spieler->getIterator(); s; s++ )
+                            {
+                                if( s->getSpielerNummer() == tmp->getSpieler() )
+                                {
+                                    s->addTreffer();
+                                    break;
+                                }
+                            }
+                            Asteroid *na = a->split( pos, tmp->getSpeed(), seed, newAsteroid );
+                            welt->addObject( na->getThis() );
+                            asteroids->add( na );
+                            welt->removeObject( tmp );
+                            schüsse->remove( j );
+                        }
+                    }
+                    break;
+                }
+            }
+            goToPresence( presence );
+            break;
+        }
+        case 0x13: // Pixel
+        {
+            bytes++;
+            int asteroid = *(int*)bytes;
+            bytes += 4;
+            län -= 4;
+            int pixelId = *(int*)bytes;
+            län -= 4;
+            goBackInTime( zeit );
+            for( auto a = asteroids->getIterator(); a; a++ )
+            {
+                if( a->getId() == asteroid )
+                {
+                    Pixel *p = new Pixel( a->getPosition(), a->getSpeed(), a->getMasse() / 50, pixelId );
+                    welt->addObject( p->getThis() );
+                    pixel->add( p );
+                    a->setDead();
+                    break;
+                }
+            }
+            goToPresence( presence );
+            break;
+        }
+        case 0x14: // Pixel einsammeln
+        {
+            bytes++;
+            int pixelId = *(int*)bytes;
+            bytes += 4;
+            län -= 4;
+            int spielerId = *(int*)bytes;
+            län -= 4;
+            goBackInTime( zeit );
+            int pixelAnz = pixel->getEintragAnzahl();
+            for( int i = 0; i < pixelAnz; i++ )
+            {
+                Pixel *p = pixel->z( i );
+                if( p->getId() == pixelId )
+                {
+                    if( spielerId >= 0 )
+                    {
+                        for( auto s = spieler->getIterator(); s; s++ )
+                        {
+                            if( s->getSpielerNummer() == spielerId )
+                            {
+                                s->addEp( p->getEp() );
+                                if( s->getSpielerNummer() == spielerNummer )
+                                    shipGUI->update( s );
+                                break;
+                            }
+                        }
+                    }
+                    welt->removeObject( p );
+                    pixel->remove( i );
+                    break;
+                }
+            }
+            goToPresence( presence );
+            break;
+        }
+        default:
+            // Fehler beim verarbeiten
+            break;
+        }
+        if( län != 0 )
+        {
+            // Fehler beim verarbeiten
+            chat->addNachricht( "Es ist ein Fehler beim verarbeiten einer Nachricht aufgetreten.", 0xFFFF0000 );
+        }
+        n->setVerarbeitet();
+    }
+    for( int i = stkna; i > 0; i-- )
+    {
+        if( !stkn->z( 0 ) || !stkn->z( 0 )->istVerarbeitet() )
+            break;
+        stkna--;
+        stkn->remove( 0 );
+    }
+    unlock();
 }
 
 bool SpielKlasse::tick( double zeit )
 {
     stknVerarbeitung();
-	if( spielPause )
-	{
-		zeit = 0;
-		return 1;
-	}
-	rZeit += zeit;
-	while( TICK <= rZeit )
-	{
-		rZeit -= TICK;
+    if( spielPause )
+    {
+        zeit = 0;
+        return 1;
+    }
+    rZeit += zeit;
+    while( TICK <= rZeit )
+    {
+        rZeit -= TICK;
         if( end )
             return 1;
-		lock();
+        lock();
         if( spielZeit == -1 )
             save(); // speichern
         // tote spieler
@@ -1083,20 +1125,20 @@ bool SpielKlasse::tick( double zeit )
         Vertex tPos;
         Vertex speed;
         bool setKam = 0;
-		for( int i = 0; i < spielerAnzahl; i++ )
-		{
-			if( spieler->z( i )->getSpielerNummer() == spielerNummer )
-				shipGUI->update( spieler->z( i ) );
-			if( spielerNummer == spieler->z( i )->getSpielerNummer() )
-			{
+        for( int i = 0; i < spielerAnzahl; i++ )
+        {
+            if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+                shipGUI->update( spieler->z( i ) );
+            if( spielerNummer == spieler->z( i )->getSpielerNummer() )
+            {
                 tPos = spieler->z( i )->getPosition();
                 speed = spieler->z( i )->getSpeed();
-				setKam = spieler->z( i )->istAmLeben();
-			}
-		}
-		unlock();
-		if( setKam )
-		{
+                setKam = spieler->z( i )->istAmLeben();
+            }
+        }
+        unlock();
+        if( setKam )
+        {
             if( !this->setKam || isnan( kam->getWorldPosition().x ) || isnan( kam->getWorldPosition().y ) )
                 kam->lookAtWorldPos( tPos );
             Vertex str = ( tPos - kam->getWorldPosition() );
@@ -1119,22 +1161,22 @@ bool SpielKlasse::tick( double zeit )
             float faktor = str.getLength() / 200.f;
             if( faktor > 1.f )
                 faktor = 1.f;
-			kam->lookAtWorldPos( kam->getWorldPosition() + speed * faktor * (float)TICK );
+            kam->lookAtWorldPos( kam->getWorldPosition() + speed * faktor * (float)TICK );
             kam->lookAtWorldPos( kam->getWorldPosition() + str * faktor * 0.1f * (float)TICK );
-		}
+        }
         this->setKam = setKam;
-		chat->tick( !zeit ? 0.05 : zeit );
-		if( shipGUI )
-		    shipGUI->tick( !zeit ? 0.05 : zeit );
-	}
-	return 1;
+        chat->tick( !zeit ? 0.05 : zeit );
+        if( shipGUI )
+            shipGUI->tick( !zeit ? 0.05 : zeit );
+    }
+    return 1;
 }
 
 void SpielKlasse::render( Bild &zRObj )
 {
-	if( !rendern )
-		return;
-	lock();
+    if( !rendern )
+        return;
+    lock();
     kam->lookAtWorldArea( zRObj.getBreite(), zRObj.getHeight() );
     kam->setSize( zRObj.getSize() );
     kam->render( zRObj );
@@ -1142,41 +1184,41 @@ void SpielKlasse::render( Bild &zRObj )
     minimap->lookAtWorldPos( welt->getWorldInfo().size.x / 2, welt->getWorldInfo().size.y / 2 );
     minimap->lookAtWorldArea( welt->getWorldInfo().size.x, welt->getWorldInfo().size.y );
     minimap->render( zRObj );
-	chat->render( zRObj );
-	if( bestenliste )
-		bestenliste->render( zRObj );
-	if( shipGUI )
-		shipGUI->render( zRObj );
-	if( end )
-		end->render( zRObj );
-	unlock();
+    chat->render( zRObj );
+    if( bestenliste )
+        bestenliste->render( zRObj );
+    if( shipGUI )
+        shipGUI->render( zRObj );
+    if( end )
+        end->render( zRObj );
+    unlock();
 }
 
 // constant
 int SpielKlasse::läuft() const
 {
-	if( !rendern )
-		return 3;
-	if( !end )
-		return 2;
-	if( end && !end->getWeiter() )
-		return 1;
-	if( end && end->getWeiter() )
-		return 0;
-	return 0;
+    if( !rendern )
+        return 3;
+    if( !end )
+        return 2;
+    if( end && !end->getWeiter() )
+        return 1;
+    if( end && end->getWeiter() )
+        return 0;
+    return 0;
 }
 
 // Reference Counting
 SpielV *SpielKlasse::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 SpielV *SpielKlasse::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Asteroids/Spiel/SpielKlasse.h

@@ -12,6 +12,8 @@
 #include <Bildschirm.h>
 #include "Objekt/SpielObjekt.h"
 #include <Kamera2D.h>
+#include "Asteroid/Asteroid.h"
+#include "Asteroid/Pixel.h"
 
 class SpielKlasse : public SpielV
 {
@@ -28,6 +30,7 @@ private:
     KSGClient::InformationServerClient *infoKlient;
     KSGClient::SpielServerClient *spielKlient;
 	RCArray< Spieler > *spieler;
+    RCArray< Asteroid > *asteroids;
 	RCArray< Team > *teams;
 	RCArray< SpielObjekt > *objekte;
     RCArray< Laser > *schüsse;
@@ -43,6 +46,9 @@ private:
 	SpielerGUI *shipGUI;
     Datei csv;
     RCArray< DeadPlayer > *deads;
+    RCArray< Model2DData > *asteroidModels;
+    RCArray< Textur2D > *asteroidTextures;
+    RCArray< Pixel > *pixel;
 	bool rendern;
 	int spielZeit;
 	double rZeit;

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -30,20 +30,17 @@ Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift,
     setPosition( startPos );
     setDrehung( (float)zStr->rot );
     beschleunigung = zStr->beschleunigung;
-    beschleunigungStart = zStr->beschleunigung;
     energie = zStr->maxEnergie;
     stabilität = zStr->maxStabilität;
     reparatur = zStr->reparatur;
     laserIntensität = zStr->laserIntensität;
     laserEffizienz = zStr->laserEffizienz;
     akkuLeistung = zStr->akkuLeistung;
-    akkuLeistungStart = zStr->akkuLeistung;
     maxEnergie = zStr->maxEnergie;
     maxStabilität = zStr->maxStabilität;
     laserTempo = zStr->laserTempo;
     netzwerk = zStr->netzwerk;
     wendigkeit = zStr->wendigkeit;
-    wendigkeitStart = wendigkeit;
     antriebEffizienz = zStr->antriebEffizienz;
     energieSchild = zStr->energieSchild;
     energieSchildEffizienz = zStr->energieSchildEffizienz;
@@ -60,6 +57,8 @@ Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift,
     zeitTod = 0;
     nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
                           TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
+    ep = 0;
+    nextSkillEp = 100;
     save();
 }
 
@@ -255,7 +254,7 @@ bool Spieler::tick( const WeltInfo &info, double tv )
             repAbk = 0;
         if( tastatur[ T_GAS ] )
         {
-            double treibstoff = 0.5 * ( ( beschleunigung + team->beschleunigung ) / 5 )
+            double treibstoff = 0.5 * ( ( beschleunigung + team->beschleunigung ) / 15 )
                 * tv * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
@@ -267,7 +266,7 @@ bool Spieler::tick( const WeltInfo &info, double tv )
         }
         if( tastatur[ T_ROT_R ] )
         {
-            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 5 )
+            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 15 )
                 * tv * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
@@ -279,7 +278,7 @@ bool Spieler::tick( const WeltInfo &info, double tv )
         }
         if( tastatur[ T_ROT_L ] )
         {
-            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 5 )
+            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 15 )
                 * tv * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
             treibstoffVerbraucht += treibstoff;
             float factor = 1;
@@ -366,11 +365,11 @@ void Spieler::setSkill( int art )
         team->reparatur = team->getReperaturBonus();
         break;
     case 3: // Laser Intensität
-        laserIntensität += 3;
+        laserIntensität += 4;
         team->laserIntensität = team->getLaserIntensitätBonus();
         break;
     case 4: // Laser Effizienz
-        laserEffizienz += 1;
+        laserEffizienz += 1.5;
         team->laserEffizienz = team->getLaserEffizienzBonus();
         break;
     case 5: // Laser Tempo
@@ -523,6 +522,22 @@ void Spieler::hatGeschossen()
     schüsse++;
 }
 
+void Spieler::addTreffer()
+{
+    treffer++;
+}
+
+void Spieler::addEp( float ep )
+{
+    this->ep += ep;
+    while( this->ep >= nextSkillEp )
+    {
+        skillPunkte++;
+        this->ep -= nextSkillEp;
+        nextSkillEp *= 1.1f;
+    }
+}
+
 void Spieler::save()
 {
     last.rSpeed = getDrehungSpeed();
@@ -607,6 +622,16 @@ void Spieler::load()
 }
 
 // constant
+float Spieler::getEp() const
+{
+    return ep;
+}
+
+float Spieler::getMaxEp() const
+{
+    return nextSkillEp;
+}
+
 int Spieler::getAccountId() const
 {
     return accountId;

Asteroids/Spiel/Spieler/Spieler.h

@@ -39,9 +39,6 @@ private:
     Vertex kR;
     Vertex stM;
     Vertex kM;
-    double akkuLeistungStart;
-    double beschleunigungStart;
-    double wendigkeitStart;
     struct SpielerDataSave
     {
         float rSpeed;
@@ -122,6 +119,8 @@ private:
     Textur2D *flammenR;
     TextFeld *nText;
     DeadPlayer *deadPlayer;
+    float ep;
+    float nextSkillEp;
 
     double calculateLaserCost();
 
@@ -147,9 +146,13 @@ public:
     DeadPlayer *sterben();
 	void wiederbelebung();
 	void hatGeschossen();
+    void addTreffer();
+    void addEp( float ep );
     void save();
     void load();
 	// constant
+    float getEp() const;
+    float getMaxEp() const;
 	int getAccountId() const;
 	Text *getName() const;
 	Text *zName() const;

Asteroids/Spiel/SpielerGUI/SpielerGUI.cpp

@@ -20,7 +20,7 @@ SpielerGUI::SpielerGUI( Schrift *zSchrift )
 {
     player = 0;
     ram = new LRahmen();
-    ram->setSize( 200, 407 );
+    ram->setSize( 200, 417 );
     ram->setPosition( Punkt( BildschirmGröße().x - 210, 10 ) );
     ram->setFarbe( 0xFFFFFFFF );
     spieler = initTextFeld( 5, 5, 190, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "" );
@@ -377,6 +377,11 @@ void SpielerGUI::render( Bild &zRObj )
         txt += " p/s";
         speed->setText( txt );
         speed->render( zRObj );
+        zRObj.drawLinieH( 5, ram->getHeight() - 12, ram->getBreite() - 12, 0xFFFFFFFF );
+        zRObj.drawLinieH( 5, ram->getHeight() - 7, ram->getBreite() - 12, 0xFFFFFFFF );
+        zRObj.drawLinieV( 5, ram->getHeight() - 12, 5, 0xFFFFFFFF );
+        zRObj.drawLinieV( ram->getBreite() - 7, ram->getHeight() - 12, 5, 0xFFFFFFFF );
+        zRObj.fillRegion( 5, ram->getHeight() - 12, (int)( ( ram->getBreite() - 12 ) * ( player->getEp() / player->getMaxEp() ) ), 5, 0xFFFFFFFF );
     }
     zRObj.releaseDrawOptions();
 }

Asteroids/SpielStatistik/Chat/StatistikChat.cpp

@@ -350,7 +350,7 @@ ChatListe *ChatListe::release()
 // Inhalt der StatistikChat Klasse aus StatistikChat.h
 // Konstruktor
 StatistikChat::StatistikChat( int eigeneId, KSGClient::SpielServerClient *spielc, KSGClient::InformationServerClient *infoc, Schrift *schrift, BilderV *bilder,
-							  void( *addNachricht )( void *, Text *, Text *, Text *, Text *, char, void * ),
+							  void( *addNachricht )( void *, Text *, Text *, Text *, Text * ),
 							  void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
 							  void( *accountAnsehen )( void *, int ), void *param )
 							  : addNachricht( addNachricht ),
@@ -438,7 +438,7 @@ void StatistikChat::doMausEreignis( MausEreignis &me )
 				for( int i = 0; i < län - 1; i++ )
 					bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
 				if( !spielc->statistikNachricht( län, bytes ) )
-					addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0, 0, 0 );
+					addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0 );
 				else
 				{
 					nachricht->setAuswahl( 0, 0 );
@@ -466,7 +466,7 @@ void StatistikChat::doTastaturEreignis( TastaturEreignis &te )
 			for( int i = 0; i < län - 1; i++ )
 				bytes[ i + 1 ] = nachricht->zText()->getText()[ i ];
 			if( !spielc->statistikNachricht( län, bytes ) )
-				addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0, 0, 0 );
+				addNachricht( nachrichtParam, new Text( "Fehler" ), new Text( "Die Nachricht konnte nicht gesendet werden." ), new Text( "Ok" ), 0 );
 			else
 			{
 				nachricht->setAuswahl( 0, 0 );

Asteroids/SpielStatistik/Chat/StatistikChat.h

@@ -93,7 +93,7 @@ public:
 class StatistikChat
 {
 private:
-	void( *addNachricht )( void *, Text *, Text *, Text *, Text *, char, void * );
+	void( *addNachricht )( void *, Text *, Text *, Text *, Text * );
 	void *nachrichtParam;
     KSGClient::SpielServerClient *spielc;
     KSGClient::InformationServerClient *infoc;
@@ -108,7 +108,7 @@ private:
 public:
 	// Konstruktor
 	StatistikChat( int eigeneId, KSGClient::SpielServerClient *spielc, KSGClient::InformationServerClient *infoc, Schrift *schrift, BilderV *bilder,
-										   void( *addNachricht )( void *, Text *, Text *, Text *, Text *, char, void * ),
+										   void( *addNachricht )( void *, Text *, Text *, Text *, Text * ),
 										   void( *addChat )( void*, int ), void( *addFreund )( void*, int ),
 										   void( *accountAnsehen )( void *, int ), void *param );
 	// Destruktor

Asteroids/SpielStatistik/SpielStatistik.cpp

@@ -88,7 +88,7 @@ void SpielStatistik::setAccountId( int id )
 	accountId = id;
 }
 
-void SpielStatistik::setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text *, char, void * ),
+void SpielStatistik::setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * ),
 										   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
 										   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam )
 {

Asteroids/SpielStatistik/SpielStatistik.h

@@ -9,7 +9,7 @@
 class SpielStatistik : public SpielStatistikV
 {
 private:
-	void( *addNachrichtF )( void *, Text *, Text *, Text *, Text *, char, void * );
+	void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * );
 	void( *addChatF )( void *, int );
 	void( *addFreundF )( void *, int );
 	void( *accountAnsehenF )( void *, int );
@@ -41,7 +41,7 @@ public:
 	virtual void bereit();
 	virtual void setBilder( BilderV *b );
 	virtual void setAccountId( int id );
-	virtual void setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text *, char, void * ),
+	virtual void setRückrufFunktionen( void( *addNachrichtF )( void *, Text *, Text *, Text *, Text * ),
 															   void( *addChatF )( void *, int ), void( *addFreundF )( void *, int ),
 															   void( *accountAnsehenF )( void *, int ), bool( *istFreundF )( void *, int ), void *nachrichtParam );
 	virtual void setSchrift( Schrift *schrift );

Asteroids/SpielStatistik/Tabelle/StatistikTabelle.cpp

@@ -199,7 +199,7 @@ void StatistikTabelle::tabelleF
 			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden bekommen" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenBekommen ) );
 			zT->setZeichnungZ( zT->getSpaltenNummer( "Schaden gemacht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->schadenGemacht ) );
 			zT->setZeichnungZ( zT->getSpaltenNummer( "Treibstoff verbraucht" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->treibstoffVerbraucht ) );
-			zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ( ssdgs->get( i )->treffer ? ( 100 / ( ssdgs->get( i )->schüsse / ssdgs->get( i )->treffer ) ) : 0 ) ) );
+			zT->setZeichnungZ( zT->getSpaltenNummer( "Präzision" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ( 100 * ssdgs->get( i )->treffer / ssdgs->get( i )->schüsse ) ) );
 			zT->setZeichnungZ( zT->getSpaltenNummer( "Punkte" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->punkte ) );
 			zT->setZeichnungZ( zT->getSpaltenNummer( "Kills" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->kills ) );
 			zT->setZeichnungZ( zT->getSpaltenNummer( "Tode" ), zNum, initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text, Text() += ssdgs->get( i )->tode ) );