Editor weiterentwickelt, Raumschiff antrieb annimiert, Anzeige wie viel energie ein schuss kostet

Asteroids/Asteroids.vcxproj

@@ -170,11 +170,16 @@
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="Aufzeichnung\Aufzeichnung.h" />
+    <ClInclude Include="Editor\ActionThread.h" />
     <ClInclude Include="Editor\Editor.h" />
     <ClInclude Include="Editor\Interface\Dialogs\Dialog.h" />
     <ClInclude Include="Editor\Interface\Dialogs\Nachricht.h" />
     <ClInclude Include="Editor\Interface\Dialogs\Frage.h" />
     <ClInclude Include="Editor\Interface\Interface.h" />
+    <ClInclude Include="Editor\Karte\EditorKarte.h" />
+    <ClInclude Include="Editor\Karte\Objekt\GameObject\GameObjekt.h" />
+    <ClInclude Include="Editor\Karte\Objekt\MapObjekt.h" />
+    <ClInclude Include="Editor\Karte\Objekt\Spawnpunkt\Spawnpunkt.h" />
     <ClInclude Include="Editor\Netzwerk\EditorKlient.h" />
     <ClInclude Include="Editor\Prozess.h" />
     <ClInclude Include="HistorieStatistik\HistorieStatistik.h" />
@@ -200,11 +205,14 @@
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Aufzeichnung\Aufzeichnung.cpp" />
+    <ClCompile Include="Editor\ActionThread.cpp" />
     <ClCompile Include="Editor\Editor.cpp" />
     <ClCompile Include="Editor\Interface\Dialogs\Dialog.cpp" />
     <ClCompile Include="Editor\Interface\Dialogs\Frage.cpp" />
     <ClCompile Include="Editor\Interface\Dialogs\Nachricht.cpp" />
     <ClCompile Include="Editor\Interface\Interface.cpp" />
+    <ClCompile Include="Editor\Karte\EditorKarte.cpp" />
+    <ClCompile Include="Editor\Karte\Objekt\MapObjekt.cpp" />
     <ClCompile Include="Editor\Netzwerk\EditorKlient.cpp" />
     <ClCompile Include="Editor\Prozess.cpp" />
     <ClCompile Include="HistorieStatistik\HistorieStatistik.cpp" />

Asteroids/Asteroids.vcxproj.filters

@@ -99,6 +99,21 @@
     <ClInclude Include="Editor\Interface\Dialogs\Nachricht.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="Editor\ActionThread.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Karte\Objekt\MapObjekt.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Karte\Objekt\Spawnpunkt\Spawnpunkt.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Karte\Objekt\GameObject\GameObjekt.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Karte\EditorKarte.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Initialisierung\Initialisierung.cpp">
@@ -182,5 +197,14 @@
     <ClCompile Include="Editor\Interface\Dialogs\Frage.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Editor\ActionThread.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Karte\Objekt\MapObjekt.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Karte\EditorKarte.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Asteroids/Editor/ActionThread.cpp

@@ -0,0 +1,21 @@
+#include "ActionThread.h"
+
+// Inhalt der ActionThread Klasse
+// Konstruktor
+ActionThread::ActionThread( std::function<void()> ak )
+{
+    action = ak;
+    start();
+}
+
+// Führt die Threadaktion aus
+void ActionThread::thread()
+{
+    action();
+}
+
+// Wird am ende des Threads ausgeführt
+void ActionThread::threadEnd()
+{
+    delete this;
+}

Asteroids/Editor/ActionThread.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <Thread.h>
+#include <functional>
+
+using namespace Framework;
+
+// Lagert den Aufruf einer bestimmten Funktion in einen neuen Thread aus.
+// Der Thread wird automatisch gestartet und löscht sich anschließend selbst.
+class ActionThread : public Thread
+{
+private:
+    std::function<void()> action;
+
+public:
+    // Konstruktor
+    ActionThread( std::function<void()> ak );
+    // Führt die Threadaktion aus
+    void thread() override;
+    // Wird am ende des Threads ausgeführt
+    void threadEnd() override;
+};

