asynchronität der Spieler behoben, steuerung verändert

Asteroids/Spiel/SpielKlasse.cpp

@@ -549,11 +549,8 @@ void SpielKlasse::stknVerarbeitung()
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
 						Team *tmp = spieler->z( i )->zTeam();
-						if( art == 6 || art == 7 || art == 8 )
-						{
-							for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
-								j->var->setMoveZeit( zeit - spielZeit, map );
-						}
+						for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
+							j->var->resetToSaveTime( zeit, map );
 						spieler->z( i )->setSkill( art );
 						tmp->akkuLeistung = tmp->getAkkuLeistungBonus();
 						tmp->beschleunigung = tmp->getBeschleunigungBonus();
@@ -564,11 +561,8 @@ void SpielKlasse::stknVerarbeitung()
 						tmp->maxStabilität = tmp->getMaxStabilitätBonus();
 						tmp->reparatur = tmp->getReperaturBonus();
 						tmp->wendigkeit = tmp->getWendigkeitBonus();
-						if( art == 6 || art == 7 || art == 8 )
-						{
-							for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
-								j->var->setMoveZeit( spielZeit - zeit, map );
-						}
+						for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
+							j->var->resetToGameTime( spielZeit, map );
 						break;
 					}
 				}
@@ -611,11 +605,11 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
-						spieler->z( i )->setMoveZeit( zeit - spielZeit, map );
+						spieler->z( i )->resetToSaveTime( zeit, map );
 						spieler->z( i )->setPosition( Vec2< double >( xPos, yPos ) );
 						spieler->z( i )->hatGeschossen();
 						farbe = spieler->z( i )->zTeam()->farbe;
-						spieler->z( i )->setMoveZeit( spielZeit - zeit, map );
+						spieler->z( i )->resetToGameTime( spielZeit, map );
 						break;
 					}
 				}
@@ -658,12 +652,16 @@ void SpielKlasse::stknVerarbeitung()
 							{
 								if( spieler->z( j )->getSpielerNummer() == sNum )
 								{
+                                    spieler->z( j )->resetToSaveTime( zeit, map );
 									spieler->z( j )->nimmSchaden( tmp->getIntensität() );
+                                    spieler->z( j )->resetToGameTime( spielZeit, map );
 									bestenliste->updateSpieler( spieler->z( j ) );
 								}
 								if( spieler->z( j )->getSpielerNummer() == tmp->getSpieler() )
 								{
+                                    spieler->z( j )->resetToSaveTime( zeit, map );
 									spieler->z( j )->machSchaden( tmp->getIntensität() );
+                                    spieler->z( j )->resetToGameTime( spielZeit, map );
 									bestenliste->updateSpieler( spieler->z( j ) );
 								}
 							}
@@ -695,7 +693,9 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
+                        spieler->z( i )->resetToSaveTime( zeit, map );
 						spieler->z( i )->wiederbelebung();
+                        spieler->z( i )->resetToGameTime( spielZeit, map );
 						break;
 					}
 				}
@@ -725,12 +725,16 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
+                        spieler->z( i )->resetToSaveTime( zeit, map );
 						spieler->z( i )->sterben();
