Nutzt nun neues 2D Framework

Asteroids/Asteroids.vcxproj

@@ -191,7 +191,6 @@
     <ClInclude Include="Spiel\Chat\Chat.h" />
     <ClInclude Include="Spiel\Define.h" />
     <ClInclude Include="Spiel\Ende\Ende.h" />
-    <ClInclude Include="Spiel\Kamera\Kamera.h" />
     <ClInclude Include="Spiel\Karte\Karte.h" />
     <ClInclude Include="Spiel\Karte\Strukturen.h" />
     <ClInclude Include="Spiel\Objekt\SpielObjekt.h" />
@@ -222,7 +221,6 @@
     <ClCompile Include="Spiel\Bestenliste\Bestenliste.cpp" />
     <ClCompile Include="Spiel\Chat\Chat.cpp" />
     <ClCompile Include="Spiel\Ende\Ende.cpp" />
-    <ClCompile Include="Spiel\Kamera\Kamera.cpp" />
     <ClCompile Include="Spiel\Karte\Karte.cpp" />
     <ClCompile Include="Spiel\Karte\Strukturen.cpp" />
     <ClCompile Include="Spiel\Objekt\SpielObjekt.cpp" />

Asteroids/Asteroids.vcxproj.filters

@@ -45,9 +45,6 @@
     <ClInclude Include="Spiel\Spieler\Spieler.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Spiel\Kamera\Kamera.h">
-      <Filter>Headerdateien</Filter>
-    </ClInclude>
     <ClInclude Include="Spiel\Karte\Karte.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
@@ -158,9 +155,6 @@
     <ClCompile Include="Spiel\Ende\Ende.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Spiel\Kamera\Kamera.cpp">
-      <Filter>Quelldateien</Filter>
-    </ClCompile>
     <ClCompile Include="Spiel\Karte\Strukturen.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>

Asteroids/Spiel/Kamera/Kamera.cpp

@@ -1,292 +0,0 @@
-#include "Kamera.h"
-#include "../Karte/Karte.h"
-
-// Inhalt der Kamera Klasse aus Kamera.h
-// Konstruktor
-Kamera::Kamera()
-{
-	pos = Punkt( 0, 0 );
-	mmr.setFarbe( 0xFFFFFFFF );
-	mmr.setRamenBreite( 1 );
-	ref = 1;
-}
-
-// nicht constant
-void Kamera::setPosition( int x, int y )
-{
-	pos = Punkt( x, y );
-}
-
-void Kamera::addPosition( int x, int y, Karte *zMap )
-{
-	pos += Punkt( x, y );
-	if( zMap )
-	{
-		if( pos.x < 0 )
-			pos.x += zMap->getSize().x;
-		if( pos.y < 0 )
-			pos.y += zMap->getSize().y;
-		if( pos.x >= zMap->getSize().x )
-			pos.x -= zMap->getSize().x;
-		if( pos.y >= zMap->getSize().y )
-			pos.y -= zMap->getSize().y;
-	}
-}
-
-bool Kamera::beginnRender( Bild &zRObj, Karte *zMap, int n )
-{
-	Punkt kamLO( pos.x - zRObj.getBreite() / 2, pos.y - zRObj.getHeight() / 2 );
-	Punkt kamRU( pos.x + zRObj.getBreite() / 2, pos.y + zRObj.getHeight() / 2 );
-	Punkt mapGr = zMap->getSize();
-	int c = 0;
-	if( kamLO.x < 0 )
-		c |= 1;
-	if( kamLO.y / 2 < 0 )
-		c |= 2;
-	if( kamRU.x > mapGr.x )
-		c |= 4;
-	if( kamRU.y > mapGr.y )
-		c |= 8;
-	switch( c )
-	{
-	case 0:
-		if( n )
-			return 0;
-		if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-			return 0;
-		zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		break;
-	case 1:
-		if( n > 1 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x + zMap->getSize().x, kamLO.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		break;
-	case 2:
-		if( n > 1 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y + mapGr.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		break;
-	case 3:
-		if( n > 3 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y + mapGr.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y );
-		}
-		if( n == 2 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y + mapGr.y );
-		}
-		if( n == 3 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		break;
-	case 4:
-		if( n > 1 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y );
-		}
-		break;
-	case 6:
-		if( n > 3 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y + mapGr.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y + mapGr.y );
-		}
-		if( n == 2 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y );
-		}
-		if( n == 3 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		break;
-	case 8:
-		if( n > 1 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y - mapGr.y );
-		}
-		break;
-	case 9:
-		if( n > 3 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x + mapGr.x, kamLO.y - mapGr.y );
-		}
-		if( n == 2 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y - mapGr.y );
-		}
-		if( n == 3 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		break;
-	case 12:
-		if( n > 3 )
-			return 0;
-		if( !n )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y );
-		}
-		if( n == 1 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x, kamLO.y - mapGr.y );
-		}
-		if( n == 2 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y );
-		}
-		if( n == 3 )
-		{
-			if( !zRObj.setDrawOptions( 0, 0, zRObj.getBreite(), zRObj.getHeight() ) )
-				return 0;
-			zRObj.addScrollOffset( kamLO.x - mapGr.x, kamLO.y - mapGr.y );
-		}
-		break;
-	}
-	return 1;
-}
-
-void Kamera::endRender( Bild &zRObj )
-{
-	zRObj.releaseDrawOptions();
-}
-
-void Kamera::beginnMinimap( Bild &zRObj, Karte *zMap )
-{
-	zRObj.setDrawOptions( zRObj.getBreite() - 260, zRObj.getHeight() - 260, 250, 250 );
-	zRObj.drawLinieH( 0, 0, 250, 0xFFFFFFFF );
-	zRObj.drawLinieH( 0, 249, 250, 0xFFFFFFFF );
-	zRObj.drawLinieV( 0, 0, 250, 0xFFFFFFFF );
-	zRObj.drawLinieV( 249, 0, 250, 0xFFFFFFFF );
-	mmr.setSize( (int)( ( zRObj.getBreite() / (double)zMap->getSize().x ) * 250 + 0.5 ), (int)( ( zRObj.getHeight() / (double)zMap->getSize().y ) * 250 + 0.5 ) );
-	mmr.setPosition( (int)( ( pos.x / (double)zMap->getSize().x ) * 250 + 0.5 ), (int)( ( pos.y / (double)zMap->getSize().y ) * 250 + 0.5 ) );
-	mmr.setPosition( mmr.getPosition() - mmr.getSize() / 2 );
-	mmr.render( zRObj );
-	if( mmr.getX() < 0 )
-		mmr.setPosition( mmr.getPosition() + Punkt( 250, 0 ) );
-	mmr.render( zRObj );
-	if( mmr.getY() < 0 )
-		mmr.setPosition( mmr.getPosition() + Punkt( 0, 250 ) );
-	if( mmr.getX() >= 250 - mmr.getBreite() )
-		mmr.setPosition( mmr.getPosition() - Punkt( 250, 0 ) );
-	mmr.render( zRObj );
-	if( mmr.getY() >= 250 - mmr.getHeight() )
-		mmr.setPosition( mmr.getPosition() - Punkt( 0, 250 ) );
-	mmr.render( zRObj );
-}
-
-void Kamera::endMinimap( Bild &zRObj )
-{
-	zRObj.releaseDrawOptions();
-}
-
-// constant
-Punkt Kamera::getPos() const
-{
-	return pos;
-}
-
-// Reference Counting
-Kamera *Kamera::getThis()
-{
-	ref++;
-	return this;
-}
-
-Kamera *Kamera::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
-}

Asteroids/Spiel/Kamera/Kamera.h

@@ -1,35 +0,0 @@
-#ifndef Kamera_H
-#define Kamera_H
-
-#include <Bild.h>
-#include <Rahmen.h>
-
-using namespace Framework;
-
-class Karte;
-
-class Kamera
-{
-private:
-	Punkt pos;
-	LRahmen mmr;
-	int ref;
-
-public:
-	// Konstruktor
-	Kamera();
-	// nicht constant
-	void setPosition( int x, int y );
-	void addPosition( int x, int y, Karte *zMap );
-	bool beginnRender( Bild &zRObj, Karte *zMap, int n );
-	void endRender( Bild &zRObj );
-	void beginnMinimap( Bild &zRObj, Karte *zMap );
-	void endMinimap( Bild &zRObj );
-	// constant
-	Punkt getPos() const;
-	// Reference Counting
-	Kamera *getThis();
-	Kamera *release();
-};
-
-#endif

Asteroids/Spiel/Karte/Karte.cpp

@@ -163,7 +163,7 @@ SpielObjekt *Karte::createObjekt( int oNum, Schrift *zSchrift ) const
     for( auto i = &ressources->getArray(); i && i->set && i->var; i = i->next )
     {
         if( i->var->getId() == obj->m2d )
-            ret->setModelData( i->var->zReccourceM2()->getThis() );
+            ret->setModel( i->var->zReccourceM2()->getThis() );
         if( i->var->getId() == obj->bild )
             ret->setTextur( i->var->zReccourceTxt()->getThis() );
     }

Asteroids/Spiel/Objekt/SpielObjekt.cpp

@@ -6,11 +6,9 @@
 // Inhalt der SpielObjekt Klasse aus SpielObjekt.h
 // Konstruktor
 SpielObjekt::SpielObjekt( ObjektStr *zStr, Schrift *zSchrift )
+    : Model2DObject()
 {
-	pos = zStr->pos;
 	id = zStr->id;
-	mdl = new Model2D();
-	mdl->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur );
 	style = zStr->style;
 	stabilität = zStr->maxStabilität;
 	energie = zStr->maxEnergie;
@@ -22,29 +20,22 @@ SpielObjekt::SpielObjekt( ObjektStr *zStr, Schrift *zSchrift )
 	team = 0;
 	nText = initTextFeld( 0, 0, 152, 30, zSchrift, TextFeld::Style::Text | TextFeld::Style::Rahmen | TextFeld::Style::Center |
 						  TextFeld::Style::Hintergrund | TextFeld::Style::HAlpha, "" );
-	ref = 1;
 }
 
 // Destruktor
 SpielObjekt::~SpielObjekt()
 {
-	mdl->release();
 	if( team )
 		team->release();
 	nText->release();
 }
 
 // nicht constant
-void SpielObjekt::setModelData( Model2DData *data )
-{
-	mdl->setModel( data );
-}
-
 void SpielObjekt::setTextur( Bild *textur )
 {
     Textur2D *t = new Textur2D();
     t->setTexturZ( textur );
-	mdl->setTextur( t );
+    __super::setTextur( t );
 }
 
 void SpielObjekt::setTeam( Team *team )
@@ -54,17 +45,17 @@ void SpielObjekt::setTeam( Team *team )
 	this->team = team;
 }
 
-void SpielObjekt::tick()
+bool SpielObjekt::tick( const WeltInfo &info, double zeit )
 {
-	repAbk -= TICK;
+	repAbk -= zeit;
 	if( repAbk < 0 )
 		repAbk = 0;
-	akkuAbk -= TICK;
+	akkuAbk -= zeit;
 	if( akkuAbk < 0 )
 		akkuAbk = 0;
 	if( !repAbk )
 	{
-		stabilität += reparatur * TICK;
+		stabilität += reparatur * zeit;
 		if( stabilität > maxStabilität )
 			stabilität = maxStabilität;
 	}
@@ -72,27 +63,24 @@ void SpielObjekt::tick()
 	{
 		if( !team )
 		{
-			energie -= akkuLeistung * TICK;
+			energie -= akkuLeistung * zeit;
 			if( energie < 0 )
 				energie = 0;
 		}
 		else
 		{
-			energie += akkuLeistung * TICK;
+			energie += akkuLeistung * zeit;
 			if( energie > maxEnergie )
 				energie = maxEnergie;
 		}
 	}
+    __super::tick( info, zeit );
+    return 1;
 }
 