Asteroids/Editor/Editor.cpp

@@ -1,4 +1,7 @@
 #include "Editor.h"
+#include "ActionThread.h"
+#include "Interface\Dialogs\Frage.h"
+#include "Interface\Dialogs\Nachricht.h"
 #include <iostream>
 
 // Inhalt der Editor Klasse aus Editor.h
@@ -10,7 +13,7 @@ Editor::Editor()
     laden = 0;
     i = 0;
     alpha = 0;
-    verlassen = 0;
+    status = START;
     dialogs = new Array< Dialog* >();
     rend = 1;
     ref = 1;
@@ -29,6 +32,14 @@ Editor::~Editor()
         i->release();
 }
 
+// nicht constant
+void Editor::addDialog( Dialog *d )
+{
+    c.lock();
+    dialogs->add( d );
+    c.unlock();
+}
+
 // nicht constant
 void Editor::setSchrift( Schrift *schrift )
 {
@@ -55,30 +66,67 @@ void Editor::setLadeAnimation( Animation2D *la )
 
 void Editor::setSichtbar()
 {
-    verlassen = 0;
+    status = START;
+    EditorKlient *k = klient->getThis();
+    Schrift *zS = schrift->getThis();
+    Punkt mS = windowSize;
+    new ActionThread( [ this, k, zS, mS ] (void) -> void
+    {
+        int ret = k->init();
+        if( ret == 2 )
+        {
+            std::function< void() > wiederherstellen = [ k ]
+            {
+                // TODO Karte herunterladen und anzeigen
+            };
+            std::function< void() > verwerfen = [ this, k, zS, mS ]
+            {
+                if( !k->sitzungVerwerfen() )
+                {
+                    Text t = "Fehler beim verwerfen der Sitzung: ";
+                    t += k->getLastError();
+                    this->addDialog( new Nachricht( zS, t, mS ) );
+                }
+                // TODO Karte herunterladen und anzeigen
+            };
+            this->addDialog( new Frage( zS, "Es wurde eine alte ungespeicherte Sitzung gefunden. möchtest du sie Wiederherstellen?", "Ja", "Nein", wiederherstellen, verwerfen, verwerfen, mS ) );
+            zS->release();
+            k->release();
+        }
+    } );
     rend = 1;
 }
 
 void Editor::doMausEreignis( MausEreignis &me )
 {
+    c.lock();
     for( auto i = dialogs->getArray(); i.set && i.var; i++ )
         i.var->doMausEreignis( me );
+    bool dialogActive = dialogs->hat( 0 );
+    c.unlock();
     i->doMausEreignis( me );
-    verlassen = i->hatVerlassen();
+    if( i->hatVerlassen() && status == INITIALIZED && !dialogActive )
+    {
+        status = EXIT;
+    }
 }
 
 void Editor::doTastaturEreignis( TastaturEreignis &te )
 {
+    c.lock();
     for( auto i = dialogs->getArray(); i.set && i.var; i++ )
         i.var->doTastaturEreignis( te );
+    c.unlock();
     i->doTastaturEreignis( te );
 }
 
 bool Editor::tick( double z )
 {
     rend |= i->tick( z );
+    c.lock();
     for( auto i = dialogs->getArray(); i.set && i.var; i++ )
         rend |= i.var->tick( z );
+    c.unlock();
     bool tmp = rend;
     rend = 0;
     return tmp;
@@ -87,6 +135,7 @@ bool Editor::tick( double z )
 void Editor::render( Bild &zRObj )
 {
     i->render( zRObj );
+    c.lock();
     for( int i = dialogs->getEintragAnzahl() - 1; i >= 0; i-- )
     {
         dialogs->get( i )->render( zRObj );
@@ -96,12 +145,13 @@ void Editor::render( Bild &zRObj )
             dialogs->remove( i );
         }
     }
+    c.unlock();
 }
 
 // constant
 bool Editor::hatVerlassen( bool jetzt ) const
 {
-    return verlassen;
+    return status == EXIT;
 }
 
 // Reference Counting

Asteroids/Editor/Editor.h

@@ -9,13 +9,23 @@
 class Editor : public EditorV
 {
 private:
+    enum Status
+    {
+        START,
+        SITZUNG_FRAGE,
+        INITIALIZED,
+        WARTEND,
+        EXIT
+    };
+    Status status;
 	Schrift *schrift;
     EditorKlient *klient;
     Animation2D *laden;
     Interface *i;
     Array< Dialog* > *dialogs;
+    Critical c;
+    Punkt windowSize;
 	unsigned char alpha;
-    bool verlassen;
     bool rend;
 	int ref;
 
@@ -25,6 +35,7 @@ public:
 	// Destruktor
 	~Editor();
 	// nicht constant
+    void addDialog( Dialog *d );
 	void setSchrift( Schrift *schrift ) override;
 	void setKlient( EditorKlientV *ekv ) override;
     void setLadeAnimation( Animation2D *la ) override;

Asteroids/Editor/Karte/EditorKarte.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "Objekt\Objekt.h"
+
+class Karte
+{
+
+};

Asteroids/Editor/Karte/Objekt/GameObject/GameObjekt.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "../MapObjekt.h"
+
+class GameObjekt : public MapObjekt2D
+{
+private:
+    struct GameObjectData
+    {
+        int id;
+        int m2d;
+        int bild;
+        int style;
+        int maxStability;
+        int maxEnergie;
+        int energieRadius;
+        double reparatur;
+        double akkuLeistung;
+        char team;
+    };
+    GameObjectData data;
+
+protected:
+    // Wird aufgerufen, wenn das Objekt durch den Nutzer verschoben wird
+    virtual void onMoved() override;
+    // Wird aufgerufen, wenn der Nutzer das Optionsfenster des Objekts aufrufen will
+    virtual void onOpenOptionWindow() override;
+public:
+    // Konstruktor
+    //  klient: Der Klient zum Editor Server
+    GameObjekt( EditorKlient *klient );
+    // Destructor
+    ~GameObjekt();
+    // Verarbeitet ein Maus Ereignis
+    //  me: Das Maus Ereignis
+    void doMausEreignis( MausEreignis me ) override;
+    // Verarbeitet ein Tastatur Ereignis
+    //  te: Das Tastaturereignis
+    void doTastaturEreignis( TastaturEreignis te ) override;
+    // Verarbeitet die vergangene Zeit
+    //  tv: Die vergangene Zeit in Sekunden seit dem letzten Aufruf der Funktion
+    //  return: 1, falls das objekt neu gezeichnet werden muss. 0 sonnst
+    bool tick( double tv ) override;
+    // Erhöht den reference Counter um 1
+    //  return this
+    virtual MapObjekt *getThis() override;
+    // Verringert den reference Counter um 1 und löscht das Objekt wenn er bei 0 ankommt
+    //  return 0
+    virtual MapObjekt *release() override;
+};

Asteroids/Editor/Karte/Objekt/MapObjekt.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <Bild.h>
+#include <TastaturEreignis.h>
+#include "../../Netzwerk/EditorKlient.h"
+
+using namespace Framework;
+
+class MapObjekt
+{
+    class Style
+    {
+    public:
+        const static int Verschiebbar = 0x01;
+        const static int Sichtbar = 0x02;
+        const static int Selected = 0x04;
+    };
+
+protected:
+    int style;
+    EditorKlient *klient;
+    Punkt pos;
+    Punkt size;
+    int ref;
+
+    // Wird aufgerufen, wenn das Objekt durch den Nutzer verschoben wird
+    virtual void onMoved() = 0;
+    // Wird aufgerufen, wenn der Nutzer das Optionsfenster des Objekts aufrufen will
+    virtual void onOpenOptionWindow() = 0;
+
+public:
+    // Konstruktor
+    //  klient: Der Klient zum Editor Server
+    MapObjekt( EditorKlient *klient );
+    // Destructor
+    ~MapObjekt();
+    // Verarbeitet ein Maus Ereignis
+    //  me: Das Maus Ereignis
+    virtual void doMausEreignis( MausEreignis me );
+    // Verarbeitet ein Tastatur Ereignis
+    //  te: Das Tastaturereignis
+    virtual void doTastaturEreignis( TastaturEreignis te );
+    // Verarbeitet die vergangene Zeit
+    //  tv: Die vergangene Zeit in Sekunden seit dem letzten Aufruf der Funktion
+    //  return: 1, falls das objekt neu gezeichnet werden muss. 0 sonnst
+    virtual bool tick( double tv );
+    // Zeichnet das Objekt nach zRObj
+    //  zRObj: Das Bild in das gezeichnet werden soll
+    virtual void render( Bild *zRObj );
+    // Erhöht den reference Counter um 1
+    //  return this
+    virtual MapObjekt *getThis();
+    // Verringert den reference Counter um 1 und löscht das Objekt wenn er bei 0 ankommt
+    //  return 0
+    virtual MapObjekt *release();
+};
+
+class MapObjektBitmap : public MapObjekt
+{
+protected:
+    Bild *bmp;
+
+public:
+    // Konstruktor
+    //  klient: Der Klient zum Editor Server
+    MapObjektBitmap( EditorKlient *klient );
+    // Destructor
+    ~MapObjektBitmap();
+    // Zeichnet das Objekt nach zRObj
+    //  zRObj: Das Bild in das gezeichnet werden soll
+    void render( Bild *zRObj ) override;
+    // Erhöht den reference Counter um 1
+    //  return this
+    MapObjekt *getThis() override;
+    // Verringert den reference Counter um 1 und löscht das Objekt wenn er bei 0 ankommt
+    //  return 0
+    MapObjekt *release() override;
+};
+
+class MapObjekt2D : public MapObjekt
+{
+protected:
+    Model2D *m2;
+
+public:
+    // Konstruktor
+    //  klient: Der Klient zum Editor Server
+    MapObjekt2D( EditorKlient *klient );
+    // Destructor
+    ~MapObjekt2D();
+    // Zeichnet das Objekt nach zRObj
+    //  zRObj: Das Bild in das gezeichnet werden soll
+    void render( Bild *zRObj ) override;
+    // Erhöht den reference Counter um 1
+    //  return this
+    MapObjekt *getThis() override;
+    // Verringert den reference Counter um 1 und löscht das Objekt wenn er bei 0 ankommt
+    //  return 0
+    MapObjekt *release() override;
+};

Asteroids/Editor/Karte/Objekt/Spawnpunkt/Spawnpunkt.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "../MapObjekt.h"
+
+class Spawnpunkt : public MapObjektBitmap
+{
+private:
+    int spielerId;
+
+protected:
+    // Wird aufgerufen, wenn das Objekt durch den Nutzer verschoben wird
+    virtual void onMoved() override;
+    // Wird aufgerufen, wenn der Nutzer das Optionsfenster des Objekts aufrufen will
+    virtual void onOpenOptionWindow() override;
+public:
+    // Konstruktor
+    //  klient: Der Klient zum Editor Server
+    Spawnpunkt( EditorKlient *klient );
+    // Destructor
+    ~Spawnpunkt();
+    // Verarbeitet ein Maus Ereignis
+    //  me: Das Maus Ereignis
+    void doMausEreignis( MausEreignis me ) override;
+    // Verarbeitet ein Tastatur Ereignis
+    //  te: Das Tastaturereignis
+    void doTastaturEreignis( TastaturEreignis te ) override;
+    // Verarbeitet die vergangene Zeit
+    //  tv: Die vergangene Zeit in Sekunden seit dem letzten Aufruf der Funktion
+    //  return: 1, falls das objekt neu gezeichnet werden muss. 0 sonnst
+    bool tick( double tv ) override;
+    // Erhöht den reference Counter um 1
+    //  return this
+    virtual MapObjekt *getThis() override;
+    // Verringert den reference Counter um 1 und löscht das Objekt wenn er bei 0 ankommt
+    //  return 0
+    virtual MapObjekt *release() override;
+};

Asteroids/Editor/Netzwerk/EditorKlient.cpp

@@ -1,4 +1,7 @@
 #include "EditorKlient.h"
+#include <Klient.h>
+
+using namespace Network;
 
 // Inhalt der EditorKlient Klasse aus EditorKlient.h
 // Konstruktor
@@ -35,6 +38,11 @@ int EditorKlient::init()
         {
             k->sendeEncrypted( "\x0", 1 );
             k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                k->getNachrichtEncrypted( &ret, 1 );
+                return ret;
+            }
         }
     }
     if( ret == 3 )