+                        spieler->z( i )->resetToGameTime( spielZeit, map );
 						bestenliste->updateSpieler( spieler->z( i ) );
 					}
 					if( spieler->z( i )->getSpielerNummer() == killer )
 					{
+                        spieler->z( i )->resetToSaveTime( zeit, map );
 						spieler->z( i )->addKill();
+                        spieler->z( i )->resetToGameTime( spielZeit, map );
 						spieler->z( i )->zTeam()->punkte++;
 						bestenliste->updateTeam( spieler->z( i )->zTeam() );
 						bestenliste->updateSpieler( spieler->z( i ) );
@@ -797,7 +801,7 @@ bool SpielKlasse::tick( double zeit )
 			objekte->z( i )->tick();
 		for( int i = 0; i < spielerAnzahl; i++ )
 		{
-			if( spieler->z( i )->tick( map ) && spieler->z( i )->getSpielerNummer() == spielerNummer )
+			if( spieler->z( i )->tick( spielZeit, map ) && spieler->z( i )->getSpielerNummer() == spielerNummer )
 				ship->update( spieler->z( i ) );
 			if( spielerNummer == spieler->z( i )->getSpielerNummer() )
 			{

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -8,58 +8,56 @@
 // Konstruktor
 Spieler::Spieler( InformationKlientV *zInfoK, Schrift *zSchrift, SpielerStr *zStr )
 {
-	accountId = 0;
-	sNum = zStr->id;
-	farbe = 0;
-	ship = new Model2D();
-	ship->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Alpha );
-	team = 0;
-	info = zInfoK->getThis();
-	name = 0;
-	for( int i = 0; i < T_MAX; i++ )
-		tastatur[ i ] = 0;
-	amLeben = 1;
-	schussAbk = 0;
-	repAbk = 0;
-	reinkAbk = 0;
-	maxReinkAbk = 5;
-	ref = 1;
-	startPos = zStr->pos;
-	pos = zStr->pos;
-	speed = Vec2< double >( 0, 0 );
-	rotation = zStr->rot;
-	beschleunigung = zStr->beschleunigung;
-	energie = zStr->maxEnergie;
-	stabilität = zStr->maxStabilität;
-	reparatur = zStr->reparatur;
-	laserIntensität = zStr->laserIntensität;
-	laserEffizienz = zStr->laserEffizienz;
-	akkuLeistung = zStr->akkuLeistung;
-	maxEnergie = zStr->maxEnergie;
-	maxStabilität = zStr->maxStabilität;
-	laserTempo = zStr->laserTempo;
-	netzwerk = zStr->netzwerk;
-	wendigkeit = zStr->wendigkeit;
-	skillPunkte =zStr->skillPunkte;
-	schadenBekommen = 0;
-	schadenGemacht = 0;
-	treibstoffVerbraucht = 0;
-	schüsse = 0;
-	treffer = 0;
-	punkte = 0;
-	kills = 0;
-	tode = 0;
-	zeitAmLeben = 0;
-	zeitTod = 0;
-	nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
-						  TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
-	spielZeit = 0;
-	stopXSpeedT = -1;
-	stopYSpeedT = -1;
-	stopXSpeed = 0;
-	stopYSpeed = 0;
-	ship->setPosition( pos );
-	ship->setDrehung( (float)rotation );
+    accountId = 0;
+    sNum = zStr->id;
+    current.farbe = 0;
+    ship = new Model2D();
+    ship->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Alpha );
+    team = 0;
+    info = zInfoK->getThis();
+    name = 0;
+    for( int i = 0; i < T_MAX; i++ )
+        tastatur[ i ] = 0;
+    current.amLeben = 1;
+    current.schussAbk = 0;
+    current.repAbk = 0;
+    current.reinkAbk = 0;
+    current.maxReinkAbk = 5;
+    ref = 1;
+    current.startPos = zStr->pos;
+    current.pos = zStr->pos;
+    current.speed = Vec2< double >( 0, 0 );
+    current.rotation = zStr->rot;
+    current.beschleunigung = zStr->beschleunigung;
+    current.energie = zStr->maxEnergie;
+    current.stabilität = zStr->maxStabilität;
+    current.reparatur = zStr->reparatur;
+    current.laserIntensität = zStr->laserIntensität;
+    current.laserEffizienz = zStr->laserEffizienz;
+    current.akkuLeistung = zStr->akkuLeistung;
+    current.maxEnergie = zStr->maxEnergie;
+    current.maxStabilität = zStr->maxStabilität;
+    current.laserTempo = zStr->laserTempo;
+    current.netzwerk = zStr->netzwerk;
+    current.wendigkeit = zStr->wendigkeit;
+    skillPunkte = zStr->skillPunkte;
+    current.schadenBekommen = 0;
+    current.schadenGemacht = 0;
+    current.treibstoffVerbraucht = 0;
+    current.schüsse = 0;
+    current.treffer = 0;
+    current.punkte = 0;
+    current.kills = 0;
+    current.tode = 0;
+    current.zeitAmLeben = 0;
+    current.zeitTod = 0;
+    nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
+                          TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
+    current.spielZeit = 0;
+    current.rSpeed = 0;
+    ship->setPosition( current.pos );
+    ship->setDrehung( (float)current.rotation );
+    last = current;
 }
 
 // Destruktor
@@ -78,7 +76,7 @@ Spieler::~Spieler()
 
 double Spieler::calculateLaserCost()
 {
-    double kosten = ( laserIntensität + team->laserIntensität + ( laserTempo + team->laserTempo ) / 5 ) - ( laserEffizienz + team->laserEffizienz );
+    double kosten = ( current.laserIntensität + team->laserIntensität + ( current.laserTempo + team->laserTempo ) / 5 ) - ( current.laserEffizienz + team->laserEffizienz );
     if( kosten < 1 )
         kosten = 1;
     return kosten;
@@ -87,7 +85,61 @@ double Spieler::calculateLaserCost()
 // nicht constant
 void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn )
 {
-	ship->setModel( data );
+    for( auto i = data->polygons->getArray(); i.set; i++ )
+    {
+        if( i.var.name->istGleich( "engine_l" ) )
+        {
+            stL = *i.var.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i.var.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i.var.tKordinaten->get( j ).x == 0.f )
+                        l = i.var.vertex->get( j );
+                    if( i.var.tKordinaten->get( j ).x == 1.f )
+                        r = i.var.vertex->get( j );
+                }
+            }
+            kL = ( ( l + ( r - l ) * 0.5 ) - stL );
+        }
+        if( i.var.name->istGleich( "engine_r" ) )
+        {
+            stR = *i.var.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i.var.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i.var.tKordinaten->get( j ).x == 0.f )
+                        l = i.var.vertex->get( j );
+                    if( i.var.tKordinaten->get( j ).x == 1.f )
+                        r = i.var.vertex->get( j );
+                }
+            }
+            kR = ( ( l + ( r - l ) * 0.5 ) - stR );
+        }
+        if( i.var.name->istGleich( "engine_m" ) )
+        {
+            stM = *i.var.schwerpunkt;
+            Vertex l, r;
+            for( int j = 0; j < 4; j++ )
+            {
+                if( i.var.tKordinaten->get( j ).y == 1.f )
+                {
+                    if( i.var.tKordinaten->get( j ).x == 0.f )
+                        l = i.var.vertex->get( j );
+                    if( i.var.tKordinaten->get( j ).x == 1.f )
+                        r = i.var.vertex->get( j );
+                }
+            }
+            kM = ( ( l + ( r - l ) * 0.5 ) - stM );
+        }
+    }
+    kL.normalize();
+    kR.normalize();
+    kM.normalize();
+    ship->setModel( data );
     flammenM = new Textur2D();
     flammenM->addAnimationZ( zFStart->getThis() );
     flammenM->addAnimationZ( zFBurn->getThis() );