-void SpielObjekt::render( Bild &zRObj )
-{
-	mdl->render( zRObj );
-}
-
-void SpielObjekt::renderLeben( Bild &zRObj )
+void SpielObjekt::renderLeben( Mat3<float> &kamMat, Bild &zRObj )
 {
-	nText->setPosition( mdl->getPosition() - Punkt( 76, (int)( mdl->zModel()->maxP.y * mdl->getSize() ) + 30 ) );
+	nText->setPosition( (Punkt)( kamMat * (getPosition() - Punkt( 76, (int)( zModel()->maxP.y * getSize() ) + 30 ) ) ) );
 	nText->render( zRObj );
 	int teamF = team ? team->farbe : 0;
 	double teamStab = team ? team->maxStabilität : 0;
@@ -113,19 +101,4 @@ void SpielObjekt::renderLeben( Bild &zRObj )
 Team *SpielObjekt::zTeam() const
 {
 	return team;
-}
-
-// Reference Counting
-SpielObjekt *SpielObjekt::getThis()
-{
-	ref++;
-	return this;
-}
-
-SpielObjekt *SpielObjekt::release()
-{
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
 }

Asteroids/Spiel/Objekt/SpielObjekt.h

@@ -6,15 +6,14 @@
 #include "../Team/Team.h"
 #include "../Karte/Strukturen.h"
 #include <TextFeld.h>
+#include <Welt2D.h>
 
 using namespace Framework;
 
-class SpielObjekt
+class SpielObjekt : public Model2DObject
 {
 private:
-	Vec2< double > pos;
 	int id;
-	Model2D *mdl;
 	int style;
 	double stabilität;
 	double energie;
@@ -27,7 +26,6 @@ private:
 	double akkuAbk;
 	Team *team;
 	TextFeld *nText;
-	int ref;
 
 public:
 	// Konstruktor
@@ -35,17 +33,12 @@ public:
 	// Destruktor
 	~SpielObjekt();
 	// nicht constant
-	void setModelData( Model2DData *data );
 	void setTextur( Bild *textur );
 	void setTeam( Team *team );
-	void tick();
-	void render( Bild &zRObj );
-	void renderLeben( Bild &zRObj );
+	bool tick( const WeltInfo &info, double zeit ) override;
+	void renderLeben( Mat3<float> &kamMat, Bild &zRObj );
 	// constant
 	Team *zTeam() const;
-	// Reference Counting
-	SpielObjekt *getThis();
-	SpielObjekt *release();
 };
 
 #endif

Asteroids/Spiel/Schuss/Laser.cpp

@@ -6,190 +6,169 @@
 // Inhalt der Laser Klasse aus Laser.h
 // Konstruktor
 Laser::Laser( int id, Vec2< double > pos, Vec2< double > speed, int sNum, double intensität, int tf )
+    : Object2D()
 {
-	this->id = id;
-	this->pos = pos;
-	this->speed = speed;
-	this->sNum = sNum;
-	this->intensität = intensität;
-	this->startIntensität = intensität;
-	this->tf = tf;
-	ref = 1;
+    this->id = id;
+    setPosition( pos );
+    setSpeed( speed );
+    this->sNum = sNum;
+    this->intensität = intensität;
+    this->startIntensität = intensität;
+    this->tf = tf;
 }
 
 // privat
 char Laser::getOutCode( Punkt& p, Bild &zrObj ) const
 {
-	char ret = 0;
-	if( p.x < 0 )
-		ret |= 1;
-	else if( p.x >= zrObj.getBreite() )
-		ret |= 2;
-	if( p.y < 0 )
-		ret |= 4;
-	else if( p.y >= zrObj.getHeight() )
-		ret |= 8;
-	return ret;
+    char ret = 0;
+    if( p.x < 0 )
+        ret |= 1;
+    else if( p.x >= zrObj.getBreite() )
+        ret |= 2;
+    if( p.y < 0 )
+        ret |= 4;
+    else if( p.y >= zrObj.getHeight() )
+        ret |= 8;
+    return ret;
 }
 
 // nicht constant
-void Laser::tick( int tick, Karte *zMap )
+Rect2< float > Laser::getBoundingBox() const
 {
-	double tickVal = tick * TICK;
-	pos += speed * tickVal;
-	Vec2< int > gr = zMap->getSize();
-	if( pos.x < 0 )
-		pos.x += gr.x;
-	if( pos.y < 0 )
-		pos.y += gr.y;
-	if( pos.x >= gr.x )
-		pos.x -= gr.x;
-	if( pos.y >= gr.y )
-		pos.y -= gr.y;
-	intensität -= tickVal * 2;
+    return Rect2< float >();
 }
 
-void Laser::render( Bild &zRObj )
+bool Laser::tick( const WeltInfo &info, double tv )
 {
-	int fa = (int)( ( intensität / startIntensität ) * 255 );
-	int f = ( ( fa << 24 ) & 0xFF000000 ) | ( tf & 0xFFFFFF );
-	Punkt a( pos );
-	Punkt b( pos - ( speed / speed.getLength() * 10 ) );
-	a += zRObj.getDrawOff();
-	b += zRObj.getDrawOff();
-	char outCode1 = getOutCode( a, zRObj );
-	char outCode2 = getOutCode( b, zRObj );
-	bool ok = 0;
-	while( 1 )
-	{
-		int xMax = zRObj.getDrawGr().x - 1;
-		int yMax = zRObj.getDrawGr().y - 1;
-		if( !( outCode1 | outCode2 ) )
-		{
-			ok = 1;
-			break;
-		}
-		else if( outCode1 & outCode2 )
-			break;
-		else
-		{
-			int x = 0, y = 0;
-			char outCodeOut = outCode1 ? outCode1 : outCode2;
-			if( outCodeOut & 8 )
-			{
-				x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
-				y = yMax;
-			}
-			else if( outCodeOut & 4 )
-			{
-				x = (int)( a.x + ( b.x - a.x ) * ( zRObj.getDrawPos().y - a.y ) / ( b.y - a.y ) + 0.5 );
-				y = zRObj.getDrawPos().y;
-			}
-			else if( outCodeOut & 2 )
-			{
-				y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
-				x = xMax;
-			}
-			else if( outCodeOut & 1 )
-			{
-				y = (int)( a.y + ( b.y - a.y ) * ( zRObj.getDrawPos().x - a.x ) / ( b.x - a.x ) + 0.5 );
-				x = zRObj.getDrawPos().x;
-			}
-			if( outCodeOut == outCode1 )
-			{
-				a.x = x;
-				a.y = y;
-				outCode1 = getOutCode( a, zRObj );
-			}
-			else
-			{
-				b.x = x;
-				b.y = y;
-				outCode2 = getOutCode( b, zRObj );
-			}
-		}
-	}
-	if( ok )
-	{
-		int xlän = b.x - a.x, axlän = abs( xlän );
-		int ylän = b.y - a.y, aylän = abs( ylän );
-		double xf = (double)xlän / ( aylän ? aylän : 1 );
-		double yf = (double)ylän / ( axlän ? axlän : 1 );
-		if( axlän > aylän )
-			xf = xf < 0 ? -1 : 1;
-		else
-			yf = yf < 0 ? -1 : 1;
-		double x = (double)a.x, y = (double)a.y;
-		int maxP = (int)( sqrt( xlän * xlän + ylän * ylän ) + 0.5 );
-		int count = 0;
-		int *buffer = zRObj.getBuffer();
-		int maxPixel = zRObj.getBreite() * zRObj.getHeight();
-		while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
-		{
-			++count;
-			if( (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel )
-			    buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] = 0xFFFFFFFF;
-			if( (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel && 
-				buffer[ (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
-				zRObj.alphaPixel( (int)( x - 0.5 ), (int)( y + 0.5 ), f );
-			if( (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel && 
-				buffer[ (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
-				zRObj.alphaPixel( (int)( x + 1.5 ), (int)( y + 0.5 ), f );
-			if( (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * zRObj.getBreite() ) < maxPixel && 
-				buffer[ (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
-				zRObj.alphaPixel( (int)( x + 0.5 ), (int)( y - 0.5 ), f );
-			if( (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * zRObj.getBreite() ) < maxPixel && 
-				buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
-				zRObj.alphaPixel( (int)( x + 0.5 ), (int)( y + 1.5 ), f );
-			x += xf, y += yf;
-		}
-	}
+    __super::tick( info, tv );
+    intensität -= tv * 2;
+    return 1;
 }
 
-void Laser::renderMinimap( Bild &zRObj, Karte *zMap )
+void Laser::render( Mat3< float > &kamMat, Bild &zRObj )
 {
-	int x = (int)( ( pos.x / zMap->getSize().x ) * 250 + 0.5 );
-	int y = (int)( ( pos.y / zMap->getSize().y ) * 250 + 0.5 );
-	zRObj.setPixelDP( x + zRObj.getDrawOff().x, y + zRObj.getDrawOff().y, tf );
+    int fa = (int)( ( intensität / startIntensität ) * 255 );
+    int f = ( ( fa << 24 ) & 0xFF000000 ) | ( tf & 0xFFFFFF );
+    Punkt a = (Punkt)( kamMat * getPosition() );
+    Punkt b = (Punkt)( kamMat * ( getPosition() - ( getSpeed() / getSpeed().getLength() * 10 ) ) );
+    a += zRObj.getDrawOff();
+    b += zRObj.getDrawOff();
+    char outCode1 = getOutCode( a, zRObj );
+    char outCode2 = getOutCode( b, zRObj );
+    bool ok = 0;
+    while( 1 )
+    {
+        int xMax = zRObj.getDrawGr().x - 1;
+        int yMax = zRObj.getDrawGr().y - 1;
+        if( !( outCode1 | outCode2 ) )
+        {
+            ok = 1;
+            break;
+        }
+        else if( outCode1 & outCode2 )
+            break;
+        else
+        {
+            int x = 0, y = 0;
+            char outCodeOut = outCode1 ? outCode1 : outCode2;
+            if( outCodeOut & 8 )
+            {
+                x = (int)( a.x + ( b.x - a.x ) * ( yMax - a.y ) / ( b.y - a.y ) + 0.5 );
+                y = yMax;
+            }
+            else if( outCodeOut & 4 )
+            {
+                x = (int)( a.x + ( b.x - a.x ) * ( zRObj.getDrawPos().y - a.y ) / ( b.y - a.y ) + 0.5 );
+                y = zRObj.getDrawPos().y;
+            }
+            else if( outCodeOut & 2 )
+            {
+                y = (int)( a.y + ( b.y - a.y ) * ( xMax - a.x ) / ( b.x - a.x ) + 0.5 );
+                x = xMax;
+            }
+            else if( outCodeOut & 1 )
+            {
+                y = (int)( a.y + ( b.y - a.y ) * ( zRObj.getDrawPos().x - a.x ) / ( b.x - a.x ) + 0.5 );
+                x = zRObj.getDrawPos().x;
+            }
+            if( outCodeOut == outCode1 )
+            {
+                a.x = x;
+                a.y = y;
+                outCode1 = getOutCode( a, zRObj );
+            }
+            else
+            {
+                b.x = x;
+                b.y = y;
+                outCode2 = getOutCode( b, zRObj );
+            }
+        }
+    }
+    if( ok )
+    {
+        int xlän = b.x - a.x, axlän = abs( xlän );
+        int ylän = b.y - a.y, aylän = abs( ylän );
+        double xf = (double)xlän / ( aylän ? aylän : 1 );
+        double yf = (double)ylän / ( axlän ? axlän : 1 );
+        if( axlän > aylän )
+            xf = xf < 0 ? -1 : 1;
+        else
+            yf = yf < 0 ? -1 : 1;
+        double x = (double)a.x, y = (double)a.y;
+        int maxP = (int)( sqrt( xlän * xlän + ylän * ylän ) + 0.5 );
+        int count = 0;
+        int *buffer = zRObj.getBuffer();
+        int maxPixel = zRObj.getBreite() * zRObj.getHeight();
+        while( !( (int)( x + 0.5 ) == b.x && (int)( y + 0.5 ) == b.y ) && count < maxP )
+        {
+            ++count;
+            if( (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel )
+                buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] = 0xFFFFFFFF;
+            if( (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel &&
+                buffer[ (int)( (int)( x - 0.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+                zRObj.alphaPixel( (int)( x - 0.5 ), (int)( y + 0.5 ), f );
+            if( (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) < maxPixel &&
+                buffer[ (int)( (int)( x + 1.5 ) + (int)( y + 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+                zRObj.alphaPixel( (int)( x + 1.5 ), (int)( y + 0.5 ), f );
+            if( (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * zRObj.getBreite() ) < maxPixel &&
+                buffer[ (int)( (int)( x + 0.5 ) + (int)( y - 0.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+                zRObj.alphaPixel( (int)( x + 0.5 ), (int)( y - 0.5 ), f );
+            if( (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * zRObj.getBreite() ) < maxPixel &&
+                buffer[ (int)( (int)( x + 0.5 ) + (int)( y + 1.5 ) * zRObj.getBreite() ) ] != 0xFFFFFFFF )
+                zRObj.alphaPixel( (int)( x + 0.5 ), (int)( y + 1.5 ), f );
+            x += xf, y += yf;
+        }
+    }
 }
 
 // constant
 int Laser::getId() const
 {
-	return id;
+    return id;
 }
 
 int Laser::getSpieler() const
 {
-	return sNum;
+    return sNum;
 }
 
 double Laser::getIntensität( Vec2< double > targetSpeed ) const
 {
-	return intensität * ((speed - targetSpeed).getLength() / 200);
-}
-
-Vec2< double > Laser::getPos() const
-{
-    return pos;
-}
-
-Vec2< double > Laser::getSpeed() const
-{
-    return speed;
+    return intensität * ( ( speed - targetSpeed ).getLength() / 200 );
 }
 
 // Reference Counting
 Laser *Laser::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 Laser *Laser::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Asteroids/Spiel/Schuss/Laser.h

@@ -3,18 +3,16 @@
 
 #include <Vec2.h>
 #include <Bild.h>
+#include <Welt2D.h>
 
 using namespace Framework;
 
 class Karte;
 
-class Laser
+class Laser : public Object2D
 {
 private:
-	int ref;
 	int id;
-	Vec2< double > pos;
-	Vec2< double > speed;
 	double intensität;
 	double startIntensität;
 	int tf;
@@ -26,15 +24,13 @@ public:
 	// Konstruktor
 	Laser( int id, Vec2< double > pos, Vec2< double > speed, int sNum, double intensität, int tf );
 	// nicht constant
-	void tick( int tick, Karte *zMap );
-	void render( Bild &zRObj );
-	void renderMinimap( Bild &zRObj, Karte *zMap );
+    Rect2< float > getBoundingBox() const;
+	bool tick( const WeltInfo &info, double tv ) override;
+	void render( Mat3< float > &kamMat, Bild &zRObj ) override;
 	// constant
 	int getId() const;
 	int getSpieler() const;
 	double getIntensität( Vec2< double > targetSpeed ) const;
-    Vec2< double > getPos() const;
-    Vec2< double > getSpeed() const;
 	// Reference Counting
 	Laser *getThis();
 	Laser *release();

Asteroids/Spiel/SpielKlasse.cpp

@@ -29,7 +29,14 @@ SpielKlasse::SpielKlasse()
 	objekte = new RCArray< SpielObjekt >();
     deads = new RCArray< DeadPlayer >();
 	screen = 0;
-	kam = 0;
+    welt = new Welt2D();
+    welt->setCircular( 1 );
+    welt->setAirResistance( 0.01f );
+    kam = new Kamera2D();
+    kam->setWelt( welt->getThis(), 1 );
+    minimap = new Kamera2D();
+    minimap->setSize( 200, 200 );
+    minimap->setWelt( welt->getThis(), 0 );
 	spielerAnzahl = 0;
 	karteId = 0;
 	ladenProzent = 0;
@@ -40,11 +47,9 @@ SpielKlasse::SpielKlasse()
 	tasten = new char[ 256 ];
 	for( int i = 0; i < 256; i++ )
 		tasten[ i ] = 0;
-	mx = -1;
-	my = -1;
 	bestenliste = 0;
 	schüsse = new RCArray< Laser >();
-	ship = 0;
+	shipGUI = 0;
 	spielPause = 1;
 	ref = 1;
 }
@@ -52,14 +57,14 @@ SpielKlasse::SpielKlasse()
 // Destruktor
 SpielKlasse::~SpielKlasse()
 {
-	if( map )
-	{
-		for( int i = 0; i < map->getMaxTeamAnzahl(); i++ )
-		{
-			if( teams->z( i ) )
-				teams->z( i )->reset();
-		}
-	}
+    for( int i = 0; i < map->getMaxTeamAnzahl(); i++ )
+    {
+        if( teams->z( i ) )
+            teams->z( i )->reset();
+    }
+    map->release();
+    minimap->release();
+    welt->release();
     deads->release();
 	stkn->release();
 	if( schrift )
@@ -70,14 +75,12 @@ SpielKlasse::~SpielKlasse()
 		spielKlient->release();
 	if( kam )
 		kam->release();
-	if( map )
-		map->release();
 	if( end )
 		end->release();
 	if( bestenliste )
 		bestenliste->release();
-	if( ship )
-		ship->release();
+	if( shipGUI )
+		shipGUI->release();
 	chat->relese();
 	spieler->release();
 	teams->release();
@@ -120,8 +123,8 @@ void SpielKlasse::setSchrift( Schrift *schrift )
 	chat->setSchrift( schrift );
 	if( !bestenliste )
 		bestenliste = new Bestenliste( schrift->getThis() );
-	if( !ship )
-		ship = new SpielerGUI( schrift );
+	if( !shipGUI )
+		shipGUI = new SpielerGUI( schrift );
 }
 
 void SpielKlasse::setBildschirm( Bildschirm *screen )
@@ -187,7 +190,6 @@ void SpielKlasse::ladeDaten()
     flammenBurn->ladeAnimation( flammenLTDB.getThis() );
     flammenBurn->setFPS( 60 );
     flammenBurn->setWiederhohlend( 1 );
-	kam = new Kamera();
 	map = new Karte();
     Text *mapPf = new Text( "data/tmp/Karten/" );
     mapPf->append( karteId );
@@ -207,14 +209,25 @@ void SpielKlasse::ladeDaten()
 	mapD->close();
 	mapD->release();
 	mapPf->release();
-	for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
-		spieler->set( map->createSpieler( i, schrift, infoKlient, flammenStart, flammenBurn ), i );
+    for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
+    {
+        Spieler *s = map->createSpieler( i, schrift, infoKlient, flammenStart, flammenBurn );
+        welt->addObject( s->getThis() );
+        spieler->set( s, i );
+    }
     flammenStart->release();
     flammenBurn->release();
 	spielKlient->setLadenProzent( 95 );
-	for( int i = 0; i < map->getZeichnungAnzahl(); i++ )
-		objekte->set( map->createObjekt( i, schrift ), i );
+    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() );
+    welt->setSize( map->getSize().x, map->getSize().y );
+    welt->setSize( 1 );
+    minimap->lookAtWorldArea( map->getSize().x, map->getSize().y );
 	spielKlient->setLadenProzent( 100 );
 }
 
@@ -226,31 +239,8 @@ void SpielKlasse::doMausEreignis( MausEreignis &me )
 		return;
 	}
 	if( !istAmLeben() )
-	{
-		if( ( me.id == ME_RLinks || me.id == ME_RRechts ) && mx >= 0 )
-		{
-			mx = -1;
-			my = -1;
-		}
-		if( me.id == ME_Bewegung && mx >= 0 )
-		{
-			kam->addPosition( mx - me.mx, my - me.my, map );
-			mx = me.mx;
-			my = me.my;
-		}
-		if( ( me.id == ME_PLinks || me.id == ME_PRechts ) && mx < 0 )
-		{
-			mx = me.mx;
-			my = me.my;
-		}
 		me.verarbeitet = 1;
-	}
-	else
-	{
-		mx = -1;
-		my = -1;
-	}
-	int skill = ship->doMausEreignis( me );
+	int skill = shipGUI->doMausEreignis( me );
 	if( skill >= 0 )
 	{
 		char *bytes = new char[ 2 ];
@@ -379,19 +369,19 @@ void SpielKlasse::doTastaturEreignis( TastaturEreignis &te )
 				switch( te.taste )
 				{
 				case T_Links:
-					kam->addPosition( -2, 0, map );
+					kam->setPosition( kam->getPosition() + Vertex( -2, 0 ) );
 					te.verarbeitet = 1;
 					break;
 				case T_Oben:
-					kam->addPosition( 0, -2, map );
+                    kam->setPosition( kam->getPosition() + Vertex( 0, -2 ) );
 					te.verarbeitet = 1;
 					break;
 				case T_Rechts:
-					kam->addPosition( 2, 0, map );
+                    kam->setPosition( kam->getPosition() + Vertex( 2, 0 ) );
 					te.verarbeitet = 1;
 					break;
 				case T_Unten:
-					kam->addPosition( 0, 2, map );
+                    kam->setPosition( kam->getPosition() + Vertex( 0, 2 ) );
 					te.verarbeitet = 1;
 					break;
 				}
@@ -424,7 +414,7 @@ void SpielKlasse::stknVerarbeitung()
 			for( int i = 0; i < spielerAnzahl; i++ )
 			{
 				if( spieler->z( i )->getSpielerNummer() == sNum )
-					spieler->z( i )->setTastataturStatus( T_GAS, 1, zeit, map );
+					spieler->z( i )->setTastataturStatus( T_GAS, 1, zeit, welt->getWorldInfo() );
 			}
 			break;
 		case 1: // spieler lässt gas los
@@ -434,7 +424,7 @@ void SpielKlasse::stknVerarbeitung()
 			for( int i = 0; i < spielerAnzahl; i++ )
 			{
 				if( spieler->z( i )->getSpielerNummer() == sNum )
-					spieler->z( i )->setTastataturStatus( T_GAS, 0, zeit, map );
+					spieler->z( i )->setTastataturStatus( T_GAS, 0, zeit, welt->getWorldInfo() );
 			}
 			break;
 		case 2: // spieler drückt rotl
@@ -444,7 +434,7 @@ void SpielKlasse::stknVerarbeitung()
 			for( int i = 0; i < spielerAnzahl; i++ )
 			{
 				if( spieler->z( i )->getSpielerNummer() == sNum )
-					spieler->z( i )->setTastataturStatus( T_ROT_L, 1, zeit, map );
+					spieler->z( i )->setTastataturStatus( T_ROT_L, 1, zeit, welt->getWorldInfo() );
 			}
 			break;
 		case 3: // spieler lässt rotl los
@@ -454,7 +444,7 @@ void SpielKlasse::stknVerarbeitung()
 			for( int i = 0; i < spielerAnzahl; i++ )
 			{
 				if( spieler->z( i )->getSpielerNummer() == sNum )
-					spieler->z( i )->setTastataturStatus( T_ROT_L, 0, zeit, map );
+					spieler->z( i )->setTastataturStatus( T_ROT_L, 0, zeit, welt->getWorldInfo() );
 			}
 			break;
 		case 4: // spieler drückt rotr
@@ -464,7 +454,7 @@ void SpielKlasse::stknVerarbeitung()
 			for( int i = 0; i < spielerAnzahl; i++ )
 			{
 				if( spieler->z( i )->getSpielerNummer() == sNum )
-					spieler->z( i )->setTastataturStatus( T_ROT_R, 1, zeit, map );
+					spieler->z( i )->setTastataturStatus( T_ROT_R, 1, zeit, welt->getWorldInfo() );
 			}
 			break;
 		case 5: // spieler lässt rotr los
@@ -474,7 +464,7 @@ void SpielKlasse::stknVerarbeitung()
 			for( int i = 0; i < spielerAnzahl; i++ )
 			{
 				if( spieler->z( i )->getSpielerNummer() == sNum )
-					spieler->z( i )->setTastataturStatus( T_ROT_R, 0, zeit, map );
+					spieler->z( i )->setTastataturStatus( T_ROT_R, 0, zeit, welt->getWorldInfo() );
 			}
 			break;
 		case 6: // Init Spieler
@@ -496,7 +486,7 @@ void SpielKlasse::stknVerarbeitung()
 					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( tmp->getThis() );
+					tmp->zTeam()->spieler->add( (Spieler*)tmp->getThis() );
 					spieler->add( tmp );
 					bestenliste->addSpieler( tmp );
 					bestenliste->updateSpieler( tmp );
@@ -533,7 +523,7 @@ void SpielKlasse::stknVerarbeitung()
 			{
 				if( spieler->z( i )->getSpielerNummer() == spielerNummer )
 				{
-					ship->update( spieler->z( i ) );
+					shipGUI->update( spieler->z( i ) );
 					break;
 				}
 			}
@@ -589,7 +579,7 @@ void SpielKlasse::stknVerarbeitung()
 					{
 						Team *tmp = spieler->z( i )->zTeam();
 						for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
-							j->var->resetToSaveTime( zeit, map );
+							j->var->resetToSaveTime( zeit, welt->getWorldInfo() );
 						spieler->z( i )->setSkill( art );
 						tmp->akkuLeistung = tmp->getAkkuLeistungBonus();
 						tmp->beschleunigung = tmp->getBeschleunigungBonus();
@@ -604,7 +594,7 @@ void SpielKlasse::stknVerarbeitung()
                         tmp->energieSchild = tmp->getEnergieSchildBonus();
                         tmp->energieSchildEffizienz = tmp->getEnergieSchildEffizienzBonus();
 						for( auto *j = &tmp->spieler->getArray(); j && j->set && j->var; j = j->next )
-							j->var->resetToGameTime( spielZeit, map );
+							j->var->resetToGameTime( spielZeit, welt->getWorldInfo() );
 						break;
 					}
 				}
@@ -612,7 +602,7 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == spielerNummer )
 					{
-						ship->update( spieler->z( i ) );
+						shipGUI->update( spieler->z( i ) );
 						break;
 					}
 				}
@@ -647,11 +637,11 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
-						spieler->z( i )->resetToSaveTime( zeit, map );
+						spieler->z( i )->resetToSaveTime( zeit, welt->getWorldInfo() );
 						spieler->z( i )->setPosition( Vec2< double >( xPos, yPos ) );
 						spieler->z( i )->hatGeschossen();
 						farbe = spieler->z( i )->zTeam()->farbe;
-						spieler->z( i )->resetToGameTime( spielZeit, map );
+						spieler->z( i )->resetToGameTime( spielZeit, welt->getWorldInfo() );
 						break;
 					}
 				}
@@ -661,14 +651,16 @@ void SpielKlasse::stknVerarbeitung()
 					{
 						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
 						{
-							ship->update( spieler->z( i ) );
+							shipGUI->update( spieler->z( i ) );
 							bestenliste->updateSpieler( spieler->z( i ) );
 							break;
 						}
 					}
 				}
 				Laser *l = new Laser( id, Vec2< double >( xPos, yPos ), Vec2< double >( xSpeed, ySpeed ), sNum, intensität, farbe );
-				l->tick( spielZeit - zeit, map );
+                for( int i = 0; i < spielZeit - zeit; i++ )
+                    l->tick( welt->getWorldInfo(), TICK );
+                welt->addObject( l->getThis() );
 				schüsse->add( l );
 			}
 			break;
@@ -687,7 +679,16 @@ void SpielKlasse::stknVerarbeitung()
 					if( schüsse->z( i )->getId() == schuss )
 					{
 						Laser *tmp = schüsse->z( i );
-						tmp->tick( zeit - spielZeit, map );
+                        if( zeit > spielZeit )
+                        {
+                            for( int i = 0; i < zeit - spielZeit; i++ )
+                                tmp->tick( welt->getWorldInfo(), TICK );
+                        }
+                        else
+                        {
+                            for( int i = 0; i < spielZeit - zeit; i++ )
+                                tmp->tick( welt->getWorldInfo(), -TICK );
+                        }
 						if( sNum >= 0 )
 						{
                             double intens = 0;
@@ -695,11 +696,11 @@ void SpielKlasse::stknVerarbeitung()
 							{
 								if( spieler->z( j )->getSpielerNummer() == sNum )
 								{
-                                    spieler->z( j )->resetToSaveTime( zeit, map );
+                                    spieler->z( j )->resetToSaveTime( zeit, welt->getWorldInfo() );
                                     intens = tmp->getIntensität( spieler->z( j )->getSpeed() );
 									spieler->z( j )->nimmSchaden( intens );
                                     spieler->z( j )->calcDeadPlayerObject( schüsse->z( i ) );
-                                    spieler->z( j )->resetToGameTime( spielZeit, map );
+                                    spieler->z( j )->resetToGameTime( spielZeit, welt->getWorldInfo() );
 									bestenliste->updateSpieler( spieler->z( j ) );
                                     break;
 								}
@@ -708,14 +709,15 @@ void SpielKlasse::stknVerarbeitung()
                             {
                                 if( spieler->z( j )->getSpielerNummer() == tmp->getSpieler() )
                                 {
-                                    spieler->z( j )->resetToSaveTime( zeit, map );
+                                    spieler->z( j )->resetToSaveTime( zeit, welt->getWorldInfo() );
                                     spieler->z( j )->machSchaden( intens );
-                                    spieler->z( j )->resetToGameTime( spielZeit, map );
+                                    spieler->z( j )->resetToGameTime( spielZeit, welt->getWorldInfo() );
                                     bestenliste->updateSpieler( spieler->z( j ) );
                                     break;
                                 }
                             }
 						}
+                        welt->removeObject( tmp );
 						schüsse->remove( i );
 						break;
 					}
@@ -726,7 +728,7 @@ void SpielKlasse::stknVerarbeitung()
 					{
 						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
 						{
-							ship->update( spieler->z( i ) );
+							shipGUI->update( spieler->z( i ) );
 							break;
 						}
 					}
@@ -743,9 +745,9 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
-                        spieler->z( i )->resetToSaveTime( zeit, map );
+                        spieler->z( i )->resetToSaveTime( zeit, welt->getWorldInfo() );
 						spieler->z( i )->wiederbelebung();
-                        spieler->z( i )->resetToGameTime( spielZeit, map );
+                        spieler->z( i )->resetToGameTime( spielZeit, welt->getWorldInfo() );
 						break;
 					}
 				}
@@ -755,7 +757,7 @@ void SpielKlasse::stknVerarbeitung()
 					{
 						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
 						{
-							ship->update( spieler->z( i ) );
+							shipGUI->update( spieler->z( i ) );
 							break;
 						}
 					}
@@ -775,18 +777,21 @@ void SpielKlasse::stknVerarbeitung()
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
-                        spieler->z( i )->resetToSaveTime( zeit, map );
+                        spieler->z( i )->resetToSaveTime( zeit, welt->getWorldInfo() );
 						DeadPlayer *dp = spieler->z( i )->sterben();
                         if( dp )
+                        {
+                            welt->addObject( dp->getThis() );
                             deads->add( dp );
-                        spieler->z( i )->resetToGameTime( spielZeit, map );
+                        }
+                        spieler->z( i )->resetToGameTime( spielZeit, welt->getWorldInfo() );
 						bestenliste->updateSpieler( spieler->z( i ) );
 					}
 					if( spieler->z( i )->getSpielerNummer() == killer )
 					{
-                        spieler->z( i )->resetToSaveTime( zeit, map );
+                        spieler->z( i )->resetToSaveTime( zeit, welt->getWorldInfo() );
 						spieler->z( i )->addKill();
-                        spieler->z( i )->resetToGameTime( spielZeit, map );
+                        spieler->z( i )->resetToGameTime( spielZeit, welt->getWorldInfo() );
 						spieler->z( i )->zTeam()->punkte++;
 						bestenliste->updateTeam( spieler->z( i )->zTeam() );
 						bestenliste->updateSpieler( spieler->z( i ) );
@@ -798,7 +803,7 @@ void SpielKlasse::stknVerarbeitung()
 					{
 						if( spieler->z( i )->getSpielerNummer() == spielerNummer )
 						{
-							ship->update( spieler->z( i ) );
+							shipGUI->update( spieler->z( i ) );
 							break;
 						}
 					}
@@ -851,47 +856,44 @@ bool SpielKlasse::tick( double zeit )
         int deadsCount = deads->getEintragAnzahl();
         for( int i = 0; i < deadsCount; i++ )
         {
-            if( deads->z( i )->tick() )
+            if( deads->z( i )->tick( welt->getWorldInfo(), 0 ) )
             {
+                welt->removeObject( deads->z( i ) );
                 deads->remove( i-- );
                 deadsCount--;
             }
         }
-		int objektAnzahl = objekte->getEintragAnzahl();
-		for( int i = 0; i < objektAnzahl; i++ )
-			objekte->z( i )->tick();
+        kam->tick( TICK );
+        minimap->tick( TICK );
 		for( int i = 0; i < spielerAnzahl; i++ )
 		{
-			if( spieler->z( i )->tick( spielZeit, map ) && spieler->z( i )->getSpielerNummer() == spielerNummer )
-				ship->update( spieler->z( i ) );
+			if( spieler->z( i )->getSpielerNummer() == spielerNummer )
+				shipGUI->update( spieler->z( i ) );
 			if( spielerNummer == spieler->z( i )->getSpielerNummer() )
 			{
-				x = (int)spieler->z( i )->getPos().x;
-				y = (int)spieler->z( i )->getPos().y;
+				x = (int)spieler->z( i )->getPosition().x;
+				y = (int)spieler->z( i )->getPosition().y;
 				setKam = spieler->z( i )->istAmLeben();
 			}
 		}
-		int schussAnzahl = schüsse->getEintragAnzahl();
-		for( int i = 0; i < schussAnzahl; i++ )
-			schüsse->z( i )->tick( 1, map );
 		unlock();
 		if( setKam )
 		{
-			double px = ( ( x - kam->getPos().x ) / 100.0 ) * ( abs( ( x - kam->getPos().x ) / 2 ) * TICK );
-			double py = ( ( y - kam->getPos().y ) / 100.0 ) * ( abs( ( y - kam->getPos().y ) / 2 ) * TICK );
-			if( abs( x - kam->getPos().x ) > abs( x - ( kam->getPos().x - map->getSize().x ) ) )
-				px = ( ( x - ( kam->getPos().x - map->getSize().x ) ) / 100.0 ) * ( abs( ( x - kam->getPos().x ) / 2 ) * TICK );
-			else if( abs( x - kam->getPos().x ) > abs( x - ( kam->getPos().x + map->getSize().x ) ) )
-				px = ( ( x - ( kam->getPos().x + map->getSize().x ) ) / 100.0 ) * ( abs( ( x - kam->getPos().x ) / 2 ) * TICK );
-			if( abs( y - kam->getPos().y ) > abs( y - ( kam->getPos().y - map->getSize().y ) ) )
-				py = ( ( y - ( kam->getPos().y - map->getSize().y ) ) / 100.0 ) * ( abs( ( y - kam->getPos().y ) / 2 ) * TICK );
-			else if( abs( y - kam->getPos().y ) > abs( y - ( kam->getPos().y + map->getSize().y ) ) )
-				py = ( ( y - ( kam->getPos().y + map->getSize().y ) ) / 100.0 ) * ( abs( ( y - kam->getPos().y ) / 2 ) * TICK );
-			kam->addPosition( (int)px, (int)py, map );
+			float px = ( ( x - kam->getPosition().x ) / 100.0f ) * ( abs( ( x - kam->getPosition().x ) / 2 ) * (float)TICK );
+            float py = ( ( y - kam->getPosition().y ) / 100.0f ) * ( abs( ( y - kam->getPosition().y ) / 2 ) * (float)TICK );
+			if( abs( x - kam->getPosition().x ) > abs( x - ( kam->getPosition().x - map->getSize().x ) ) )
+				px = ( ( x - ( kam->getPosition().x - map->getSize().x ) ) / 100.0f ) * ( abs( ( x - kam->getPosition().x ) / 2 ) * (float)TICK );
+			else if( abs( x - kam->getPosition().x ) > abs( x - ( kam->getPosition().x + map->getSize().x ) ) )
+				px = ( ( x - ( kam->getPosition().x + map->getSize().x ) ) / 100.0f ) * ( abs( ( x - kam->getPosition().x ) / 2 ) * (float)TICK );
+			if( abs( y - kam->getPosition().y ) > abs( y - ( kam->getPosition().y - map->getSize().y ) ) )
+				py = ( ( y - ( kam->getPosition().y - map->getSize().y ) ) / 100.0f ) * ( abs( ( y - kam->getPosition().y ) / 2 ) * (float)TICK );
+			else if( abs( y - kam->getPosition().y ) > abs( y - ( kam->getPosition().y + map->getSize().y ) ) )
+				py = ( ( y - ( kam->getPosition().y + map->getSize().y ) ) / 100.0f ) * ( abs( ( y - kam->getPosition().y ) / 2 ) * (float)TICK );
+			kam->lookAtWorldPos( kam->getWorldPosition() + Vertex( px, py ) );
 		}
 		chat->tick( !zeit ? 0.05 : zeit );
-		if( ship )
-		    ship->tick( !zeit ? 0.05 : zeit );
+		if( shipGUI )
+		    shipGUI->tick( !zeit ? 0.05 : zeit );
 	}
 	return 1;
 }
@@ -901,35 +903,23 @@ void SpielKlasse::render( Bild &zRObj )
 	if( !rendern )
 		return;
 	lock();
-	for( int i = 0; kam->beginnRender( zRObj, map, i ); i++ )
-	{
-        int deadsCount = deads->getEintragAnzahl();
-        for( int i = 0; i < deadsCount; i++ )
-            deads->z( i )->render( zRObj );
-		int objektAnzahl = objekte->getEintragAnzahl();
-		for( int i = 0; i < objektAnzahl; i++ )
-			objekte->z( i )->render( zRObj );
-		for( int j = 0; j < spielerAnzahl; j++ )
-			spieler->z( j )->render( zRObj );
-		int schussAnzahl = schüsse->getEintragAnzahl();
-		for( int j = 0; j < schussAnzahl; j++ )
-			schüsse->z( j )->render( zRObj );
-		for( int j = 0; j < spielerAnzahl; j++ )
-			spieler->z( j )->renderLeben( zRObj );
-		kam->endRender( zRObj );
-	}
-	kam->beginnMinimap( zRObj, map );
-	for( int j = 0; j < spielerAnzahl; j++ )
-		spieler->z( j )->renderMinimap( zRObj, map, spielerNummer );
-	int schussAnzahl = schüsse->getEintragAnzahl();
-	for( int j = 0; j < schussAnzahl; j++ )
-		schüsse->z( j )->renderMinimap( zRObj, map );
-	kam->endMinimap( zRObj );
+    kam->lookAtWorldArea( zRObj.getBreite(), zRObj.getHeight() );
+    kam->setSize( zRObj.getSize() );
+    kam->render( zRObj );
+    for( int j = 0; j < spielerAnzahl; j++ )
+        spieler->z( j )->renderLeben( kam->getMatrix(), zRObj );
+    int objektAnzahl = objekte->getEintragAnzahl();
+    for( int i = 0; i < objektAnzahl; i++ )
+        objekte->z( i )->renderLeben( kam->getMatrix(), zRObj );
+    zRObj.setAlpha( 50 );
+    minimap->setPosition( zRObj.getSize() - Punkt( 210, 210 ) );
+    minimap->render( zRObj );
+    zRObj.releaseAlpha();
 	chat->render( zRObj );
 	if( bestenliste )
 		bestenliste->render( zRObj );
-	if( ship )
-		ship->render( zRObj );
+	if( shipGUI )
+		shipGUI->render( zRObj );
 	if( end )
 		end->render( zRObj );
 	unlock();

Asteroids/Spiel/SpielKlasse.h

@@ -11,6 +11,7 @@
 #include "Schuss\Laser.h"
 #include <Bildschirm.h>
 #include "Objekt/SpielObjekt.h"
+#include <Kamera2D.h>
 
 class SpielKlasse : public SpielV
 {
@@ -24,15 +25,17 @@ private:
 	RCArray< Spieler > *spieler;
 	RCArray< Team > *teams;
 	RCArray< SpielObjekt > *objekte;
+    RCArray< Laser > *schüsse;
 	Bildschirm *screen;
 	Karte *map;
-	Kamera *kam;
+	Kamera2D *kam;
+    Kamera2D *minimap;
+    Welt2D *welt;
 	SpielChat *chat;                                                                                                   
 	Ende *end;
-	RCArray< Laser > *schüsse;
 	Model2DData *shipData;
 	Bild *shipTextur;
-	SpielerGUI *ship;
+	SpielerGUI *shipGUI;
     Datei csv;
     RCArray< DeadPlayer > *deads;
 	bool rendern;
@@ -43,8 +46,6 @@ private:
 	int ladenProzent;
 	int spielerNummer;
 	char *tasten;
-	int mx;
-	int my;
 	bool spielPause;
 	int ref;
 	bool istAmLeben() const;

Asteroids/Spiel/Spieler/DeadPlayer.cpp

@@ -4,17 +4,16 @@
 #include <Bild.h>
 
 DeadPlayer::DeadPlayer( Model2DData *mda, Model2DData *mdb, Punkt posa, Punkt posb, Vertex speedA, Vertex speedB, float curRotA, float curRotB, float rotA, float rotB, Textur2D *zTextur )
+    : Object2D()
 {
-    m2a = new Model2D();
+    m2a = new Model2DObject();
     m2a->setModel( mda );
     m2a->setPosition( posa );
-    m2a->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Alpha );
     m2a->setTextur( zTextur->getThis() );
     m2a->setDrehung( curRotA );
-    m2b = new Model2D();
+    m2b = new Model2DObject();
     m2b->setModel( mdb );
     m2b->setPosition( posb );
-    m2b->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Alpha );
     m2b->setTextur( zTextur->getThis() );
     m2b->setDrehung( curRotB );
     this->speedA = speedA;
@@ -22,7 +21,6 @@ DeadPlayer::DeadPlayer( Model2DData *mda, Model2DData *mdb, Punkt posa, Punkt po
     this->rotA = rotA;
     this->rotB = rotB;
     alpha = 255;
-    ref = 1;
 }
 
 DeadPlayer::~DeadPlayer()
@@ -31,21 +29,19 @@ DeadPlayer::~DeadPlayer()
     m2b->release();
 }
 
-void DeadPlayer::render( Bild &zRObj )
+void DeadPlayer::render( Mat3< float > &kamMat, Bild &zRObj )
 {
     zRObj.setAlpha( (unsigned char)alpha );
-    m2a->render( zRObj );
-    m2b->render( zRObj );
+    m2a->render( kamMat, zRObj );
+    m2b->render( kamMat, zRObj );
     zRObj.releaseAlpha();
 }
 
-bool DeadPlayer::tick()
+bool DeadPlayer::tick( const WeltInfo &info, double zeit )
 {
-    m2a->addDrehung( rotA * (float)TICK );
-    m2b->addDrehung( rotB * (float)TICK );
-    m2a->setPosition( m2a->getPosition() + speedA * (float)TICK );
-    m2b->setPosition( m2b->getPosition() + speedB * (float)TICK );
-    alpha -= TICK * 15;
+    m2a->tick( info, zeit );
+    m2b->tick( info, zeit );
+    alpha -= zeit * 15;
     if( alpha < 0 )
     {
         alpha = 0;
@@ -54,15 +50,7 @@ bool DeadPlayer::tick()
     return 0;
 }
 
-DeadPlayer *DeadPlayer::getThis()
+Rect2< float > DeadPlayer::getBoundingBox() const
 {
-    ref++;
-    return this;
-}
-
-DeadPlayer *DeadPlayer::release()
-{
-    if( !--ref )
-        delete this;
-    return 0;
+    return Rect2< float >();
 }

Asteroids/Spiel/Spieler/DeadPlayer.h

@@ -4,23 +4,21 @@
 
 using namespace Framework;
 
-class DeadPlayer
+class DeadPlayer : public Object2D
 {
 private:
-    Model2D *m2a;
-    Model2D *m2b;
+    Model2DObject *m2a;
+    Model2DObject *m2b;
     Vertex speedA;
     Vertex speedB;
     float rotA;
     float rotB;
     double alpha;
-    int ref;
 
 public:
     DeadPlayer( Model2DData *mda, Model2DData *mdb, Punkt posa, Punkt posb, Vertex speedA, Vertex speedB, float curRotA, float curRotB, float rotA, float rotB, Textur2D *zTextur );
     ~DeadPlayer();
-    void render( Bild &zRObj );
-    bool tick();
-    DeadPlayer *getThis();
-    DeadPlayer *release();
+    void render( Mat3< float > &kamMat, Bild &zRObj ) override;
+    bool tick( const WeltInfo &info, double zeit ) override;
+    Rect2< float > getBoundingBox() const override;
 };

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -8,74 +8,65 @@
 // Inhalt der Spieler Klasse aus Spieler.h
 // Konstruktor
 Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift, SpielerStr *zStr )
+    : Model2DObject()
 {
-    textur = 0;
     deadPlayer = 0;
     accountId = 0;
     sNum = zStr->id;
-    current.farbe = 0;
-    ship = new Model2D();
-    ship->setStyle( Model2D::Style::Sichtbar | Model2D::Style::Textur | Model2D::Style::Alpha );
+    farbe = 0;
     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.energieAbk = 0;
-    current.repAbk = 0;
-    current.reinkAbk = 0;
-    current.maxReinkAbk = 5;
+    amLeben = 1;
+    schussAbk = 0;
+    energieAbk = 0;
+    repAbk = 0;
+    reinkAbk = 0;
+    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;
+    startPos = zStr->pos;
+    setPosition( zStr->pos );
+    setDrehung( (float)zStr->rot );
+    beschleunigung = zStr->beschleunigung;
     beschleunigungStart = 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;
+    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;
-    current.maxEnergie = zStr->maxEnergie;
-    current.maxStabilität = zStr->maxStabilität;
-    current.laserTempo = zStr->laserTempo;
-    current.netzwerk = zStr->netzwerk;
-    current.wendigkeit = zStr->wendigkeit;
-    wendigkeitStart = current.wendigkeit;
-    current.antriebEffizienz = zStr->antriebEffizienz;
-    current.energieSchild = zStr->energieSchild;
-    current.energieSchildEffizienz = zStr->energieSchildEffizienz;
+    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;
     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;
+    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, "" );
-    current.spielZeit = 0;
-    current.rSpeed = 0;
-    ship->setPosition( current.pos );
-    ship->setDrehung( (float)current.rotation );
-    last = current;
+    spielZeit = 0;
+    save();
 }
 
 // Destruktor
 Spieler::~Spieler()
 {
-    if( textur )
-        textur->release();
-    ship->release();
     info->release();
     if( team )
         team->release();
@@ -88,12 +79,96 @@ Spieler::~Spieler()
 
 double Spieler::calculateLaserCost()
 {
-    double kosten = ( ( current.laserIntensität + team->laserIntensität ) / 2 + ( current.laserTempo + team->laserTempo ) / 13 ) * ( 1 / ( ( current.laserEffizienz + team->laserEffizienz ) / 25 ) );
+    double kosten = ( ( laserIntensität + team->laserIntensität ) / 2 + ( laserTempo + team->laserTempo ) / 13 ) * ( 1 / ( ( laserEffizienz + team->laserEffizienz ) / 25 ) );
     if( kosten < 1 )
         kosten = 1;
     return kosten;
 }
 
+void Spieler::save()
+{
+    last.rSpeed = getDrehungSpeed();
+    last.pos = getPosition();
+    last.speed = getSpeed();
+    last.rotation = getDrehung();
+    last.farbe = farbe;
+    last.amLeben = amLeben;
+    last.schussAbk = schussAbk;
+    last.energieAbk = energieAbk;
+    last.repAbk = repAbk;
+    last.reinkAbk = reinkAbk;
+    last.maxReinkAbk = maxReinkAbk;
+    last.spielZeit = spielZeit;
+    last.startPos = startPos;
+    last.beschleunigung = beschleunigung;
+    last.energie = energie;
+    last.stabilität = stabilität;
+    last.reparatur = reparatur;
+    last.laserIntensität = laserIntensität;
+    last.laserEffizienz = laserEffizienz;
+    last.akkuLeistung = akkuLeistung;
+    last.maxEnergie = maxEnergie;
+    last.maxStabilität = maxStabilität;
+    last.laserTempo = laserTempo;
+    last.netzwerk = netzwerk;
+    last.wendigkeit = wendigkeit;
+    last.antriebEffizienz = antriebEffizienz;
+    last.energieSchild = energieSchild;
+    last.energieSchildEffizienz = energieSchildEffizienz;
+    last.zeitAmLeben = zeitAmLeben;
+    last.zeitTod = zeitTod;
+    last.schadenBekommen = schadenBekommen;
+    last.schadenGemacht = schadenGemacht;
+    last.treibstoffVerbraucht = treibstoffVerbraucht;
+    last.schüsse = schüsse;
+    last.treffer = treffer;
+    last.punkte = punkte;
+    last.kills = kills;
+    last.tode = tode;
+}
+
+void Spieler::load()
+{
+    setDrehungSpeed( last.rSpeed );
+    setPosition( last.pos );
+    setSpeed( last.speed );
+    setDrehung( last.rotation );
+    farbe = last.farbe;
+    amLeben = last.amLeben;
+    schussAbk = last.schussAbk;
+    energieAbk = last.energieAbk;
+    repAbk = last.repAbk;
+    reinkAbk = last.reinkAbk;
+    maxReinkAbk = last.maxReinkAbk;
+    spielZeit = last.spielZeit;
+    startPos = last.startPos;
+    beschleunigung = last.beschleunigung;
+    energie = last.energie;
+    stabilität = last.stabilität;
+    reparatur = last.reparatur;
+    laserIntensität = last.laserIntensität;
+    laserEffizienz = last.laserEffizienz;
+    akkuLeistung = last.akkuLeistung;
+    maxEnergie = last.maxEnergie;
+    maxStabilität = last.maxStabilität;
+    laserTempo = last.laserTempo;
+    netzwerk = last.netzwerk;
+    wendigkeit = last.wendigkeit;
+    antriebEffizienz = last.antriebEffizienz;
+    energieSchild = last.energieSchild;
+    energieSchildEffizienz = last.energieSchildEffizienz;
+    zeitAmLeben = last.zeitAmLeben;
+    zeitTod = last.zeitTod;
+    schadenBekommen = last.schadenBekommen;
+    schadenGemacht = last.schadenGemacht;
+    treibstoffVerbraucht = last.treibstoffVerbraucht;
+    schüsse = last.schüsse;
+    treffer = last.treffer;
+    punkte = last.punkte;
+    kills = last.kills;
+    tode = last.tode;
+}
+
 // nicht constant
 void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn )
 {
@@ -151,7 +226,7 @@ void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animati
     kL.normalize();
     kR.normalize();
     kM.normalize();
-    ship->setModel( data );
+    setModel( data );
     flammenM = new Textur2D();
     flammenM->addAnimationZ( zFStart->getThis() );
     flammenM->addAnimationZ( zFBurn->getThis() );
@@ -161,9 +236,9 @@ void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animati
     flammenR = new Textur2D();
     flammenR->addAnimationZ( zFStart->getThis() );
     flammenR->addAnimationZ( zFBurn->getThis() );
-    ship->setTextur( flammenL->getThis(), "engine_l" );
-    ship->setTextur( flammenR->getThis(), "engine_r" );
-    ship->setTextur( flammenM->getThis(), "engine_m" );
+    setTextur( flammenL->getThis(), "engine_l" );
+    setTextur( flammenR->getThis(), "engine_r" );
+    setTextur( flammenM->getThis(), "engine_m" );
 }
 
 void Spieler::setAccountId( int accId )
@@ -185,7 +260,7 @@ void Spieler::setTeam( Team *team )
 
 void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
 {
-    current.farbe = fc;
+    farbe = fc;
     nText->setSchriftFarbe( fc );
     Bild *shb = new Bild();
     shb->neuBild( zTextur->getBreite(), zTextur->getHeight(), 0 );
@@ -199,36 +274,23 @@ void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
             shb->alphaPixelDP( i, buffer[ i ] );
         }
     }
-    if( textur )
-        textur->release();
-    textur = new Textur2D();
+    Textur2D *textur = new Textur2D();
     textur->setTexturZ( shb );
-    ship->setTextur( textur->getThis(), "ship" );
-}
-
-void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
-{
-    current.speed = Vec2< double >( xSpeed, ySpeed );
-}
-
-void Spieler::setPosition( Vec2< double > p )
-{
-    current.pos = p;
-    ship->setPosition( current.pos );
+    setTextur( textur, "ship" );
 }
 
-void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap )
+void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, const WeltInfo &info )
 {
-    if( !current.amLeben )
+    if( !amLeben )
     {
         tastatur[ ts ] = aktiv;
         return;
     }
-    int z = sZ - current.spielZeit;
-    int time = current.spielZeit;
-    resetToSaveTime( sZ, zMap );
+    int z = sZ - spielZeit;
+    int time = spielZeit;
+    resetToSaveTime( sZ, info );
     tastatur[ ts ] = aktiv;
-    resetToGameTime( time, zMap );
+    resetToGameTime( time, info );
     if( flammenM && flammenR && flammenL )
     {
         switch( ts )
@@ -255,177 +317,116 @@ void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte
     }
 }
 
-bool Spieler::tick( int time, Karte *zMap )
+bool Spieler::tick( const WeltInfo &info, double tv )
 {
-    if( time <= current.spielZeit )
-        return 0;
     bool ret = 0;
-    while( current.spielZeit != time )
+    if( !team )
+        return 0;
+    if( !spielZeit )
+        save();
+    tv = TICK;
+    reinkAbk -= tv;
+    if( reinkAbk < 0 )
+        reinkAbk = 0;
+    flammenM->tick( tv );
+    flammenL->tick( tv );
+    flammenR->tick( tv );
+    if( amLeben )
     {
-        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 )
+        schussAbk -= tv;
+        energieAbk -= tv;
+        if( schussAbk < 0 )
+            schussAbk = 0;
+        if( energieAbk < 0 )
+            energieAbk = 0;
+        repAbk -= tv;
+        if( repAbk < 0 )
+            repAbk = 0;
+        spielZeit++;
+        if( tastatur[ T_GAS ] )
         {
-            current.schussAbk -= tv;
-            current.energieAbk -= tv;
-            if( current.schussAbk < 0 )
-                current.schussAbk = 0;
-            if( current.energieAbk < 0 )
-                current.energieAbk = 0;
-            current.repAbk -= tv;
-            if( current.repAbk < 0 )
-                current.repAbk = 0;
-            current.spielZeit++;
-            if( tastatur[ T_GAS ] )
-            {
-                Vertex hp;
-                Vertex mv;
-                float r;
-                double treibstoff = 0.5 * ( ( current.beschleunigung + team->beschleunigung) / 5 ) 
-                     * tv * ( 100 / ( current.antriebEffizienz + team->antriebEffizienz ) );
-                current.treibstoffVerbraucht += treibstoff;
-                double factor = 1;
-                if( treibstoff > current.energie )
-                    factor = current.energie / treibstoff;
-                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 * factor;
-                }
-                current.energie -= treibstoff * factor;
-            }
-            double movementAngle = atan2( current.speed.y, current.speed.x );
-            bool xg0 = current.speed.x > 0;
-            bool yg0 = current.speed.y > 0;
-            if( current.speed.x != 0 )
-                current.speed.x += 5.0f * cos( movementAngle + PI ) * TICK;
-            if( current.speed.y != 0 )
-                current.speed.y += 5.0f * sin( movementAngle + PI ) * TICK;
-            if( !xg0 && current.speed.x > 0 )
-                current.speed.x = 0;
-            if( !yg0 && current.speed.y > 0 )
-                current.speed.y = 0;
-            if( current.rSpeed > 0 )
-            {
-                current.rSpeed -= (float)(TICK * 0.5);
-                if( current.rSpeed < 0 )
-                    current.rSpeed = 0;
-            }
-            if( current.rSpeed < 0 )
-            {
-                current.rSpeed += (float)(TICK * 0.5);
-                if( current.rSpeed > 0 )
-                    current.rSpeed = 0;
-            }
-            if( tastatur[ T_ROT_R ] )
-            {
-                Vertex hp;
-                Vertex mv;
-                float r;
-                double treibstoff = 0.25 * ( ( current.wendigkeit + team->wendigkeit ) / 5 )
-                    * tv * ( 100 / ( current.antriebEffizienz + team->antriebEffizienz ) );
-                current.treibstoffVerbraucht += treibstoff;
-                double factor = 1;
-                if( treibstoff > current.energie )
-                    factor = current.energie / treibstoff;
-                if( ship->zModel()->calcHitPoint( stL, kL * (float)( current.wendigkeit + team->wendigkeit ), "ship", hp, mv, r ) )
-                {
-                    current.rSpeed += r * (float)TICK * (float)factor;
-                    current.speed += ( Vec2<double> )mv.rotation( (float)current.rotation ) * (float)TICK * factor;
-                }
-                current.energie -= treibstoff * factor;
-            }
-            if( tastatur[ T_ROT_L ] )
-            {
-                Vertex hp;
-                Vertex mv;
-                float r;
-                double treibstoff = 0.25 *( ( current.wendigkeit + team->wendigkeit ) / 5 )
-                    * tv * ( 100 / ( current.antriebEffizienz + team->antriebEffizienz ) );
-                current.treibstoffVerbraucht += treibstoff;
-                double factor = 1;
-                if( treibstoff > current.energie )
-                    factor = current.energie / treibstoff;
-                if( ship->zModel()->calcHitPoint( stR, kR * (float)( current.wendigkeit + team->wendigkeit ), "ship", hp, mv, r ) )
-                {
-                    current.rSpeed += r * (float)TICK * (float)factor;
-                    current.speed += ( Vec2<double> )mv.rotation( (float)current.rotation ) * (float)TICK * factor;
-                }
-                current.energie -= treibstoff * factor;
-            }
-            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.energieAbk )
-            {
-                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;
+            double treibstoff = 0.5 * ( ( beschleunigung + team->beschleunigung ) / 5 )
+                * tv * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            float factor = 1;
+            if( treibstoff > energie )
+                factor = (float)( energie / treibstoff );
+            impuls( stM, kM * (float)( beschleunigung + team->beschleunigung ) * factor );
+            energie -= treibstoff * factor;
+        }
+        if( tastatur[ T_ROT_R ] )
+        {
+            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 5 )
+                * tv * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            float factor = 1;
+            if( treibstoff > energie )
+                factor = (float)( energie / treibstoff );
+            impuls( stL, kL * (float)( wendigkeit + team->wendigkeit ) * factor );
+            energie -= treibstoff * factor;
+        }
+        if( tastatur[ T_ROT_L ] )
+        {
+            double treibstoff = 0.25 * ( ( wendigkeit + team->wendigkeit ) / 5 )
+                * tv * ( 100 / ( antriebEffizienz + team->antriebEffizienz ) );
+            treibstoffVerbraucht += treibstoff;
+            float factor = 1;
+            if( treibstoff > energie )
+                factor = (float)( energie / treibstoff );
+            impuls( stR, kR * (float)( wendigkeit + team->wendigkeit ) * factor );
+            energie -= treibstoff * factor;
         }
-        else
+        __super::tick( info, tv );
+        if( !energieAbk )
         {
-            current.zeitTod += tv;
-            current.spielZeit++;
+            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;
 }
 
-void Spieler::render( Bild &zRObj )
+void Spieler::render( Mat3< float > &kamMat, Bild &zRObj )
 {
-    if( !current.amLeben )
+    if( !amLeben )
         return;
-    ship->render( zRObj );
+    __super::render( kamMat, zRObj );
 }
 
-void Spieler::renderLeben( Bild &zRObj )
+void Spieler::renderLeben( Mat3< float > &kamMat, Bild &zRObj )
 {
-    if( !team || !current.amLeben )
+    if( !team || !amLeben )
         return;
-    nText->setPosition( ship->getPosition() - Punkt( 76, (int)( ship->zModel()->maxP.y * ship->getSize() ) + 30 ) );
+    nText->setPosition( (Punkt)( kamMat * getPosition() - Vertex( 76, (int)( zModel()->maxP.y * 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 );
+    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)( current.energie * 100 / ( current.maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
+    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)( ( current.energie - calculateLaserCost() ) * 100 / ( current.maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
+    int e2 = (int)( ( energie - calculateLaserCost() ) * 100 / ( maxEnergie + team->maxEnergie ) * 1.5 + 0.5 );
     if( e2 > 0 )
     {
         zRObj.drawLinieV( nText->getX() + e2, nText->getY() + 26, 3, 0xFFFFFFFF );
@@ -433,58 +434,46 @@ void Spieler::renderLeben( Bild &zRObj )
     }
 }
 
-void Spieler::renderMinimap( Bild &zRObj, Karte *zMap, int thisSpielerNummer )
-{
-    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, current.farbe );
-}
-
 void Spieler::setSkill( int art )
 {
     skillPunkte--;
     switch( art )
     {
     case 0: // Max Stabilität
-        current.maxStabilität += 10;
-        current.stabilität += 10;
+        maxStabilität += 10;
+        stabilität += 10;
         team->maxStabilität = team->getMaxStabilitätBonus();
         break;
     case 1: // Max Energie
-        current.maxEnergie += 10;
+        maxEnergie += 10;
         team->maxEnergie = team->getMaxEnergieBonus();
         break;
     case 2: // Reparatur
-        current.reparatur += 0.15;
+        reparatur += 0.15;
         team->reparatur = team->getReperaturBonus();
         break;
     case 3: // Laser Intensität
-        current.laserIntensität += 3;
+        laserIntensität += 3;
         team->laserIntensität = team->getLaserIntensitätBonus();
         break;
     case 4: // Laser Effizienz
-        current.laserEffizienz += 1;
+        laserEffizienz += 1;
         team->laserEffizienz = team->getLaserEffizienzBonus();
         break;
     case 5: // Laser Tempo
-        current.laserTempo += 20;
+        laserTempo += 20;
         team->laserTempo = team->getLaserTempoBonus();
         break;
     case 6: // Beschleunigung
-        current.beschleunigung += 1;
+        beschleunigung += 1.75;
         team->beschleunigung = team->getBeschleunigungBonus();
         break;
     case 7: // Wendigkeit
-        current.wendigkeit += 0.25;
+        wendigkeit += 2.5;
         team->wendigkeit = team->getWendigkeitBonus();
         break;
     case 8: // Netzwerk
-        current.netzwerk += 1;
+        netzwerk += 1;
         team->maxStabilität = team->getMaxStabilitätBonus();
         team->maxEnergie = team->getMaxEnergieBonus();
         team->reparatur = team->getReperaturBonus();
@@ -499,19 +488,19 @@ void Spieler::setSkill( int art )
         team->energieSchildEffizienz = team->getEnergieSchildEffizienzBonus();
         break;
     case 9: // Akkuleistung
-        current.akkuLeistung += 0.12;
+        akkuLeistung += 0.12;
         team->akkuLeistung = team->getAkkuLeistungBonus();
         break;
     case 10: // Antrieb Effizienz
-        current.antriebEffizienz += 10;
+        antriebEffizienz += 10;
         team->antriebEffizienz = team->getAntriebEffizienzBonus();
         break;
     case 11: // Antrieb Effizienz
-        current.energieSchild += 1;
+        energieSchild += 1;
         team->energieSchild = team->getEnergieSchildBonus();
         break;
     case 12: // Antrieb Effizienz
-        current.energieSchildEffizienz += 2;
+        energieSchildEffizienz += 2;
         team->energieSchildEffizienz = team->getEnergieSchildEffizienzBonus();
         break;
     }
@@ -519,38 +508,36 @@ void Spieler::setSkill( int art )
 
 void Spieler::nimmSchaden( double &intensität )
 {
-    double schieldVal = intensität / 100 * current.energieSchild;
-    double schieldEVal = schieldVal - schieldVal / 100 * current.energieSchildEffizienz;
-    if( schieldEVal > current.energie )
+    double schieldVal = intensität / 100 * energieSchild;
+    double schieldEVal = schieldVal - schieldVal / 100 * energieSchildEffizienz;
+    if( schieldEVal > energie )
     {
-        schieldEVal = current.energie;
-        schieldVal = schieldEVal / ( 1 - ( current.energieSchildEffizienz / 100 ) );
+        schieldEVal = energie;
+        schieldVal = schieldEVal / ( 1 - ( energieSchildEffizienz / 100 ) );
     }
     intensität -= schieldVal;
-    current.energie -= schieldEVal;
-    current.stabilität -= intensität;
-    current.schadenBekommen += intensität;
-    current.repAbk = 2;
+    energie -= schieldEVal;
+    stabilität -= intensität;
+    schadenBekommen += intensität;
+    repAbk = 2;
 }
 
 void Spieler::calcDeadPlayerObject( Laser *zSchuss )
 {
     Vertex hp;
-    Vertex speed;
     Polygon2D a;
     Polygon2D b;
     Punkt pa;
     Punkt pb;
-    float rot;
-    if( ship->zModel()->calcHitPoint( ( ( zSchuss->getPos() - zSchuss->getSpeed() ) - ship->getPosition() ).rotation( -ship->getDrehung() ) / ship->getSize(), Vertex( zSchuss->getSpeed() ).rotation( -ship->getDrehung() ), "ship", hp, speed, rot ) )
+    if( calcHitPoint( zSchuss->getPosition() - zSchuss->getSpeed(), zSchuss->getSpeed(), hp ) )
     {
-        ship->zModel()->split( hp, speed.rotation( -ship->getDrehung() ) * 0.1f, "ship", a, b, pa, pb, []()
+        zModel()->split( getObjectPos( hp ), getObjectDir( zSchuss->getSpeed() ) * 0.1f, "ship", a, b, pa, pb, []()
         {
             return rand() / (double)RAND_MAX;
         } );
-        hp = ( hp * ship->getSize() ).rotation( ship->getDrehung() ) + ship->getPosition();
-        pa += ship->getPosition();
-        pb += ship->getPosition();
+        hp = ( hp * getSize() ).rotation( getDrehung() ) + getPosition();
+        pa += getPosition();
+        pb += getPosition();
         Array< Polygon2D > *npaA = new Array< Polygon2D >();
         npaA->add( a );
         Model2DData *npdA = new Model2DData();
@@ -561,87 +548,82 @@ void Spieler::calcDeadPlayerObject( Laser *zSchuss )
         npdB->erstelleModell( npaB );
         if( deadPlayer )
             deadPlayer->release();
-        deadPlayer = new DeadPlayer( npdA, npdB, pa, pb, current.speed * ( rand() / (double)RAND_MAX ), current.speed * ( rand() / (double)RAND_MAX), ship->getDrehung(), ship->getDrehung(), current.rSpeed * (rand() / (float)RAND_MAX), current.rSpeed * (rand() / (float)RAND_MAX), textur );
+        deadPlayer = new DeadPlayer( npdA, npdB, pa, pb, getSpeed() * ( rand() / (double)RAND_MAX ), getSpeed() * ( rand() / (double)RAND_MAX ), getDrehung(), getDrehung(), getDrehungSpeed() * ( rand() / (float)RAND_MAX ), getDrehungSpeed() * ( rand() / (float)RAND_MAX ), zTextur( "ship" ) );
     }
 }
 
 void Spieler::machSchaden( double intensität )
 {
-    current.schadenGemacht += intensität;
-    current.treffer++;
+    schadenGemacht += intensität;
+    treffer++;
 }
 
 void Spieler::addKill()
 {
-    current.kills++;
-    current.punkte++;
+    kills++;
+    punkte++;
     skillPunkte += 2;
-    current.maxReinkAbk--;
-    if( current.maxReinkAbk < 5 )
-        current.maxReinkAbk = 5;
+    maxReinkAbk--;
+    if( maxReinkAbk < 5 )
+        maxReinkAbk = 5;
 }
 
 DeadPlayer *Spieler::sterben()
 {
-    current.amLeben = 0;
-    current.tode++;
-    current.stabilität = 0;
-    current.reinkAbk += current.maxReinkAbk;
-    current.maxReinkAbk++;
-    current.punkte--;
-    return deadPlayer ? deadPlayer->getThis() : 0;
+    amLeben = 0;
+    tode++;
+    stabilität = 0;
+    reinkAbk += maxReinkAbk;
+    maxReinkAbk++;
+    punkte--;
+    return deadPlayer ? (DeadPlayer*)deadPlayer->getThis() : 0;
 }
 
 void Spieler::wiederbelebung()
 {
-    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.energieAbk = 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 );
+    setPosition( startPos );
+    reinkAbk = maxReinkAbk * 2;
+    energie = maxEnergie + team->maxEnergie;
+    stabilität = maxStabilität + team->maxStabilität;
+    schussAbk = 0;
+    energieAbk = 0;
+    repAbk = 0;
+    setSpeed( 0, 0 );
+    setDrehung( 0 );
+    setDrehungSpeed( 0 );
     for( int i = 0; i < T_MAX; i++ )
         tastatur[ i ] = 0;
     flammenM->setAnimation( -1 );
     flammenL->setAnimation( -1 );
     flammenR->setAnimation( -1 );
-    current.amLeben = 1;
+    amLeben = 1;
 }
 
-void Spieler::resetToSaveTime( int t, Karte *zMap )
+void Spieler::resetToSaveTime( int t, const WeltInfo &info )
 {
     if( last.spielZeit > t )
         return; // this should never be possible
-    current = last;
-    tick( t, zMap );
+    load();
+    while( spielZeit < t )
+        tick( info, 0 );
 }
 
-void Spieler::resetToGameTime( int t, Karte *zMap )
+void Spieler::resetToGameTime( int t, const WeltInfo &info )
 {
-    last = current;
-    tick( t, zMap );
+    save();
+    while( spielZeit < t )
+        tick( info, 0 );
 }
 
 void Spieler::hatGeschossen()
 {
-    current.energie -= calculateLaserCost();
-    current.schussAbk = 1;
-    current.energieAbk = 1.5;
-    current.schüsse++;
+    energie -= calculateLaserCost();
+    schussAbk = 1;
+    energieAbk = 1.5;
+    schüsse++;
 }
 
 // constant
-Vec2< double > Spieler::getSpeed() const
-{
-    return current.speed;
-}
-
 int Spieler::getAccountId() const
 {
     return accountId;
@@ -664,7 +646,7 @@ bool Spieler::hatSkill() const
 
 bool Spieler::istAmLeben() const
 {
-    return current.amLeben;
+    return amLeben;
 }
 
 // Statistik Werte
@@ -680,135 +662,115 @@ Team *Spieler::zTeam() const
 
 int Spieler::getSpielerFarbe() const
 {
-    return current.farbe;
+    return farbe;
 }
 
 int Spieler::getSchadenBekommen() const
 {
-    return (int)current.schadenBekommen;
+    return (int)schadenBekommen;
 }
 
 int Spieler::getSchadenGemacht() const
 {
-    return (int)current.schadenGemacht;
+    return (int)schadenGemacht;
 }
 
 int Spieler::getTreibstoffVerbraucht() const
 {
-    return (int)current.treibstoffVerbraucht;
+    return (int)treibstoffVerbraucht;
 }
 
 int Spieler::getSchüsse() const
 {
-    return current.schüsse;
+    return schüsse;
 }
 
 int Spieler::getTreffer() const
 {
-    return current.treffer;
+    return treffer;
 }
 
 int Spieler::getPunkte() const
 {
-    return current.punkte;
+    return punkte;
 }
 
 int Spieler::getKills() const
 {
-    return current.kills;
+    return kills;
 }
 
 int Spieler::getTode() const
 {
-    return current.tode;
+    return tode;
 }
 
 int Spieler::getZeitAmLeben() const
 {
-    return (int)current.zeitAmLeben;
+    return (int)zeitAmLeben;
 }
 
 int Spieler::getZeitTod() const
 {
-    return (int)current.zeitTod;
-}
-
-Punkt Spieler::getPos() const
-{
-    return (Punkt)current.pos;
+    return (int)zeitTod;
 }
 
 double Spieler::getTeamMaxEnergieBonus() const
 {
-    return current.maxEnergie / 100 * current.netzwerk;
+    return maxEnergie / 100 * netzwerk;
 }
 
 double Spieler::getTeamMaxStabilitätBonus() const
 {
-    return current.maxStabilität / 100 * current.netzwerk;
+    return maxStabilität / 100 * netzwerk;
 }
 
 double Spieler::getTeamReparaturBonus() const
 {
-    return current.reparatur / 100 * current.netzwerk;
+    return reparatur / 100 * netzwerk;
 }
 
 double Spieler::getTeamLaserIntensitätBonus() const
 {
-    return current.laserIntensität / 100 * current.netzwerk;
+    return laserIntensität / 100 * netzwerk;
 }
 
 double Spieler::getTeamLaserEffizienzBonus() const
 {
-    return current.laserEffizienz / 100 * current.netzwerk;
+    return laserEffizienz / 100 * netzwerk;
 }
 
 double Spieler::getTeamAkkuLeistungBonus() const
 {
-    return current.akkuLeistung / 100 * current.netzwerk;
+    return akkuLeistung / 100 * netzwerk;
 }
 
 double Spieler::getTeamLaserTempoBonus() const
 {
-    return current.laserTempo / 100 * current.netzwerk;
+    return laserTempo / 100 * netzwerk;
 }
 
 double Spieler::getTeamBeschleunigungBonus() const
 {
-    return current.beschleunigung / 100 * current.netzwerk;
+    return beschleunigung / 100 * netzwerk;
 }
 
 double Spieler::getTeamWendigkeitBonus() const
 {
-    return current.wendigkeit / 100 * current.netzwerk;
+    return wendigkeit / 100 * netzwerk;
 }
 
 double Spieler::getTeamAntriebEffizienzBonus() const
 {
-    return current.antriebEffizienz / 100 * current.netzwerk;
+    return antriebEffizienz / 100 * netzwerk;
 }
 
 double Spieler::getTeamEnergieSchildBonus() const
 {
-    return current.energieSchild / 100 * current.netzwerk;
+    return energieSchild / 100 * netzwerk;
 }
 
 double Spieler::getTeamEnergieSchildEffizienzBonus() const
 {
-    return current.energieSchildEffizienz / 100 * current.netzwerk;
-}
-
-// Reference Counting
-Spieler *Spieler::getThis()
-{
-    ref++;
-    return this;
-}
-
-Spieler *Spieler::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
+    return energieSchildEffizienz / 100 * netzwerk;
 }

Asteroids/Spiel/Spieler/Spieler.h

@@ -5,7 +5,6 @@
 #include <Model2D.h>
 #include <TextFeld.h>
 #include <Animation.h>
-#include "..\Kamera\Kamera.h"
 #include "../Team/Team.h"
 #include "../Karte/Strukturen.h"
 #include "DeadPlayer.h"
@@ -24,15 +23,13 @@ enum TastaturStatus
 	T_MAX
 };
 
-class Spieler
+class Spieler : public Model2DObject
 {
 	friend class SpielerGUI;
 private:
     int accountId;
     int sNum;
     bool tastatur[ T_MAX ];
-    Textur2D *textur;
-    Model2D *ship;
     Team *team;
     KSGClient::InformationServerClient *info;
     Text *name;
@@ -48,6 +45,9 @@ private:
     struct SpielerDataSave
     {
         float rSpeed;
+        Vec2< double > pos;
+        Vec2< double > speed;
+        float rotation;
         int farbe;
         bool amLeben;
         double schussAbk;
@@ -57,9 +57,6 @@ private:
         int maxReinkAbk;
         int spielZeit;
         Punkt startPos;
-        Vec2< double > pos;
-        Vec2< double > speed;
-        double rotation;
         double beschleunigung;
         double energie;
         double stabilität;
@@ -86,9 +83,41 @@ private:
         int kills;
         int tode;
     };
+    int farbe;
+    bool amLeben;
+    double schussAbk;
+    double energieAbk;
+    double repAbk;
+    double reinkAbk;
+    int maxReinkAbk;
+    int spielZeit;
+    Punkt startPos;
+    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 antriebEffizienz;
+    double energieSchild;
+    double energieSchildEffizienz;
+    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;
 	int skillPunkte;
     Textur2D *flammenM;
     Textur2D *flammenL;
@@ -97,6 +126,8 @@ private:
     DeadPlayer *deadPlayer;
 
     double calculateLaserCost();
+    void save();
+    void load();
 
 public:
 	// Konstruktor
@@ -108,13 +139,10 @@ public:
 	void setAccountId( int accId );
 	void setTeam( Team *team );
 	void setSpielerFarbe( int fc, Bild *zTextur );
-	void setGeschwindigkeit( double xSpeed, double ySpeed );
-	void setPosition( Vec2< double > p );
-	void setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte *zMap );
-	bool tick( int time, Karte *zMap );
-	void render( Bild &zRObj );
-	void renderLeben( Bild &zRObj );
-	void renderMinimap( Bild &zRObj, Karte *zMap, int thisSpielerNummer );
+	void setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, const WeltInfo &info );
+	bool tick( const WeltInfo &info, double zeit ) override;
+	void render( Mat3< float > &kamMat, Bild &zRObj ) override;
+	void renderLeben( Mat3< float > &kamMat, Bild &zRObj );
 	void setSkill( int art );
 	void nimmSchaden( double &intensität );
     void calcDeadPlayerObject( Laser *zSchuss );
@@ -122,11 +150,10 @@ public:
 	void addKill();
     DeadPlayer *sterben();
 	void wiederbelebung();
-	void resetToSaveTime( int t, Karte *zMap );
-    void resetToGameTime( int t, Karte *zMap );
+	void resetToSaveTime( int t, const WeltInfo &info );
+    void resetToGameTime( int t, const WeltInfo &info );
 	void hatGeschossen();
 	// constant
-    Vec2< double > getSpeed() const;
 	int getAccountId() const;
 	Text *getName() const;
 	Text *zName() const;
@@ -146,7 +173,6 @@ public:
 	int getTode() const;
 	int getZeitAmLeben() const;
 	int getZeitTod() const;
-	Punkt getPos() const;
 	double getTeamMaxEnergieBonus() const;
 	double getTeamMaxStabilitätBonus() const;
 	double getTeamReparaturBonus() const;
@@ -159,9 +185,6 @@ public:
     double getTeamAntriebEffizienzBonus() const;
     double getTeamEnergieSchildBonus() const;
     double getTeamEnergieSchildEffizienzBonus() const;
-	// Reference Counting
-	Spieler *getThis();
-	Spieler *release();
 };
 
 #endif

Asteroids/Spiel/SpielerGUI/SpielerGUI.cpp

@@ -125,117 +125,117 @@ SpielerGUI::~SpielerGUI()
 void SpielerGUI::update( Spieler *zSpieler )
 {
 	spieler->setText( zSpieler->name->getText() );
-	spieler->setSchriftFarbe( zSpieler->current.farbe );
+	spieler->setSchriftFarbe( zSpieler->farbe );
 	Text txt;
-	txt.setPrecision( getStellen( zSpieler->current.stabilität ) + 2 );
-	txt = zSpieler->current.stabilität;
+	txt.setPrecision( getStellen( zSpieler->stabilität ) + 2 );
+	txt = zSpieler->stabilität;
 	txt += "/";
-	txt.setPrecision( getStellen( zSpieler->current.maxStabilität ) + 2 );
-	txt += zSpieler->current.maxStabilität;
+	txt.setPrecision( getStellen( zSpieler->maxStabilität ) + 2 );
+	txt += zSpieler->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->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;
+	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;
 	txt += "/";
-	txt.setPrecision( getStellen( zSpieler->current.maxEnergie ) + 2 );
-	txt += zSpieler->current.maxEnergie;
+	txt.setPrecision( getStellen( zSpieler->maxEnergie ) + 2 );
+	txt += zSpieler->maxEnergie;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->maxEnergie ) + 2 );
 	txt += zSpieler->team->maxEnergie;
 	txt += ")";
 	energie->setText( txt );
 	energieB->reset();
-	energieB->setAktionAnzahl( (int)( zSpieler->current.maxEnergie + zSpieler->team->maxEnergie ) );
-	energieB->aktionPlus( (int)( zSpieler->current.energie ) );
+	energieB->setAktionAnzahl( (int)( zSpieler->maxEnergie + zSpieler->team->maxEnergie ) );
+	energieB->aktionPlus( (int)( zSpieler->energie ) );
 	txt = "Reparatur:";
-	txt.setPrecision( getStellen( zSpieler->current.reparatur ) + 2 );
-	txt += zSpieler->current.reparatur;
+	txt.setPrecision( getStellen( zSpieler->reparatur ) + 2 );
+	txt += zSpieler->reparatur;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->reparatur ) + 2 );
 	txt += zSpieler->team->reparatur;
 	txt += ")";
 	reparatur->setText( txt );
 	txt = "Akku:";
-	txt.setPrecision( getStellen( zSpieler->current.akkuLeistung ) + 2 );
-	txt += zSpieler->current.akkuLeistung;
+	txt.setPrecision( getStellen( zSpieler->akkuLeistung ) + 2 );
+	txt += zSpieler->akkuLeistung;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->akkuLeistung ) + 2 );
 	txt += zSpieler->team->akkuLeistung;
 	txt += ")";
 	akkuLeistung->setText( txt );
 	txt = "Wendigkeit:";
-	txt.setPrecision( getStellen( zSpieler->current.wendigkeit ) + 2 );
-	txt += zSpieler->current.wendigkeit;
+	txt.setPrecision( getStellen( zSpieler->wendigkeit ) + 2 );
+	txt += zSpieler->wendigkeit;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->wendigkeit ) + 2 );
 	txt += zSpieler->team->wendigkeit;
 	txt += ")";
 	wendigkeit->setText( txt );
 	txt = "Beschleunigung:";
-	txt.setPrecision( getStellen( zSpieler->current.beschleunigung ) + 2 );
-	txt += zSpieler->current.beschleunigung;
+	txt.setPrecision( getStellen( zSpieler->beschleunigung ) + 2 );
+	txt += zSpieler->beschleunigung;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->beschleunigung ) + 2 );
 	txt += zSpieler->team->beschleunigung;
 	txt += ")";
 	beschleunigung->setText( txt );
 	txt = "Antrieb effizienz:";