@@ -52,6 +60,40 @@ int EditorKlient::init()
     return ret;
 }
 
+// Verwirft die vorhandene Sitzung und erstellt eine neue
+bool EditorKlient::sitzungVerwerfen()
+{
+    klient->lock();
+    error = "";
+    Klient *k = klient->zKlient();
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xF", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x1", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+        }
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->unlock();
+    return ret == 1;
+}
+
 // Gibt den Letzten Fehler zurück
 char *EditorKlient::getLastError() const
 {

Asteroids/Editor/Netzwerk/EditorKlient.h

@@ -20,6 +20,8 @@ public:
     //          2, falls bereits eine Sitzung existiert
     //          0, sonnst
     int init();
+    // Verwirft die vorhandene Sitzung und erstellt eine neue
+    bool sitzungVerwerfen();
     // Gibt den Letzten Fehler zurück
     char *getLastError() const;
     // Reference Counting

Asteroids/Editor/Prozess.cpp

@@ -1,4 +1,7 @@
 #include "Prozess.h"
+#include <Klient.h>
+
+using namespace Network;
 
 // Inhalt der Klasse Prozess aus Prozess.h
 // Konstruktor

Asteroids/Spiel/Karte/Karte.cpp

@@ -72,14 +72,14 @@ void Karte::ladeSts( Datei *zDatei )
 	}
 }
 