@@ -104,64 +156,65 @@ void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animati
 
 void Spieler::setAccountId( int accId )
 {
-	accountId = accId;
-	name = info->getSpielerName( accountId );
-	if( name )
-		nText->setText( *name );
+    accountId = accId;
+    name = info->getSpielerName( accountId );
+    if( name )
+        nText->setText( *name );
 }
 
 void Spieler::setTeam( Team *team )
 {
-	if( this->team )
-		this->team->release();
-	this->team = team;
-	nText->setHintergrundFarbe( 0xA0000000 | ( team->farbe & 0x00FFFFFF ) );
-	nText->setLinienRahmenFarbe( team->farbe );
+    if( this->team )
+        this->team->release();
+    this->team = team;
+    nText->setHintergrundFarbe( 0xA0000000 | ( team->farbe & 0x00FFFFFF ) );
+    nText->setLinienRahmenFarbe( team->farbe );
 }
 
 void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
 {
-	farbe = fc;
-	nText->setSchriftFarbe( fc );
-	Bild *shb = new Bild();
-	shb->neuBild( zTextur->getBreite(), zTextur->getHeight(), 0 );
-	int maxP = shb->getBreite() * shb->getHeight();
-	int *buffer = zTextur->getBuffer();
-	for( int i = 0; i < maxP; i++ )
-	{
-		if( buffer[ i ] )
-		{
-			shb->setPixelDP( i, ( buffer[ i ] & 0xFF000000 ) | ( fc & 0x00FFFFFF ) );
-			shb->alphaPixelDP( i, buffer[ i ] );
-		}
-	}
+    current.farbe = fc;
+    nText->setSchriftFarbe( fc );
+    Bild *shb = new Bild();
+    shb->neuBild( zTextur->getBreite(), zTextur->getHeight(), 0 );
+    int maxP = shb->getBreite() * shb->getHeight();
+    int *buffer = zTextur->getBuffer();
+    for( int i = 0; i < maxP; i++ )
+    {
+        if( buffer[ i ] )
+        {
+            shb->setPixelDP( i, ( buffer[ i ] & 0xFF000000 ) | ( fc & 0x00FFFFFF ) );
+            shb->alphaPixelDP( i, buffer[ i ] );
+        }
+    }
     Textur2D *textur = new Textur2D();
     textur->setTexturZ( shb );
-	ship->setTextur( textur, "ship" );
+    ship->setTextur( textur, "ship" );
 }
 
 void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
 {
-	speed = Vec2< double >( xSpeed, ySpeed );
+    current.speed = Vec2< double >( xSpeed, ySpeed );
 }
 
 void Spieler::setPosition( Vec2< double > p )
 {
-	pos = p;
-	ship->setPosition( pos );
+    current.pos = p;
+    ship->setPosition( current.pos );
 }
 
 void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap )
 {
-	if( !amLeben )
-	{
-		tastatur[ ts ] = aktiv;
-		return;
-	}
-	int z = sZ - spielZeit;
-	setMoveZeit( z, zMap );
-	tastatur[ ts ] = aktiv;
-	setMoveZeit( -z, zMap );
+    if( !current.amLeben )
+    {
+        tastatur[ ts ] = aktiv;
+        return;
+    }
+    int z = sZ - current.spielZeit;
+    int time = current.spielZeit;
+    resetToSaveTime( sZ, zMap );
+    tastatur[ ts ] = aktiv;
+    resetToGameTime( time, zMap );
     if( flammenM && flammenR && flammenL )
     {
         switch( ts )
@@ -188,81 +241,159 @@ void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte
     }
 }
 