-	txt.setPrecision( getStellen( zSpieler->current.antriebEffizienz ) + 2 );
-	txt += zSpieler->current.antriebEffizienz;
+	txt.setPrecision( getStellen( zSpieler->antriebEffizienz ) + 2 );
+	txt += zSpieler->antriebEffizienz;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->antriebEffizienz ) + 2 );
 	txt += zSpieler->team->antriebEffizienz;
 	txt += ")";
     antriebEffizienz->setText( txt );
     txt = "Laser intensität:";
-    txt.setPrecision( getStellen( zSpieler->current.laserIntensität ) + 2 );
-    txt += zSpieler->current.laserIntensität;
+    txt.setPrecision( getStellen( zSpieler->laserIntensität ) + 2 );
+    txt += zSpieler->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->current.laserEffizienz ) + 2 );
-	txt += zSpieler->current.laserEffizienz;
+	txt.setPrecision( getStellen( zSpieler->laserEffizienz ) + 2 );
+	txt += zSpieler->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->current.laserTempo ) + 2 );
-	txt += zSpieler->current.laserTempo;
+	txt.setPrecision( getStellen( zSpieler->laserTempo ) + 2 );
+	txt += zSpieler->laserTempo;
 	txt += "\r0xFF00FF00(+";
 	txt.setPrecision( getStellen( zSpieler->team->laserTempo ) + 2 );
 	txt += zSpieler->team->laserTempo;
 	txt += ")";
 	laserTempo->setText( txt );
     txt = "Energie Schild:";