-void Karte::ladeMap( Datei *zDatei, InformationKlientV *infoK, int mapId, SpielKlientV *zSpielKlient )
+void Karte::ladeMap( Datei *zDatei, int mapId, SpielKlientV *zSpielKlient, Text *zGamePath )
 {
 	int ressourceAnz = 0;
 	zDatei->lese( (char*)&ressourceAnz, 4 );
 	for( int i = 0; i < ressourceAnz; i++ )
 	{
-		ressources->add( new RessourceStr( zDatei, infoK, mapId ) );
-		zSpielKlient->setLadenProzent( 5 + (int)( 65 * ( (double)( i + 1 ) / ressourceAnz ) + 0.5 ) );
+		ressources->add( new RessourceStr( zDatei, mapId, zGamePath ) );
+		zSpielKlient->setLadenProzent( 15 + (int)( 65 * ( (double)( i + 1 ) / ressourceAnz ) + 0.5 ) );
 	}
 	zDatei->lese( (char*)&größe.x, 4 );
 	zDatei->lese( (char*)&größe.y, 4 );
@@ -108,7 +108,7 @@ Vec2< int > Karte::getSize() const
 	return größe;
 }
 
-Spieler *Karte::createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *zInfoK ) const
+Spieler *Karte::createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *zInfoK, Animation2DData *zFStart, Animation2DData *zFBurn ) const
 {
 	if( sNum < 0 || sNum >= spielerAnzahl )
 		return 0;
@@ -118,7 +118,7 @@ Spieler *Karte::createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *
 	for( auto i = &ressources->getArray(); i && i->set && i->var; i = i->next )
 	{
 		if( i->var->getId() == m2d )
-			ret->setModelData( i->var->zReccourceM2()->getThis() );
+			ret->setModelData( i->var->zReccourceM2()->getThis(), zFStart, zFBurn );
 		if( i->var->getId() == bild )
 			ret->setSpielerFarbe( spielerFarbe->hat( sNum ) ? spielerFarbe->get( sNum ) : 0, i->var->zReccourceTxt() );
 	}

Asteroids/Spiel/Karte/Karte.h

@@ -34,10 +34,10 @@ public:
 	~Karte();
 	// nicht constant
 	void ladeSts( Datei *zDatei ); // call 1
-	void ladeMap( Datei *zDatei, InformationKlientV *infoK, int mapId, SpielKlientV *zSpielKlient ); // call 2
+	void ladeMap( Datei *zDatei, int mapId, SpielKlientV *zSpielKlient, Text *zGamePath ); // call 2
 	// constant
 	Vec2< int > getSize() const;
-	Spieler *createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *zInfoK ) const;
+	Spieler *createSpieler( int sNum, Schrift *zSchrift, InformationKlientV *zInfoK, Animation2DData *zFStart, Animation2DData *zFBurn ) const;
 	Team *createTeam( int tNum ) const;
 	SpielObjekt *createZeichnung( int oNum, Schrift *zSchrift ) const;
 	int getMaxTeamAnzahl() const;