-bool Spieler::tick( Karte *zMap )
-{
-	if( !team )
-		return 0;
-	bool ret = 0;
-	double tv = TICK;
-	reinkAbk -= tv;
-	if( reinkAbk < 0 )
-		reinkAbk = 0;
-    flammenM->tick( tv );
-    flammenL->tick( tv );
-    flammenR->tick( tv );
-	if( !reinkAbk && !amLeben )
-	{ // Wiederbelebung
-		//wiederbelebung( spielZeit );
-	}
-	if( amLeben )
-	{
-		schussAbk -= tv;
-		if( schussAbk < 0 )
-			schussAbk = 0;
-		repAbk -= tv;
-		if( repAbk < 0 )
-			repAbk = 0;
-		setMoveZeit( 1, zMap );
-		if( !schussAbk )
-		{
-			if( energie != ( maxEnergie + team->maxEnergie ) )
-				ret = 1;
-			energie += ( akkuLeistung + team->akkuLeistung ) * tv;
-			if( energie >( maxEnergie + team->maxEnergie ) )
-				energie = ( maxEnergie + team->maxEnergie );
-		}
-		if( !repAbk )
-		{
-			if( stabilität != ( maxStabilität + team->maxStabilität ) )
-				ret = 1;
-			stabilität += ( reparatur + team->reparatur ) * tv;
-			if( stabilität > ( maxStabilität + team->maxStabilität ) )
-				stabilität = ( maxStabilität + team->maxStabilität );
-		}
-		zeitAmLeben += tv;
-	}
-	else
-	{
-		zeitTod += tv;
-		spielZeit++;
-	}
-	return ret;
+bool Spieler::tick( int time, Karte *zMap )
+{
+    if( time <= current.spielZeit )
+        return 0;
+    bool ret = 0;
+    while( current.spielZeit != time )
+    {
+        if( !team )
+            return 0;
+        if( !current.spielZeit )
+            last = current;
+        double tv = TICK;
+        current.reinkAbk -= tv;
+        if( current.reinkAbk < 0 )
+            current.reinkAbk = 0;
+        flammenM->tick( tv );
+        flammenL->tick( tv );
+        flammenR->tick( tv );
+        if( current.amLeben )
+        {
+            current.schussAbk -= tv;
+            if( current.schussAbk < 0 )
+                current.schussAbk = 0;
+            current.repAbk -= tv;
+            if( current.repAbk < 0 )
+                current.repAbk = 0;
+            current.spielZeit++;
+            if( tastatur[ T_GAS ] )
+            {
+                Vertex hp;
+                Vertex mv;
+                float r;
+                current.treibstoffVerbraucht += TICK;
+                if( ship->zModel()->calcHitPoint( stM, kM * (float)( current.beschleunigung + team->beschleunigung ), "ship", hp, mv, r ) )
+                {
+                    current.speed += ( Vec2<double> )mv.rotation( (float)current.rotation ) * (float)TICK;
+                }
+            }
+            else
+            {
+                double movementAngle = atan2( current.speed.y, current.speed.x );
+                if( current.speed.x != 0 )
+                    current.speed.x += 30.0f * cos( movementAngle + PI ) * TICK;
+                if( current.speed.y != 0 )
+                    current.speed.y += 30.0f * sin( movementAngle + PI ) * TICK;
+                if( current.speed.x < 6.f && current.speed.x > -6.f )
+                {
+                    current.speed.x = 0;
+                }
+                if( current.speed.y < 6.f && current.speed.y > -6.f )
+                {
+                    current.speed.y = 0;
+                }
+            }
+            if( current.rSpeed > 0 )
+            {
+                current.rSpeed -= (float)TICK;
+                if( current.rSpeed < 0 )
+                    current.rSpeed = 0;
+            }
+            if( current.rSpeed < 0 )
+            {
+                current.rSpeed += (float)TICK;
+                if( current.rSpeed > 0 )
+                    current.rSpeed = 0;
+            }
+            if( tastatur[ T_ROT_R ] )
+            {
+                Vertex hp;
+                Vertex mv;
+                float r;
+                if( ship->zModel()->calcHitPoint( stL, kL * (float)( current.wendigkeit + team->wendigkeit ), "ship", hp, mv, r ) )
+                {
+                    current.rSpeed += r * (float)TICK;
+                    current.speed += ( Vec2<double> )mv.rotation( (float)current.rotation ) * (float)TICK;
+                }
+            }
+            if( tastatur[ T_ROT_L ] )
+            {
+                Vertex hp;
+                Vertex mv;
+                float r;
+                if( ship->zModel()->calcHitPoint( stR, kR * (float)( current.wendigkeit + team->wendigkeit ), "ship", hp, mv, r ) )
+                {
+                    current.rSpeed += r * (float)TICK;
+                    current.speed += ( Vec2<double> )mv.rotation( (float)current.rotation ) * (float)TICK;
+                }
+            }
+            current.rotation += current.rSpeed * (float)TICK;
+            ship->setDrehung( (float)current.rotation );
+            if( current.speed.x || current.speed.y )
+                current.pos += current.speed * tv;
+            Vec2< int > gr = zMap->getSize();
+            while( current.pos.x < 0 )
+                current.pos.x += gr.x;
+            while( current.pos.y < 0 )
+                current.pos.y += gr.y;
+            while( current.pos.x >= gr.x )
+                current.pos.x -= gr.x;
+            while( current.pos.y >= gr.y )
+                current.pos.y -= gr.y;
+            ship->setPosition( current.pos );
+            if( !current.schussAbk )
+            {
+                if( current.energie != ( current.maxEnergie + team->maxEnergie ) )
+                    ret = 1;
+                current.energie += ( current.akkuLeistung + team->akkuLeistung ) * tv;
+                if( current.energie > ( current.maxEnergie + team->maxEnergie ) )
+                    current.energie = ( current.maxEnergie + team->maxEnergie );
+            }
+            if( !current.repAbk )
+            {
+                if( current.stabilität != ( current.maxStabilität + team->maxStabilität ) )
+                    ret = 1;
+                current.stabilität += ( current.reparatur + team->reparatur ) * tv;
+                if( current.stabilität > ( current.maxStabilität + team->maxStabilität ) )
+                    current.stabilität = ( current.maxStabilität + team->maxStabilität );
+            }
+            current.zeitAmLeben += tv;
+        }
+        else
+        {
+            current.zeitTod += tv;
+            current.spielZeit++;
+        }
+    }
+    return ret;
 }
 
 void Spieler::render( Bild &zRObj )
 {
-	if( !amLeben )
-		return;
-	ship->render( zRObj );
+    if( !current.amLeben )
+        return;
+    ship->render( zRObj );
 }
 
 void Spieler::renderLeben( Bild &zRObj )
 {
-	if( !team || !amLeben )
-		return;
-	nText->setPosition( ship->getPosition() - Punkt( 76, (int)( ship->zModel()->maxP.y * ship->getSize() ) + 30 ) );
-	nText->render( zRObj );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, team->farbe );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, team->farbe );
-	int l = (int)( stabilität * 100 / ( maxStabilität + team->maxStabilität ) * 1.5 + 0.5 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
-	int e = (int)( energie * 100 / ( maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFF0000FF );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFF0000FF );
-	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFF0000FF );
-    int e2 = (int)( (energie - calculateLaserCost() ) * 100 / ( maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
+    if( !team || !current.amLeben )
+        return;
+    nText->setPosition( ship->getPosition() - Punkt( 76, (int)( ship->zModel()->maxP.y * ship->getSize() ) + 30 ) );
+    nText->render( zRObj );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 4, 150, team->farbe );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 25, 150, team->farbe );
+    int l = (int)( current.stabilität * 100 / ( current.maxStabilität + team->maxStabilität ) * 1.5 + 0.5 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 1, l, 0xFF00FF00 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 2, l, 0xFF00FF00 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 3, l, 0xFF00FF00 );
+    int e = (int)( current.energie * 100 / ( current.maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFF0000FF );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFF0000FF );
+    zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFF0000FF );
+    int e2 = (int)( ( current.energie - calculateLaserCost() ) * 100 / ( current.maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
     if( e2 > 0 )
     {
         zRObj.drawLinieV( nText->getX() + e2, nText->getY() + 26, 3, 0xFFFFFFFF );
@@ -272,381 +403,300 @@ void Spieler::renderLeben( Bild &zRObj )
 
 void Spieler::renderMinimap( Bild &zRObj, Karte *zMap, int thisSpielerNummer )
 {
-	if( !team || !amLeben )
-		return;
-	int x = (int)( ( pos.x / zMap->getSize().x ) * 250 + 0.5 ) - 2;
-	int y = (int)( ( pos.y / zMap->getSize().y ) * 250 + 0.5 ) - 2;
+    if( !team || !current.amLeben )
+        return;
+    int x = (int)( ( current.pos.x / zMap->getSize().x ) * 250 + 0.5 ) - 2;
+    int y = (int)( ( current.pos.y / zMap->getSize().y ) * 250 + 0.5 ) - 2;
     if( sNum == thisSpielerNummer )
         zRObj.fillCircle( x + 2, y + 2, 4, 0xFFFFFFFF );
-	zRObj.fillRegion( x, y, 4, 4, team->farbe );
-	zRObj.fillRegion( x + 1, y + 1, 2, 2, farbe );
+    zRObj.fillRegion( x, y, 4, 4, team->farbe );
+    zRObj.fillRegion( x + 1, y + 1, 2, 2, current.farbe );
 }
 
 void Spieler::setSkill( int art )
 {
-	skillPunkte--;
-	switch( art )
-	{
-	case 0: // Max Stabilität
-		maxStabilität += 10;
-		team->maxStabilität = team->getMaxStabilitätBonus();
-		break;
-	case 1: // Max Energie
-		maxEnergie += 10;
-		team->maxEnergie = team->getMaxEnergieBonus();
-		break;
-	case 2: // Reparatur
-		reparatur += 0.1;
-		team->reparatur = team->getReperaturBonus();
-		break;
-	case 3: // Laser Intensität
-		laserIntensität += 3;
-		team->laserIntensität = team->getLaserIntensitätBonus();
-		break;
-	case 4: // Laser Effizienz
-		laserEffizienz += 2;
-		team->laserEffizienz = team->getLaserEffizienzBonus();
-		break;
-	case 5: // Laser Tempo
-		laserTempo += 10;
-		team->laserTempo = team->getLaserTempoBonus();
-		break;
-	case 6: // Beschleunigung
-		beschleunigung += 2;
-		team->beschleunigung = team->getBeschleunigungBonus();
-		break;
-	case 7: // Wendigkeit
-		wendigkeit += 0.15;
-		team->wendigkeit = team->getWendigkeitBonus();
-		break;
-	case 8: // Netzwerk
-		netzwerk += 1;
-		team->maxStabilität = team->getMaxStabilitätBonus();
-		team->maxEnergie = team->getMaxEnergieBonus();
-		team->reparatur = team->getReperaturBonus();
-		team->laserIntensität = team->getLaserIntensitätBonus();
-		team->laserEffizienz = team->getLaserEffizienzBonus();
-		team->laserTempo = team->getLaserTempoBonus();
-		team->beschleunigung = team->getBeschleunigungBonus();
-		team->wendigkeit = team->getWendigkeitBonus();
-		team->akkuLeistung = team->getAkkuLeistungBonus();
-		break;
-	case 9: // Akkuleistung
-		akkuLeistung += 0.4;
-		team->akkuLeistung = team->getAkkuLeistungBonus();
-		break;
-	}
+    skillPunkte--;
+    switch( art )
+    {
+    case 0: // Max Stabilität
+        current.maxStabilität += 10;
+        team->maxStabilität = team->getMaxStabilitätBonus();
+        break;
+    case 1: // Max Energie
+        current.maxEnergie += 10;
+        team->maxEnergie = team->getMaxEnergieBonus();
+        break;
+    case 2: // Reparatur
+        current.reparatur += 0.1;
+        team->reparatur = team->getReperaturBonus();
+        break;
+    case 3: // Laser Intensität
+        current.laserIntensität += 3;
+        team->laserIntensität = team->getLaserIntensitätBonus();
+        break;
+    case 4: // Laser Effizienz
+        current.laserEffizienz += 2;
+        team->laserEffizienz = team->getLaserEffizienzBonus();
+        break;
+    case 5: // Laser Tempo
+        current.laserTempo += 10;
+        team->laserTempo = team->getLaserTempoBonus();
+        break;
+    case 6: // Beschleunigung
+        current.beschleunigung += 0.15;
+        team->beschleunigung = team->getBeschleunigungBonus();
+        break;
+    case 7: // Wendigkeit
+        current.wendigkeit += 0.15;
+        team->wendigkeit = team->getWendigkeitBonus();
+        break;
+    case 8: // Netzwerk
+        current.netzwerk += 1;
+        team->maxStabilität = team->getMaxStabilitätBonus();
+        team->maxEnergie = team->getMaxEnergieBonus();
+        team->reparatur = team->getReperaturBonus();
+        team->laserIntensität = team->getLaserIntensitätBonus();
+        team->laserEffizienz = team->getLaserEffizienzBonus();
+        team->laserTempo = team->getLaserTempoBonus();
+        team->beschleunigung = team->getBeschleunigungBonus();
+        team->wendigkeit = team->getWendigkeitBonus();
+        team->akkuLeistung = team->getAkkuLeistungBonus();
+        break;
+    case 9: // Akkuleistung
+        current.akkuLeistung += 0.4;
+        team->akkuLeistung = team->getAkkuLeistungBonus();
+        break;
+    }
 }
 
 void Spieler::nimmSchaden( double intensität )
 {
-	stabilität -= intensität;
-	schadenBekommen += intensität;
-	repAbk = 2;
+    current.stabilität -= intensität;
+    current.schadenBekommen += intensität;
+    current.repAbk = 2;
 }
 
 void Spieler::machSchaden( double intensität )
 {
-	schadenGemacht += intensität;
-	treffer++;
+    current.schadenGemacht += intensität;
+    current.treffer++;
 }
 
 void Spieler::addKill()
 {
-	kills++;
-	punkte++;
-	skillPunkte += 2;
-	maxReinkAbk--;
-	if( maxReinkAbk < 5 )
-		maxReinkAbk = 5;
+    current.kills++;
+    current.punkte++;
+    skillPunkte += 2;
+    current.maxReinkAbk--;
+    if( current.maxReinkAbk < 5 )
+        current.maxReinkAbk = 5;
 }
 
 void Spieler::sterben()
 {
-	amLeben = 0;
-	tode++;
-	stabilität = 0;
-	reinkAbk += maxReinkAbk;
-	maxReinkAbk++;
-	punkte--;
+    current.amLeben = 0;
+    current.tode++;
+    current.stabilität = 0;
+    current.reinkAbk += current.maxReinkAbk;
+    current.maxReinkAbk++;
+    current.punkte--;
 }
 
 void Spieler::wiederbelebung()
 {
-	pos = startPos;
-	reinkAbk = maxReinkAbk * 2;
-	energie = maxEnergie + team->maxEnergie;
-	stabilität = maxStabilität + team->maxStabilität;
-	schussAbk = 0;
-	repAbk = 0;
-	speed = Vec2< double >( 0, 0 );
-	rotation = 0;
-	ship->setDrehung( (float)rotation );
-	ship->setPosition( pos );
-	for( int i = 0; i < T_MAX; i++ )
-		tastatur[ i ] = 0;
+    current.pos = current.startPos;
+    current.reinkAbk = current.maxReinkAbk * 2;
+    current.energie = current.maxEnergie + team->maxEnergie;
+    current.stabilität = current.maxStabilität + team->maxStabilität;
+    current.schussAbk = 0;
+    current.repAbk = 0;
+    current.speed = Vec2< double >( 0, 0 );
+    current.rotation = 0;
+    current.rSpeed = 0;
+    ship->setDrehung( (float)current.rotation );
+    ship->setPosition( current.pos );
+    for( int i = 0; i < T_MAX; i++ )
+        tastatur[ i ] = 0;
     flammenM->setAnimation( -1 );
     flammenL->setAnimation( -1 );
     flammenR->setAnimation( -1 );
-	amLeben = 1;
-}
-
-void Spieler::setMoveZeit( int z, Karte *zMap )
-{
-	spielZeit += z;
-	double tv = TICK * z;
-	if( tv < 0 )
-	{
-		if( speed.x || speed.y )
-			pos += speed * tv;
-		Vec2< int > gr = zMap->getSize();
-		while( pos.x < 0 )
-			pos.x += gr.x;
-		while( pos.y < 0 )
-			pos.y += gr.y;
-		while( pos.x >= gr.x )
-			pos.x -= gr.x;
-		while( pos.y >= gr.y )
-			pos.y -= gr.y;
-		ship->setPosition( pos );
-		if( tastatur[ T_ROT_R ] )
-			rotation += tv * ( wendigkeit + team->wendigkeit );
-		if( tastatur[ T_ROT_L ] )
-			rotation -= tv * ( wendigkeit + team->wendigkeit );
-		ship->setDrehung( (float)rotation );
-		if( tastatur[ T_GAS ] )
-		{
-			treibstoffVerbraucht += tv;
-			speed.x += ( beschleunigung + team->beschleunigung ) * cos( rotation ) * tv;
-			speed.y += ( beschleunigung + team->beschleunigung ) * sin( rotation ) * tv;
-		}
-		else
-		{
-			double movementAngle = atan2( speed.y, speed.x );
-			for( int i = 1; i <= -z; i++ )
-			{
-				if( stopXSpeedT == spielZeit + ( -z - i ) )
-					speed.x = stopXSpeed;
-				if( stopYSpeedT == spielZeit + ( -z - i ) )
-					speed.y = stopYSpeed;
-				if( speed.x != 0 )
-					speed.x += 30.0f * cos( movementAngle + PI ) * -TICK;
-				if( speed.y != 0 )
-					speed.y += 30.0f * sin( movementAngle + PI ) * -TICK;
-			}
-		}
-	}
-	else
-	{
-		if( tastatur[ T_GAS ] )
-		{
-			treibstoffVerbraucht += tv;
-			speed.x += ( beschleunigung + team->beschleunigung ) * cos( rotation ) * tv;
-			speed.y += ( beschleunigung + team->beschleunigung ) * sin( rotation ) * tv;
-		}
-		else
-		{
-			double movementAngle = atan2( speed.y, speed.x );
-			for( int i = 1; i <= z; i++ )
-			{
-				if( speed.x != 0 )
-					speed.x += 30.0f * cos( movementAngle + PI ) * TICK;
-				if( speed.y != 0 )
-					speed.y += 30.0f * sin( movementAngle + PI ) * TICK;
-				if( speed.x < 6.f && speed.x > -6.f )
-				{
-					stopXSpeedT = spielZeit - ( z - i );
-					stopXSpeed = speed.x;
-					speed.x = 0;
-				}
-				if( speed.y < 6.f && speed.y > -6.f )
-				{
-					stopYSpeedT = spielZeit - ( z - i );
-					stopYSpeed = speed.y;
-					speed.y = 0;
-				}
-			}
-		}
-		if( tastatur[ T_ROT_R ] )
-			rotation += tv * ( wendigkeit + team->wendigkeit );
-		if( tastatur[ T_ROT_L ] )
-			rotation -= tv * ( wendigkeit + team->wendigkeit );
-		ship->setDrehung( (float)rotation );
-		if( speed.x || speed.y )
-			pos += speed * tv;
-		Vec2< int > gr = zMap->getSize();
-		while( pos.x < 0 )
-			pos.x += gr.x;
-		while( pos.y < 0 )
-			pos.y += gr.y;
-		while( pos.x >= gr.x )
-			pos.x -= gr.x;
-		while( pos.y >= gr.y )
-			pos.y -= gr.y;
-		ship->setPosition( pos );
-	}
+    current.amLeben = 1;
+}
+
+void Spieler::resetToSaveTime( int t, Karte *zMap )
+{
+    if( last.spielZeit > t )
+        return; // this should never be possible
+    current = last;
+    tick( t, zMap );
+}
+
+void Spieler::resetToGameTime( int t, Karte *zMap )
+{
+    last = current;
+    tick( t, zMap );
 }
 
 void Spieler::hatGeschossen()
 {
-	energie -= calculateLaserCost();
-	schussAbk = 1;
-	schüsse++;
+    current.energie -= calculateLaserCost();
+    current.schussAbk = 1;
+    current.schüsse++;
 }
 
 // constant
 int Spieler::getAccountId() const
 {
-	return accountId;
+    return accountId;
 }
 
 Text *Spieler::getName() const
 {
-	return name ? name->getThis() : 0;
+    return name ? name->getThis() : 0;
 }
 
 Text *Spieler::zName() const
 {
-	return name;
+    return name;
 }
 
 bool Spieler::hatSkill() const
 {
-	return skillPunkte != 0;
+    return skillPunkte != 0;
 }
 
 bool Spieler::istAmLeben() const
 {
-	return amLeben;
+    return current.amLeben;
 }
 
 // Statistik Werte
 int Spieler::getSpielerNummer() const
 {
-	return sNum;
+    return sNum;
 }
 
 Team *Spieler::zTeam() const
 {
-	return team;
+    return team;
 }
 
 int Spieler::getSpielerFarbe() const
 {
-	return farbe;
+    return current.farbe;
 }
 
 int Spieler::getSchadenBekommen() const
 {
-	return (int)schadenBekommen;
+    return (int)current.schadenBekommen;
 }
 
 int Spieler::getSchadenGemacht() const
 {
-	return (int)schadenGemacht;
+    return (int)current.schadenGemacht;
 }
 
 int Spieler::getTreibstoffVerbraucht() const
 {
-	return (int)treibstoffVerbraucht;
+    return (int)current.treibstoffVerbraucht;
 }
 
 int Spieler::getSchüsse() const
 {
-	return schüsse;
+    return current.schüsse;
 }
 
 int Spieler::getTreffer() const
 {
-	return treffer;
+    return current.treffer;
 }
 
 int Spieler::getPunkte() const
 {
-	return punkte;
+    return current.punkte;
 }
 
 int Spieler::getKills() const
 {
-	return kills;
+    return current.kills;
 }
 
 int Spieler::getTode() const
 {
-	return tode;
+    return current.tode;
 }
 
 int Spieler::getZeitAmLeben() const
 {
-	return (int)zeitAmLeben;
+    return (int)current.zeitAmLeben;
 }
 
 int Spieler::getZeitTod() const
 {
-	return (int)zeitTod;
+    return (int)current.zeitTod;
 }
 
 Punkt Spieler::getPos() const
 {
-	return (Punkt)pos;
+    return (Punkt)current.pos;
 }
 
 double Spieler::getTeamMaxEnergieBonus() const
 {
-	return maxEnergie / 100 * netzwerk;
+    return current.maxEnergie / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamMaxStabilitätBonus() const
 {
-	return maxStabilität / 100 * netzwerk;
+    return current.maxStabilität / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamReparaturBonus() const
 {
-	return reparatur / 100 * netzwerk;
+    return current.reparatur / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamLaserIntensitätBonus() const
 {
-	return laserIntensität / 100 * netzwerk;
+    return current.laserIntensität / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamLaserEffizienzBonus() const
 {
-	return laserEffizienz / 100 * netzwerk;
+    return current.laserEffizienz / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamAkkuLeistungBonus() const
 {
-	return akkuLeistung / 100 * netzwerk;
+    return current.akkuLeistung / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamLaserTempoBonus() const
 {
-	return laserTempo / 100 * netzwerk;
+    return current.laserTempo / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamBeschleunigungBonus() const
 {
-	return beschleunigung / 100 * netzwerk;
+    return current.beschleunigung / 100 * current.netzwerk;
 }
 
 double Spieler::getTeamWendigkeitBonus() const
 {
-	return wendigkeit / 100 * netzwerk;
+    return current.wendigkeit / 100 * current.netzwerk;
 }
 
 // Reference Counting
 Spieler *Spieler::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Spieler *Spieler::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Asteroids/Spiel/Spieler/Spieler.h

@@ -27,58 +27,63 @@ class Spieler
 {
 	friend class SpielerGUI;
 private:
-	int accountId;
-	int sNum;
-	int farbe;
-	Model2D *ship;
-	Team *team;
-	InformationKlientV *info;
-	Text *name;
-	bool tastatur[ T_MAX ];
-	bool amLeben;
-	double schussAbk;
-	double repAbk;
-	double reinkAbk;
-	int maxReinkAbk;
-	int spielZeit;
-	int stopXSpeedT;
-	int stopYSpeedT;
-	double stopXSpeed;
-	double stopYSpeed;
+    int accountId;
+    int sNum;
+    bool tastatur[ T_MAX ];
+    Model2D *ship;
+    Team *team;
+    InformationKlientV *info;
+    Text *name;
+    Vertex stL;
+    Vertex kL;
+    Vertex stR;
+    Vertex kR;
+    Vertex stM;
+    Vertex kM;
+    struct SpielerDataSave
+    {
+        float rSpeed;
+        int farbe;
+        bool amLeben;
+        double schussAbk;
+        double repAbk;
+        double reinkAbk;
+        int maxReinkAbk;
+        int spielZeit;
+        Punkt startPos;
+        Vec2< double > pos;
+        Vec2< double > speed;
+        double rotation;
+        double beschleunigung;
+        double energie;
+        double stabilität;
+        double reparatur;
+        double laserIntensität;
+        double laserEffizienz;
+        double akkuLeistung;
+        double maxEnergie;
+        double maxStabilität;
+        double laserTempo;
+        double netzwerk;
+        double wendigkeit;
+        double zeitAmLeben;
+        double zeitTod;
+        double schadenBekommen;
+        double schadenGemacht;
+        double treibstoffVerbraucht;
+        int schüsse;
+        int treffer;
+        int punkte;
+        int kills;
+        int tode;
+    };
+    SpielerDataSave last;
+    SpielerDataSave current;
 	int ref;
-	// Raumschiff Eigenschaften
-	Punkt startPos;
-	Vec2< double > pos;
-	Vec2< double > speed;
-	double rotation;
-	double beschleunigung;
-	double energie;
-	double stabilität;
-	double reparatur;
-	double laserIntensität;
-	double laserEffizienz;
-	double akkuLeistung;
-	double maxEnergie;
-	double maxStabilität;
-	double laserTempo;
-	double netzwerk;
-	double wendigkeit;
 	int skillPunkte;
-	// Statistik Werte
-	double schadenBekommen;
-	double schadenGemacht;
-	double treibstoffVerbraucht;
-	int schüsse;
-	int treffer;
-	int punkte;
-	int kills;
-	int tode;
-	double zeitAmLeben;
-	double zeitTod;
     Textur2D *flammenM;
     Textur2D *flammenL;
     Textur2D *flammenR;
-	// Namen Anzeige
     TextFeld *nText;
 
     double calculateLaserCost();
@@ -96,7 +101,7 @@ public:
 	void setGeschwindigkeit( double xSpeed, double ySpeed );
 	void setPosition( Vec2< double > p );
 	void setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap );
-	bool tick( Karte *zMap );
+	bool tick( int time, Karte *zMap );
 	void render( Bild &zRObj );
 	void renderLeben( Bild &zRObj );
 	void renderMinimap( Bild &zRObj, Karte *zMap, int thisSpielerNummer );
@@ -106,7 +111,8 @@ public:
 	void addKill();
 	void sterben();
 	void wiederbelebung();
-	void setMoveZeit( int z, Karte *zMap );
+	void resetToSaveTime( int t, Karte *zMap );
+    void resetToGameTime( int t, Karte *zMap );
 	void hatGeschossen();
 	// constant
 	int getAccountId() const;

Asteroids/Spiel/SpielerGUI/SpielerGUI.cpp

@@ -111,93 +111,93 @@ SpielerGUI::~SpielerGUI()
 void SpielerGUI::update( Spieler *zSpieler )
 {
 	spieler->setText( zSpieler->name->getText() );
-	spieler->setSchriftFarbe( zSpieler->farbe );
+	spieler->setSchriftFarbe( zSpieler->current.farbe );
 	Text txt;
-	txt.setPrecision( getStellen( zSpieler->stabilität ) + 2 );
-	txt = zSpieler->stabilität;
+	txt.setPrecision( getStellen( zSpieler->current.stabilität ) + 2 );
+	txt = zSpieler->current.stabilität;
 	txt += "/";
-	txt.setPrecision( getStellen( zSpieler->maxStabilität ) + 2 );
-	txt += zSpieler->maxStabilität;
+	txt.setPrecision( getStellen( zSpieler->current.maxStabilität ) + 2 );
+	txt += zSpieler->current.maxStabilität;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->maxStabilität ) + 2 );
 	txt += zSpieler->team->maxStabilität;
 	txt += ")";
 	stabilität->setText( txt );
 	stabilitätB->reset();
-	stabilitätB->setAktionAnzahl( (int)( zSpieler->maxStabilität + zSpieler->team->maxStabilität ) );
-	stabilitätB->aktionPlus( (int)( zSpieler->stabilität ) );
-	txt.setPrecision( getStellen( zSpieler->energie ) + 2 );
-	txt = zSpieler->energie;
+	stabilitätB->setAktionAnzahl( (int)( zSpieler->current.maxStabilität + zSpieler->team->maxStabilität ) );
+	stabilitätB->aktionPlus( (int)( zSpieler->current.stabilität ) );
+	txt.setPrecision( getStellen( zSpieler->current.energie ) + 2 );
+	txt = zSpieler->current.energie;
 	txt += "/";
-	txt.setPrecision( getStellen( zSpieler->maxEnergie ) + 2 );
-	txt += zSpieler->maxEnergie;
+	txt.setPrecision( getStellen( zSpieler->current.maxEnergie ) + 2 );
+	txt += zSpieler->current.maxEnergie;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->maxEnergie ) + 2 );
 	txt += zSpieler->team->maxEnergie;
 	txt += ")";
 	energie->setText( txt );
 	energieB->reset();
-	energieB->setAktionAnzahl( (int)( zSpieler->maxEnergie + zSpieler->team->maxEnergie ) );
-	energieB->aktionPlus( (int)( zSpieler->energie ) );
+	energieB->setAktionAnzahl( (int)( zSpieler->current.maxEnergie + zSpieler->team->maxEnergie ) );
+	energieB->aktionPlus( (int)( zSpieler->current.energie ) );
 	txt = "Reparatur:";
-	txt.setPrecision( getStellen( zSpieler->reparatur ) + 2 );
-	txt += zSpieler->reparatur;
+	txt.setPrecision( getStellen( zSpieler->current.reparatur ) + 2 );
+	txt += zSpieler->current.reparatur;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->reparatur ) + 2 );
 	txt += zSpieler->team->reparatur;
 	txt += ")";
 	reparatur->setText( txt );
 	txt = "Akku:";
-	txt.setPrecision( getStellen( zSpieler->akkuLeistung ) + 2 );
-	txt += zSpieler->akkuLeistung;
+	txt.setPrecision( getStellen( zSpieler->current.akkuLeistung ) + 2 );
+	txt += zSpieler->current.akkuLeistung;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->akkuLeistung ) + 2 );
 	txt += zSpieler->team->akkuLeistung;
 	txt += ")";
 	akkuLeistung->setText( txt );
 	txt = "Wendigkeit:";
-	txt.setPrecision( getStellen( zSpieler->wendigkeit ) + 2 );
-	txt += zSpieler->wendigkeit;
+	txt.setPrecision( getStellen( zSpieler->current.wendigkeit ) + 2 );
+	txt += zSpieler->current.wendigkeit;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->wendigkeit ) + 2 );
 	txt += zSpieler->team->wendigkeit;
 	txt += ")";
 	wendigkeit->setText( txt );
 	txt = "Beschleunigung:";
-	txt.setPrecision( getStellen( zSpieler->beschleunigung ) + 2 );
-	txt += zSpieler->beschleunigung;
+	txt.setPrecision( getStellen( zSpieler->current.beschleunigung ) + 2 );
+	txt += zSpieler->current.beschleunigung;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->beschleunigung ) + 2 );
 	txt += zSpieler->team->beschleunigung;
 	txt += ")";
 	beschleunigung->setText( txt );
 	txt = "Laser intensität:";