-    txt.setPrecision( getStellen( zSpieler->current.energieSchild ) + 2 );
-    txt += zSpieler->current.energieSchild;
+    txt.setPrecision( getStellen( zSpieler->energieSchild ) + 2 );
+    txt += zSpieler->energieSchild;
     txt += "\r0xFF00FF00(+";
     txt.setPrecision( getStellen( zSpieler->team->energieSchild ) + 2 );
     txt += zSpieler->team->energieSchild;
     txt += ")";
     energieSchild->setText( txt );
     txt = "Schild effizienz:";
-    txt.setPrecision( getStellen( zSpieler->current.energieSchildEffizienz ) + 2 );
-    txt += zSpieler->current.energieSchildEffizienz;
+    txt.setPrecision( getStellen( zSpieler->energieSchildEffizienz ) + 2 );
+    txt += zSpieler->energieSchildEffizienz;
     txt += "\r0xFF00FF00(+";
     txt.setPrecision( getStellen( zSpieler->team->energieSchildEffizienz ) + 2 );
     txt += zSpieler->team->energieSchildEffizienz;
     txt += ")";
     energieSchildEffizienz->setText( txt );
 	txt = "Netzwerk:";
-	txt.setPrecision( getStellen( zSpieler->current.netzwerk ) + 2 );
-	txt += zSpieler->current.netzwerk;
+	txt.setPrecision( getStellen( zSpieler->netzwerk ) + 2 );
+	txt += zSpieler->netzwerk;
 	netzwerk->setText( txt );
 	stabilitätSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );
 	energieSkill->setStyle( Knopf::Style::Erlaubt, zSpieler->hatSkill() );