Asteroids/Spiel/Karte/Strukturen.cpp

@@ -4,7 +4,7 @@
 
 // Inhalt der RessourceStr Klasse aus Strukturen.h
 // Konstruktor
-RessourceStr::RessourceStr( Datei *zDatei, InformationKlientV *zInfoK, int karteId )
+RessourceStr::RessourceStr( Datei *zDatei, int karteId, Text *zGamePath )
 {
 	zDatei->lese( (char*)&id, 4 );
 	char län = 0;
@@ -16,7 +16,7 @@ RessourceStr::RessourceStr( Datei *zDatei, InformationKlientV *zInfoK, int karte
 	pfad = 0;
 	if( txt.positionVon( "spiel:" ) == 0 )
 	{
-		pfad = zInfoK->getDateiGruppePfad( zInfoK->getDateiGruppeIdVonSpiel( zInfoK->getSpielId( karteId ) ) );
+		pfad->setText( zGamePath->getText() );
 		if( pfad )
 			pfad->append( txt.getTeilText( 6 ) );
 	}

Asteroids/Spiel/Karte/Strukturen.h

@@ -19,7 +19,7 @@ private:
 
 public:
 	// Konstruktor
-	RessourceStr( Datei *zDatei, InformationKlientV *zInfoK, int karteId );
+	RessourceStr( Datei *zDatei, int karteId, Text *zGamePath );
 	// Destruktor
 	~RessourceStr();
 	// constant

Asteroids/Spiel/Objekt/SpielObjekt.cpp

@@ -1,6 +1,7 @@
 #include "SpielObjekt.h"
 #include "../Define.h"
 #include "../../Initialisierung/Initialisierung.h"
+#include <Textur2D.h>
 
 // Inhalt der SpielObjekt Klasse aus SpielObjekt.h
 // Konstruktor
@@ -41,7 +42,9 @@ void SpielObjekt::setModelData( Model2DData *data )
 
 void SpielObjekt::setTextur( Bild *textur )
 {
-	mdl->setTextur( textur );
+    Textur2D *t = new Textur2D();
+    t->setTexturZ( textur );
+	mdl->setTextur( t );
 }
 
 void SpielObjekt::setTeam( Team *team )

Asteroids/Spiel/SpielKlasse.cpp

@@ -7,6 +7,7 @@
 #include <DateiSystem.h>
 #include "Ship/Ship.h"
 #include "Define.h"
+#include <Animation.h>
 
 // Inhalt der SpielKlasse Klasse aus SpielKlasse.h
 // Konstruktor
@@ -153,6 +154,24 @@ void SpielKlasse::setKarteId( int karteId )
 
 void SpielKlasse::ladeDaten()
 {
+    // load frame annimation
+    Text *gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
+    LTDBDatei flammenStartLTDB;
+    Text *f_start = new Text( gamePath->getText() );
+    f_start->append( "/bilder/f_start.ltdb" );
+    flammenStartLTDB.setDatei( f_start );
+    flammenStartLTDB.leseDaten( 0 );
+    Animation2DData *flammenStart = new Animation2DData();
+    flammenStart->ladeAnimation( flammenStartLTDB.getThis() );
+    flammenStart->setFPS( 60 );
+    flammenStart->setWiederhohlend( 0 );
+    spielKlient->setLadenProzent( 7 );
+    LTDBDatei flammenLTDB;
+    flammenLTDB.setDatei( new Text( "data/Minigames/Asteroids/bilder/f_burn.ltdb" ) );
+    Animation2DData *flammenBurn = new Animation2DData();
+    flammenBurn->ladeAnimation( flammenLTDB.getThis() );
+    flammenBurn->setFPS( 60 );
+    flammenBurn->setWiederhohlend( 1 );
 	kam = new Kamera();
 	map = new Karte();
     Text *mapPf = new Text( "data/tmp/Karten/" );
@@ -164,17 +183,19 @@ void SpielKlasse::ladeDaten()
 	map->ladeSts( stsD );
 	stsD->close();
 	stsD->release();
-	spielKlient->setLadenProzent( 5 );
+	spielKlient->setLadenProzent( 15 );
 	mapPf->ersetzen( mapPf->getLength() - 3, mapPf->getLength(), "map" );
 	Datei *mapD = new Datei();
 	mapD->setDatei( mapPf->getText() );
 	mapD->open( Datei::Style::lesen );
-	map->ladeMap( mapD, infoKlient, karteId, spielKlient );
+	map->ladeMap( mapD, karteId, spielKlient, gamePath );
 	mapD->close();
 	mapD->release();
 	mapPf->release();
 	for( int i = 0; i < map->getMaxSpielerAnzahl(); i++ )
-		spieler->set( map->createSpieler( i, schrift, infoKlient ), i );
+		spieler->set( map->createSpieler( i, schrift, infoKlient, flammenStart, flammenBurn ), i );
+    flammenStart->release();
+    flammenBurn->release();
 	spielKlient->setLadenProzent( 95 );
 	for( int i = 0; i < map->getZeichnungAnzahl(); i++ )
 		objekte->set( map->createZeichnung( i, schrift ), i );

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -2,6 +2,7 @@
 #include "../../Initialisierung/Initialisierung.h"
 #include "../Karte/Karte.h"
 #include "../Define.h"
+#include <Textur2D.h>
 
 // Inhalt der Spieler Klasse aus Spieler.h
 // Konstruktor
@@ -64,18 +65,41 @@ Spieler::Spieler( InformationKlientV *zInfoK, Schrift *zSchrift, SpielerStr *zSt
 // Destruktor
 Spieler::~Spieler()
 {
-	ship->release();
-	info->release();
-	if( team )
-		team->release();
-	if( name )
-		name->release();
+    ship->release();
+    info->release();
+    if( team )
+        team->release();
+    if( name )
+        name->release();
+    flammenL->release();
+    flammenR->release();
+    flammenM->release();
+}
+
+double Spieler::calculateLaserCost()
+{
+    double kosten = ( laserIntensität + team->laserIntensität + ( laserTempo + team->laserTempo ) / 5 ) - ( laserEffizienz + team->laserEffizienz );
+    if( kosten < 1 )
+        kosten = 1;
+    return kosten;
 }
 
 // nicht constant
-void Spieler::setModelData( Model2DData *data )
+void Spieler::setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn )
 {
 	ship->setModel( data );
+    flammenM = new Textur2D();
+    flammenM->addAnimationZ( zFStart->getThis() );
+    flammenM->addAnimationZ( zFBurn->getThis() );
+    flammenL = new Textur2D();
+    flammenL->addAnimationZ( zFStart->getThis() );
+    flammenL->addAnimationZ( zFBurn->getThis() );
+    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" );
 }
 
 void Spieler::setAccountId( int accId )
@@ -111,7 +135,9 @@ void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
 			shb->alphaPixelDP( i, buffer[ i ] );
 		}
 	}
-	ship->setTextur( shb );
+    Textur2D *textur = new Textur2D();
+    textur->setTexturZ( shb );
+	ship->setTextur( textur, "ship" );
 }
 
 void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
@@ -136,6 +162,28 @@ void Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv, int sZ, Karte
 	setMoveZeit( z, zMap );
 	tastatur[ ts ] = aktiv;
 	setMoveZeit( -z, zMap );
+    if( flammenM && flammenR && flammenL )
+    {
+        switch( ts )
+        {
+        case T_GAS:
+            if( aktiv )
+                flammenM->setAnimation( 0 );
+            else
+                flammenM->setAnimation( -1 );
+            break;
+        case T_ROT_L:
+            if( aktiv )
+                flammenR->setAnimation( 0 );
+            else
+                flammenR->setAnimation( -1 );
+        case T_ROT_R:
+            if( aktiv )
+                flammenL->setAnimation( 0 );
+            else
+                flammenL->setAnimation( -1 );
+        }
+    }
 }
 
 bool Spieler::tick( Karte *zMap )
@@ -147,6 +195,9 @@ bool Spieler::tick( Karte *zMap )
 	reinkAbk -= tv;
 	if( reinkAbk < 0 )
 		reinkAbk = 0;
+    flammenM->tick( tv );
+    flammenL->tick( tv );
+    flammenR->tick( tv );
 	if( !reinkAbk && !amLeben )
 	{ // Wiederbelebung
 		//wiederbelebung( spielZeit );
@@ -209,6 +260,12 @@ void Spieler::renderLeben( Bild &zRObj )
 	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 26, e, 0xFFFFFF00 );
 	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 27, e, 0xFFFFFF00 );
 	zRObj.drawLinieH( nText->getX() + 1, nText->getY() + 28, e, 0xFFFFFF00 );
+    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 );
+        zRObj.drawLinieV( nText->getX() + e2 + 1, nText->getY() + 26, 3, 0xFFFFFFFF );
+    }
 }
 
 void Spieler::renderMinimap( Bild &zRObj, Karte *zMap )
@@ -324,6 +381,9 @@ void Spieler::wiederbelebung()
 	ship->setPosition( pos );
 	for( int i = 0; i < T_MAX; i++ )
 		tastatur[ i ] = 0;
+    flammenM->setAnimation( -1 );
+    flammenL->setAnimation( -1 );
+    flammenR->setAnimation( -1 );
 	amLeben = 1;
 }
 
@@ -425,10 +485,7 @@ void Spieler::setMoveZeit( int z, Karte *zMap )
 
 void Spieler::hatGeschossen()
 {
-	double kosten = ( laserIntensität + team->laserIntensität + ( laserTempo + team->laserTempo ) / 5 ) - ( laserEffizienz + team->laserEffizienz );
-	if( kosten < 1 )
-		kosten = 1;
-	energie -= kosten;
+	energie -= calculateLaserCost();
 	schussAbk = 1;
 	schüsse++;
 }

Asteroids/Spiel/Spieler/Spieler.h

@@ -4,6 +4,7 @@
 #include <KSGKlientV.h>
 #include <Model2D.h>
 #include <TextFeld.h>
+#include <Animation.h>
 #include "..\Kamera\Kamera.h"
 #include "../Team/Team.h"
 #include "../Karte/Strukturen.h"
@@ -74,8 +75,13 @@ private:
 	int tode;
 	double zeitAmLeben;
 	double zeitTod;
+    Textur2D *flammenM;
+    Textur2D *flammenL;
+    Textur2D *flammenR;
 	// Namen Anzeige
-	TextFeld *nText;
+    TextFeld *nText;
+
+    double calculateLaserCost();
 
 public:
 	// Konstruktor
@@ -83,7 +89,7 @@ public:
 	// Destruktor
 	~Spieler();
 	// nicht constant
-	void setModelData( Model2DData *data );
+	void setModelData( Model2DData *data, Animation2DData *zFStart, Animation2DData *zFBurn );
 	void setAccountId( int accId );
 	void setTeam( Team *team );
 	void setSpielerFarbe( int fc, Bild *zTextur );