-	txt.setPrecision( getStellen( zSpieler->laserIntensität ) + 2 );
-	txt += zSpieler->laserIntensität;
+	txt.setPrecision( getStellen( zSpieler->current.laserIntensität ) + 2 );
+	txt += zSpieler->current.laserIntensität;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->laserIntensität ) + 2 );
 	txt += zSpieler->team->laserIntensität;
 	txt += ")";
 	laserIntensität->setText( txt );
 	txt = "Laser effizienz:";
-	txt.setPrecision( getStellen( zSpieler->laserEffizienz ) + 2 );
-	txt += zSpieler->laserEffizienz;
+	txt.setPrecision( getStellen( zSpieler->current.laserEffizienz ) + 2 );
+	txt += zSpieler->current.laserEffizienz;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->laserEffizienz ) + 2 );
 	txt += zSpieler->team->laserEffizienz;
 	txt += ")";
 	laserEffizienz->setText( txt );
 	txt = "Laser tempo:";
-	txt.setPrecision( getStellen( zSpieler->laserTempo ) + 2 );
-	txt += zSpieler->laserTempo;
+	txt.setPrecision( getStellen( zSpieler->current.laserTempo ) + 2 );
+	txt += zSpieler->current.laserTempo;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->laserTempo ) + 2 );
 	txt += zSpieler->team->laserTempo;
 	txt += ")";
 	laserTempo->setText( txt );
 	txt = "Netzwerk:";
-	txt.setPrecision( getStellen( zSpieler->netzwerk ) + 2 );
-	txt += zSpieler->netzwerk;
+	txt.setPrecision( getStellen( zSpieler->current.netzwerk ) + 2 );
+	txt += zSpieler->current.netzwerk;
 	netzwerk->setText( txt );
 	stabilitätSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
 	energieSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );