Editor Funktionen für Skill Startwerte hinzugefügt

Asteroids/Asteroids.vcxproj

@@ -170,18 +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\Interface\RightTools\RightTools.h" />
+    <ClInclude Include="Editor\Interface\RightTools\SpielerOptionen\SpielerOptionen.h" />
+    <ClInclude Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.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" />
     <ClInclude Include="Initialisierung\Initialisierung.h" />
     <ClInclude Include="SpielStatistik\Chat\StatistikChat.h" />
@@ -199,22 +197,23 @@
     <ClInclude Include="Spiel\Objekt\SpielObjekt.h" />
     <ClInclude Include="Spiel\Schuss\Laser.h" />
     <ClInclude Include="Spiel\SpielerGUI\SpielerGUI.h" />
+    <ClInclude Include="Spiel\Spieler\DeadPlayer.h" />
     <ClInclude Include="Spiel\Spieler\Spieler.h" />
     <ClInclude Include="Spiel\SpielKlasse.h" />
     <ClInclude Include="Spiel\Team\Team.h" />
   </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\Interface\RightTools\RightTools.cpp" />
+    <ClCompile Include="Editor\Interface\RightTools\SpielerOptionen\SpielerOptionen.cpp" />
+    <ClCompile Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.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" />
     <ClCompile Include="Initialisierung\Initialisierung.cpp" />
     <ClCompile Include="SpielStatistik\Chat\StatistikChat.cpp" />
@@ -229,6 +228,7 @@
     <ClCompile Include="Spiel\Objekt\SpielObjekt.cpp" />
     <ClCompile Include="Spiel\Schuss\Laser.cpp" />
     <ClCompile Include="Spiel\SpielerGUI\SpielerGUI.cpp" />
+    <ClCompile Include="Spiel\Spieler\DeadPlayer.cpp" />
     <ClCompile Include="Spiel\Spieler\Spieler.cpp" />
     <ClCompile Include="Spiel\SpielKlasse.cpp" />
     <ClCompile Include="Spiel\Team\Team.cpp" />

Asteroids/Asteroids.vcxproj.filters

@@ -78,9 +78,6 @@
     <ClInclude Include="Aufzeichnung\Aufzeichnung.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Editor\Prozess.h">
-      <Filter>Headerdateien</Filter>
-    </ClInclude>
     <ClInclude Include="Editor\Interface\Interface.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
@@ -96,22 +93,22 @@
     <ClInclude Include="Editor\Interface\Dialogs\Nachricht.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Editor\ActionThread.h">
+    <ClInclude Include="Editor\Karte\EditorKarte.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Editor\Karte\Objekt\MapObjekt.h">
+    <ClInclude Include="Spiel\SpielerGUI\SpielerGUI.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Editor\Karte\Objekt\Spawnpunkt\Spawnpunkt.h">
+    <ClInclude Include="Spiel\Spieler\DeadPlayer.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Editor\Karte\Objekt\GameObject\GameObjekt.h">
+    <ClInclude Include="Editor\Interface\RightTools\SpielerOptionen\SpielerOptionen.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Editor\Karte\EditorKarte.h">
+    <ClInclude Include="Editor\Interface\RightTools\RightTools.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
-    <ClInclude Include="Spiel\SpielerGUI\SpielerGUI.h">
+    <ClInclude Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
   </ItemGroup>
@@ -176,9 +173,6 @@
     <ClCompile Include="Aufzeichnung\Aufzeichnung.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Editor\Prozess.cpp">
-      <Filter>Quelldateien</Filter>
-    </ClCompile>
     <ClCompile Include="Editor\Interface\Interface.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
@@ -194,16 +188,22 @@
     <ClCompile Include="Editor\Interface\Dialogs\Frage.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Editor\ActionThread.cpp">
+    <ClCompile Include="Editor\Karte\EditorKarte.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Editor\Karte\Objekt\MapObjekt.cpp">
+    <ClCompile Include="Spiel\SpielerGUI\SpielerGUI.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Editor\Karte\EditorKarte.cpp">
+    <ClCompile Include="Spiel\Spieler\DeadPlayer.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="Spiel\SpielerGUI\SpielerGUI.cpp">
+    <ClCompile Include="Editor\Interface\RightTools\SpielerOptionen\SpielerOptionen.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\RightTools\RightTools.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
   </ItemGroup>

Asteroids/Editor/ActionThread.cpp

@@ -1,21 +0,0 @@
-#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

@@ -1,22 +0,0 @@
-#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,12 +1,15 @@
 #include "Editor.h"
-#include "ActionThread.h"
+#include <AsynchronCall.h>
 #include "Interface\Dialogs\Frage.h"
 #include "Interface\Dialogs\Nachricht.h"
 #include <iostream>
+#include <Bild.h>
+
+using namespace Editor;
 
 // Inhalt der Editor Klasse aus Editor.h
 // Konstruktor
-Editor::Editor()
+AsteroidsEditor::AsteroidsEditor()
 {
     schrift = 0;
     klient = 0;
@@ -15,13 +18,17 @@ Editor::Editor()
     alpha = 0;
     status = START;
     dialogs = new Array< Dialog* >();
+    sts = 0;
     rend = 1;
+    daten = 0;
     ref = 1;
 }
 
 // Destruktor
-Editor::~Editor()
+AsteroidsEditor::~AsteroidsEditor()
 {
+    if( sts )
+        sts->release();
     if( schrift )
         schrift->release();
     if( klient )
@@ -30,10 +37,25 @@ Editor::~Editor()
         laden->release();
     if( i )
         i->release();
+    if( daten )
+        daten->release();
+    dialogs->release();
+}
+
+void AsteroidsEditor::ladeKarte()
+{
+    if( sts )
+        sts = (SpielerTeamStruktur*)sts->release();
+    sts = new SpielerTeamStruktur();
+    klient->getSpielerTeamStruktur( sts );
+    if( daten )
+        daten->release();
+    daten = new KarteDaten( klient->getThis() );
+    i->setDaten( daten->getThis() );
 }
 
 // nicht constant
-void Editor::addDialog( Dialog *d )
+void AsteroidsEditor::addDialog( Dialog *d )
 {
     c.lock();
     dialogs->add( d );
@@ -41,87 +63,157 @@ void Editor::addDialog( Dialog *d )
 }
 
 // nicht constant
-void Editor::setSchrift( Schrift *schrift )
+void AsteroidsEditor::setSchrift( Schrift *schrift )
 {
     if( this->schrift )
         this->schrift->release();
     this->schrift = schrift;
-    if( !i )
-        i = new Interface( schrift );
+    if( !i && windowSize != Punkt() )
+        i = new Interface( schrift, windowSize );
 }
 
-void Editor::setKlient( KSGClient::EditorServerClient *ekv )
+void AsteroidsEditor::setKlient( KSGClient::EditorServerClient *ekv )
 {
     if( klient )
         klient->release();
     klient = new EditorKlient( ekv );
 }
 
-void Editor::setLadeAnimation( Animation2D *la )
+void AsteroidsEditor::setLadeAnimation( Animation2D *la )
 {
     if( laden )
         laden->release();
     laden = la;
 }
 
-void Editor::setSichtbar()
+void AsteroidsEditor::setSichtbar()
 {
     status = START;
     EditorKlient *k = klient->getThis();
     Schrift *zS = schrift->getThis();
     Punkt mS = windowSize;
-    new ActionThread( [ this, k, zS, mS ] (void) -> void
+    if( windowSize != Punkt() )
     {
-        int ret = k->init();
-        if( ret == 2 )
+        new AsynchronCall( [ this, k, zS, mS ]( void ) -> void
         {
-            std::function< void() > wiederherstellen = [ k ]
+            int ret = k->init();
+            if( ret == 2 )
             {
-                // TODO Karte herunterladen und anzeigen
-            };
-            std::function< void() > verwerfen = [ this, k, zS, mS ]
-            {
-                if( !k->sitzungVerwerfen() )
+                std::function< void() > wiederherstellen = [ this, k ]
                 {
-                    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 ) );
+                    status = START;
+                    ladeKarte();
+                    this->status = INITIALIZED;
+                };
+                std::function< void() > verwerfen = [ this, k, zS, mS ]
+                {
+                    status = START;
+                    if( !k->sitzungVerwerfen() )
+                    {
+                        Text t = "Fehler beim verwerfen der Sitzung: ";
+                        t += k->getLastError();
+                        this->addDialog( new Nachricht( zS, t, mS, 0 ) );
+                    }
+                    ladeKarte();
+                    this->status = INITIALIZED;
+                };
+                this->addDialog( new Frage( zS, "Es wurde eine alte ungespeicherte Sitzung gefunden. möchtest du sie Wiederherstellen?", "Ja", "Nein", wiederherstellen, verwerfen, verwerfen, mS ) );
+                this->status = INITIALIZED;
+            }
+            else if( ret == 1 )
+            {
+                ladeKarte();
+                this->status = INITIALIZED;
+            }
+            else
+            {
+                Status *st = &status;
+                this->status = INITIALIZED;
+                this->addDialog( new Nachricht( zS, Text( "Fehler beim Initialisieren: " ) += k->getLastError(), mS, [ st ]() { *st = EXIT; } ) );
+            }
             zS->release();
             k->release();
-        }
-    } );
+        } );
+    }
     rend = 1;
 }
 
-void Editor::doMausEreignis( MausEreignis &me )
+void AsteroidsEditor::doMausEreignis( MausEreignis &me )
 {
     c.lock();
     for( auto i = dialogs->getArray(); i.set && i.var; i++ )
         i.var->doMausEreignis( me );
     bool dialogActive = dialogs->hat( 0 );
+    int anz = dialogs->getEintragAnzahl();
     c.unlock();
-    i->doMausEreignis( me );
-    if( i->hatVerlassen() && status == INITIALIZED && !dialogActive )
+    if( anz == 0 )
     {
-        status = EXIT;
+        i->doMausEreignis( me );
+        if( i->hatVerlassen() && status == INITIALIZED && !dialogActive && me.id == ME_RLinks )
+        {
+            status = WARTEND;
+            EditorKlient *k = klient->getThis();
+            Schrift *zS = schrift->getThis();
+            Punkt mS = windowSize;
+            new AsynchronCall( [ this, k, zS, mS ]( void ) -> void
+            {
+                if( !k->sitzungBeenden() )
+                {
+                    this->addDialog( new Nachricht( zS, Text( "Fehler beim Speichern: " ) += k->getLastError(), mS, 0 ) );
+                    status = INITIALIZED;
+                }
+                else
+                    status = EXIT;
+                zS->release();
+                k->release();
+            } );
+        }
     }
 }
 
-void Editor::doTastaturEreignis( TastaturEreignis &te )
+void AsteroidsEditor::doTastaturEreignis( TastaturEreignis &te )
 {
     c.lock();
     for( auto i = dialogs->getArray(); i.set && i.var; i++ )
         i.var->doTastaturEreignis( te );
+    int anz = dialogs->getEintragAnzahl();
     c.unlock();
-    i->doTastaturEreignis( te );
+    if( anz == 0 )
+        i->doTastaturEreignis( te );
 }
 
-bool Editor::tick( double z )
+bool AsteroidsEditor::tick( double z )
 {
+    if( ( status == WARTEND || status == START || ( daten && daten->hasAktions() ) ) && alpha != 100 )
+    {
+        if( laden && !laden->istSichtbar() )
+            laden->setSichtbar( 1 );
+        if( alpha < 100 )
+        {
+            alpha += (unsigned char)( 100 * z );
+            if( alpha > 100 )
+                alpha = 100;
+        }
+        else
+        {
+            alpha -= (unsigned char)( 100 * z );
+            if( alpha < 100 )
+                alpha = 100;
+        }
+        rend = 1;
+    }
+    else if( alpha != 255 )
+    {
+        if( laden && laden->istSichtbar() )
+            laden->setSichtbar( 0 );
+        if( alpha + 100 * z > 255 )
+            alpha = 255;
+        else
+            alpha += (unsigned char)( 100 * z );
+        rend = 1;
+    }
+    if( laden )
+        rend |= laden->tick( z );
     rend |= i->tick( z );
     c.lock();
     for( auto i = dialogs->getArray(); i.set && i.var; i++ )
@@ -132,8 +224,17 @@ bool Editor::tick( double z )
     return tmp;
 }
 
-void Editor::render( Bild &zRObj )
+void AsteroidsEditor::render( Bild &zRObj )
 {
+    if( windowSize == Punkt() )
+    {
+        if( status != EXIT )
+            windowSize = zRObj.getSize();
+        setSichtbar();
+        if( !i && schrift )
+            i = new Interface( schrift, windowSize );
+    }
+    zRObj.setAlpha( alpha );
     i->render( zRObj );
     c.lock();
     for( int i = dialogs->getEintragAnzahl() - 1; i >= 0; i-- )
@@ -146,22 +247,25 @@ void Editor::render( Bild &zRObj )
         }
     }
     c.unlock();
+    zRObj.releaseAlpha();
+    if( laden )
+        laden->render( zRObj );
 }
 
 // constant
-bool Editor::hatVerlassen( bool jetzt ) const
+bool AsteroidsEditor::hatVerlassen( bool jetzt ) const
 {
     return status == EXIT;
 }
 
 // Reference Counting
-EditorV *Editor::getThis()
+EditorV *AsteroidsEditor::getThis()
 {
     ref++;
     return this;
 }
 
-EditorV *Editor::release()
+EditorV *AsteroidsEditor::release()
 {
     ref--;
     if( !ref )

Asteroids/Editor/Editor.h

@@ -5,50 +5,58 @@
 #include "Interface\Interface.h"
 #include "Netzwerk\EditorKlient.h"
 #include "Interface\Dialogs\Dialog.h"
+#include "Karte\EditorKarte.h"
 
-class Editor : public EditorV
+namespace Editor
 {
-private:
-    enum Status
+    class AsteroidsEditor : public EditorV
     {
-        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 rend;
-	int ref;
+    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;
+        SpielerTeamStruktur *sts;
+        KarteDaten *daten;
+        unsigned char alpha;
+        bool rend;
+        int ref;
+
+        void ladeKarte();
 
-public:
-	// Konstruktor
-	Editor();
-	// Destruktor
-	~Editor();
-	// nicht constant
-    void addDialog( Dialog *d );
-	void setSchrift( Schrift *schrift ) override;
-	void setKlient( KSGClient::EditorServerClient *ekv ) override;
-    void setLadeAnimation( Animation2D *la ) override;
-	void setSichtbar() override;
-	void doMausEreignis( MausEreignis &me ) override;
-	void doTastaturEreignis( TastaturEreignis &te ) override;
-	bool tick( double z ) override;
-	void render( Bild &zRObj ) override;
-	// constant
-	bool hatVerlassen( bool jetzt ) const override;
-	// Reference Counting
-	EditorV *getThis() override;
-	EditorV *release() override;
-};
+    public:
+        // Konstruktor
+        AsteroidsEditor();
+        // Destruktor
+        ~AsteroidsEditor();
+        // nicht constant
+        void addDialog( Dialog *d );
+        void setSchrift( Schrift *schrift ) override;
+        void setKlient( KSGClient::EditorServerClient *ekv ) override;
+        void setLadeAnimation( Animation2D *la ) override;
+        void setSichtbar() override;
+        void doMausEreignis( MausEreignis &me ) override;
+        void doTastaturEreignis( TastaturEreignis &te ) override;
+        bool tick( double z ) override;
+        void render( Bild &zRObj ) override;
+        // constant
+        bool hatVerlassen( bool jetzt ) const override;
+        // Reference Counting
+        EditorV *getThis() override;
+        EditorV *release() override;
+    };
+}
 
 #endif

Asteroids/Editor/Interface/Dialogs/Frage.cpp

@@ -22,13 +22,16 @@ Frage::Frage( Schrift *zS, char *frage, char *left, char *right, std::function<
     int br = zS->getTextBreite( tmp );
     int hö = zS->getTextHeight( tmp );
     zS->unlock();
-    setSize( br + 12, hö + 58 );
+    setSize( br + 12, hö + 63 );
     setPosition( maxSize / 2 - getSize() / 2 );
     
     this->text = initTextFeld( 5, 5, br, hö, zS, TextFeld::Style::Text, tmp->getText() );
+    addMember( text );
     tmp->release();
     this->right = initKnopf( br - 94, hö + 22, 100, 20, zS, Knopf::Style::Normal, right );
+    addMember( this->right );
     this->left = initKnopf( br - 199, hö + 22, 100, 20, zS, Knopf::Style::Normal, left );
+    addMember( this->left );
 
     bool *verl = &verlassen;
 

Asteroids/Editor/Interface/Dialogs/Nachricht.cpp

@@ -12,7 +12,7 @@
 //  zS: Die zu verwendende Schrift
 //  nachricht: Der Fehler, der angezeigt werden soll
 //  maxSize: Die Bildschirmgröße in Pixeln
-Nachricht::Nachricht( Schrift *zS, char *nachricht, Punkt maxSize )
+Nachricht::Nachricht( Schrift *zS, char *nachricht, Punkt maxSize, std::function< void() > onClose )
     : Dialog( zS )
 {
     Text *tmp = new Text( nachricht );
@@ -22,19 +22,24 @@ Nachricht::Nachricht( Schrift *zS, char *nachricht, Punkt maxSize )
     int br = zS->getTextBreite( tmp );
     int hö = zS->getTextHeight( tmp );
     zS->unlock();
-    setSize( br + 12, hö + 58 );
+    setSize( br + 12, hö + 63 );
     setPosition( maxSize / 2 - getSize() / 2 );
 
     this->text = initTextFeld( 5, 5, br, hö, zS, TextFeld::Style::Text, tmp->getText() );
+    addMember( text );
     tmp->release();
-    ok = initKnopf( br - 94, hö + 22, 100, 20, zS, Knopf::Style::Normal, "Ok" );
-
+    ok = initKnopf( br - 94, hö + 12, 100, 20, zS, Knopf::Style::Normal, "Ok" );
+    addMember( ok );
     bool *verl = &verlassen;
 
-    auto me = [ verl ]( void *param, void *obj, MausEreignis me ) -> bool
+    auto me = [ verl, onClose ]( void *param, void *obj, MausEreignis me ) -> bool
     {
         if( me.id == ME_RLinks && !me.verarbeitet )
+        {
             *verl = 1;
+            if( onClose )
+                onClose();
+        }
         return 1;
     };
 

Asteroids/Editor/Interface/Dialogs/Nachricht.h

@@ -16,7 +16,7 @@ public:
     //  zS: Die zu verwendende Schrift
     //  nachricht: Der Fehler, der angezeigt werden soll
     //  maxSize: Die Bildschirmgröße in Pixeln
-    Nachricht( Schrift *zS, char *nachricht, Punkt maxSize );
+    Nachricht( Schrift *zS, char *nachricht, Punkt maxSize, std::function< void() > onClose );
     // Destruktor
     ~Nachricht();
 };

Asteroids/Editor/Interface/Interface.cpp

@@ -1,21 +1,41 @@
 #include "Interface.h"
 #include "../../Initialisierung/Initialisierung.h"
+#include "RightTools\SpielerOptionen\SpielerOptionen.h"
+#include "RightTools\TeamOptionen\TeamOptionen.h"
 #include <MausEreignis.h>
 
+using namespace Editor;
+
 // Inhalt der Interface Klasse aus Interface.h
 // Konstruktor
 //  zS: Ein Zeiger auf die zu verwendende Schrift
-Interface::Interface( Schrift *zS )
+Interface::Interface( Schrift *zS, Punkt maxSize )
 {
     beenden = initKnopf( 10, 10, 100, 20, zS, Knopf::Style::Normal, "beenden" );
+    right = new RightTools( zS, maxSize );
     verlassen = 0;
+    schrift = zS->getThis();
+    daten = 0;
     ref = 1;
 }
 
 // Destruktor
 Interface::~Interface()
 {
+    if( daten )
+        daten->release();
+    schrift->release();
     beenden->release();
+    right->release();
+}
+
+void Interface::setDaten( KarteDaten *daten )
+{
+    if( this->daten )
+        this->daten->release();
+    this->daten = daten;
+    right->addTool( new SpielerTool( schrift, daten->getThis() ), "Spieler" );
+    right->addTool( new TeamTool( schrift, daten->getThis() ), "Teams" );
 }
 
 // Verarbeitet eine Mausnachricht
@@ -28,6 +48,21 @@ void Interface::doMausEreignis( MausEreignis &me )
     {
         verlassen = 1;
     }
+    right->doMausEreignis( me );
+}
+
+// Verarbeitet eine Tastaturnachricht
+//  te: Die Nachricht die verarbeitet werden soll
+void Interface::doTastaturEreignis( TastaturEreignis &te )
+{
+    right->doTastaturEreignis( te );
+}
+
+bool Interface::tick( double time )
+{
+    rend |= beenden->tick( time );
+    rend |= right->tick( time );
+    return __super::tick( time );
 }
 
 // Zeichnet das Interface nach uRObj
@@ -35,6 +70,7 @@ void Interface::doMausEreignis( MausEreignis &me )
 void Interface::render( Bild &zRObj )
 {
     beenden->render( zRObj );
+    right->render( zRObj );
 }
 
 // Setzt das Interface in den Initialisierungszustand zurück

Asteroids/Editor/Interface/Interface.h

@@ -2,36 +2,49 @@
 
 #include <Fenster.h>
 #include <Knopf.h>
+#include "RightTools\RightTools.h"
+#include "../Karte/EditorKarte.h"
 
 using namespace Framework;
 
-class Interface : public ZeichnungHintergrund
+namespace Editor
 {
-private:
-    Knopf *beenden;
-    bool verlassen;
-    int ref;
+    class Interface : public ZeichnungHintergrund
+    {
+    private:
+        Knopf * beenden;
+        RightTools *right;
+        KarteDaten *daten;
+        Schrift *schrift;
+        bool verlassen;
+        int ref;
 
-public:
-    // Konstruktor
-    //  zS: Ein Zeiger auf die zu verwendende Schrift
-    Interface( Schrift *zS );
-    // Destruktor
-    ~Interface();
-    // Verarbeitet eine Mausnachricht
-    //  me: Die Nachricht die verarbeitet werden soll
-    void doMausEreignis( MausEreignis &me ) override;
-    // Zeichnet das Interface nach uRObj
-    //  zRObj: Das Bild in das gezeichnet werden soll
-    void render( Bild &zRObj ) override;
-    // Setzt das Interface in den Initialisierungszustand zurück
-    void reset();
-    // Gibt zurück, ob der Benutzer den Editor verlassen möchte
-    bool hatVerlassen() const;
-    // erhöht den Reference Counter
-    //  return: this
-    Interface *getThis();
-    // verringert den Reference Counter und löscht das Objekt wenn es nicht mehr gebraucht wird.
-    //  return: 0
-    Interface *release();
-};
+    public:
+        // Konstruktor
+        //  zS: Ein Zeiger auf die zu verwendende Schrift
+        Interface( Schrift *zS, Punkt maxSize );
+        // Destruktor
+        ~Interface();
+        void setDaten( KarteDaten *daten );
+        // Verarbeitet eine Mausnachricht
+        //  me: Die Nachricht die verarbeitet werden soll
+        void doMausEreignis( MausEreignis &me ) override;
+        // Verarbeitet eine Tastaturnachricht
+        //  te: Die Nachricht die verarbeitet werden soll
+        void doTastaturEreignis( TastaturEreignis &te ) override;
+        bool tick( double time ) override;
+        // Zeichnet das Interface nach uRObj
+        //  zRObj: Das Bild in das gezeichnet werden soll
+        void render( Bild &zRObj ) override;
+        // Setzt das Interface in den Initialisierungszustand zurück
+        void reset();
+        // Gibt zurück, ob der Benutzer den Editor verlassen möchte
+        bool hatVerlassen() const;
+        // erhöht den Reference Counter
+        //  return: this
+        Interface *getThis();
+        // verringert den Reference Counter und löscht das Objekt wenn es nicht mehr gebraucht wird.
+        //  return: 0
+        Interface *release();
+    };
+}

Asteroids/Editor/Interface/RightTools/RightTools.cpp

@@ -0,0 +1,118 @@
+#include "RightTools.h"
+#include "../../../Initialisierung/Initialisierung.h"
+
+
+RightTool::RightTool()
+    : Zeichnung()
+{
+    ref = 1;
+}
+
+RightTool::~RightTool()
+{}
+
+RightTool *RightTool::getThis()
+{
+    ref++;
+    return this;
+}
+
+RightTool *RightTool::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+RightTools::RightTools( Schrift *zSchrift, Punkt maxSize )
+    : ZeichnungHintergrund()
+{
+    ref = 1;
+    this->maxSize = maxSize;
+    toolAuswahl = initAuswahlBox( 5, 5, 290, 20, zSchrift, AuswahlBox::Style::Normal, {} );
+    tools = new RCArray< RightTool >();
+    setSize( 300, maxSize.y );
+    setPosition( maxSize.x - 300, 0 );
+    setStyle( ZeichnungHintergrund::Style::Sichtbar | ZeichnungHintergrund::Style::Rahmen |
+              ZeichnungHintergrund::Style::Hintergrund );
+    setHintergrundFarbe( 0xFF000000 );
+    setLinienRahmenBreite( 1 );
+    setLinienRahmenFarbe( 0xFFFFFFFF );
+}
+
+RightTools::~RightTools()
+{
+    tools->release();
+    toolAuswahl->release();
+}
+
+void RightTools::addTool( RightTool *tool, char *name )
+{
+    toolAuswahl->addEintrag( name );
+    tools->add( tool );
+    tool->setPosition( 5, 30 );
+    tool->setSize( 290, maxSize.y - 35 );
+}
+
+void RightTools::doMausEreignis( MausEreignis &me )
+{
+    me.mx -= pos.x, me.my -= pos.y;
+    toolAuswahl->doMausEreignis( me );
+    int anz = tools->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        tools->z( i )->doMausEreignis( me );
+    }
+    me.mx += pos.x, me.my += pos.y;
+}
+
+void RightTools::doTastaturEreignis( TastaturEreignis &te )
+{
+    toolAuswahl->doTastaturEreignis( te );
+    int anz = tools->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        tools->z( i )->doTastaturEreignis( te );
+    }
+}
+
+bool RightTools::tick( double tickVal )
+{
+    bool ret = __super::tick( tickVal );
+    ret |= toolAuswahl->tick( tickVal );
+    int anz = tools->getEintragAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        ret |= tools->z( i )->tick( tickVal );
+    }
+    return ret;
+}
+
+void RightTools::render( Bild &rObj )
+{
+    __super::render( rObj );
+    if( rObj.setDrawOptions( pos, gr ) )
+    {
+        toolAuswahl->render( rObj );
+        int anz = tools->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            tools->z( i )->render( rObj );
+        }
+        rObj.releaseDrawOptions();
+    }
+}
+
+RightTools *RightTools::getThis()
+{
+    ref++;
+    return this;
+}
+
+RightTools *RightTools::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Asteroids/Editor/Interface/RightTools/RightTools.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <AuswahlBox.h>
+#include "../../Netzwerk/EditorKlient.h"
+
+using namespace Framework;
+
+class RightTool : public Zeichnung
+{
+private:
+    int ref;
+
+public:
+    RightTool();
+    virtual ~RightTool();
+    RightTool *getThis();
+    RightTool *release();
+};
+
+class RightTools : public ZeichnungHintergrund
+{
+private:
+    AuswahlBox * toolAuswahl;
+    RCArray< RightTool > *tools;
+    Punkt maxSize;
+    int ref;
+
+public:
+    RightTools( Schrift *zSchrift, Punkt maxSize );
+    ~RightTools();
+    void addTool( RightTool *tool, char *name );
+    void doMausEreignis( MausEreignis &me ) override;
+    void doTastaturEreignis( TastaturEreignis &te ) override;
+    bool tick( double tickVal ) override;
+    void render( Bild &rObj ) override;
+    RightTools *getThis();
+    RightTools *release();
+};

Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.cpp

@@ -0,0 +1,241 @@
+#include "SpielerOptionen.h"
+#include "../../../../Initialisierung/Initialisierung.h"
+#include "../../../Karte/EditorKarte.h"
+
+using namespace Editor;
+
+SpielerTool::SpielerTool( Schrift *zSchrift, KarteDaten *daten )
+    : RightTool()
+{
+    int spielerAnzahl = daten->getSpielerAnzahl();
+    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal, {} );
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        spielerAuswahl->addEintrag( new Text( Text( "Spieler " ) += ( i + 1 ) ) );
+    }
+    spielerAuswahl->setEventAktion( [ this ]( void *p, AuswahlBox *a, int old, int auswahl )
+    {
+        this->selectPlayer( auswahl + 1 );
+    } );
+    skillStartT = initTextFeld( 0, 30, 290, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
+    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, zSchrift, TextFeld::Style::Text, "Stabilität" );
+    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, zSchrift, TextFeld::Style::Text, "Energie" );
+    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, zSchrift, TextFeld::Style::Text, "Reparatur" );
+    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, zSchrift, TextFeld::Style::Text, "Akku" );
+    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, zSchrift, TextFeld::Style::Text, "Wendigkeit" );
+    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, zSchrift, TextFeld::Style::Text, "Beschleunigung" );
+    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, zSchrift, TextFeld::Style::Text, "Antrieb Effizienz" );
+    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Intensität" );
+    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Effizienz" );
+    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Tempo" );
+    skillStartNetzwerkT = initTextFeld( 0, 305, 200, 20, zSchrift, TextFeld::Style::Text, "Netzwerk" );
+    const SpielerDaten *spieler = daten->getSpieler( daten->getSpielerIndexById( 1 ) );
+    skillStartStabilität = initTextFeld( 200, 55, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->maxStabilität ) );
+    skillStartEnergie = initTextFeld( 200, 80, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->maxEnergie ) );
+    skillStartReparatur = initTextFeld( 200, 105, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->reparatur ) );
+    skillStartAkku = initTextFeld( 200, 130, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->akkuLeistung ) );
+    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->wendigkeit ) );
+    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->beschleunigung ) );
+    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->antriebEffizienz ) );
+    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserIntensität ) );
+    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserEffizienz ) );
+    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->laserTempo ) );
+    skillStartNetzwerk = initTextFeld( 200, 305, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( spieler->netzwerk ) );
+    speichern = initKnopf( 0, 330, 100, 20, zSchrift, Knopf::Style::Normal, "Speichern" );
+    this->daten = daten;
+}
+
+SpielerTool::~SpielerTool()
+{
+    spielerAuswahl->release();
+    skillStartT->release();
+    skillStartStabilitätT->release();
+    skillStartEnergieT->release();
+    skillStartReparaturT->release();
+    skillStartAkkuT->release();
+    skillStartWendigkeitT->release();
+    skillStartBeschleunigungT->release();
+    skillStartAntriebEffizienzT->release();
+    skillStartLaserIntensitätT->release();
+    skillStartLaserEffizienzT->release();
+    skillStartLaserTempoT->release();
+    skillStartNetzwerkT->release();
+    skillStartStabilität->release();
+    skillStartEnergie->release();
+    skillStartReparatur->release();
+    skillStartAkku->release();
+    skillStartWendigkeit->release();
+    skillStartBeschleunigung->release();
+    skillStartAntriebEffizienz->release();
+    skillStartLaserIntensität->release();
+    skillStartLaserEffizienz->release();
+    skillStartLaserTempo->release();
+    skillStartNetzwerk->release();
+    speichern->release();
+    daten->release();
+}
+
+void SpielerTool::doMausEreignis( MausEreignis &me )
+{
+    me.mx -= pos.x;
+    me.my -= pos.y;
+    spielerAuswahl->doMausEreignis( me );
+    skillStartT->doMausEreignis( me );
+    skillStartStabilitätT->doMausEreignis( me );
+    skillStartEnergieT->doMausEreignis( me );
+    skillStartReparaturT->doMausEreignis( me );
+    skillStartAkkuT->doMausEreignis( me );
+    skillStartWendigkeitT->doMausEreignis( me );
+    skillStartBeschleunigungT->doMausEreignis( me );
+    skillStartAntriebEffizienzT->doMausEreignis( me );
+    skillStartLaserIntensitätT->doMausEreignis( me );
+    skillStartLaserEffizienzT->doMausEreignis( me );
+    skillStartLaserTempoT->doMausEreignis( me );
+    skillStartNetzwerkT->doMausEreignis( me );
+    skillStartStabilität->doMausEreignis( me );
+    skillStartEnergie->doMausEreignis( me );
+    skillStartReparatur->doMausEreignis( me );
+    skillStartAkku->doMausEreignis( me );
+    skillStartWendigkeit->doMausEreignis( me );
+    skillStartBeschleunigung->doMausEreignis( me );
+    skillStartAntriebEffizienz->doMausEreignis( me );
+    skillStartLaserIntensität->doMausEreignis( me );
+    skillStartLaserEffizienz->doMausEreignis( me );
+    skillStartLaserTempo->doMausEreignis( me );
+    skillStartNetzwerk->doMausEreignis( me );
+    bool verarbeitet = me.verarbeitet;
+    speichern->doMausEreignis( me );
+    if( !verarbeitet && me.verarbeitet && me.id == ME_RLinks )
+    {
+        SpielerDaten data = *daten->getSpieler( daten->getSpielerIndexById( spielerAuswahl->getAuswahl() + 1 ) );
+        data.maxStabilität = *skillStartStabilität->zText();
+        data.maxEnergie = *skillStartEnergie->zText();
+        data.reparatur = *skillStartReparatur->zText();
+        data.akkuLeistung = *skillStartAkku->zText();
+        data.wendigkeit = *skillStartWendigkeit->zText();
+        data.beschleunigung = *skillStartBeschleunigung->zText();
+        data.antriebEffizienz = *skillStartAntriebEffizienz->zText();
+        data.laserIntensität = *skillStartLaserIntensität->zText();
+        data.laserEffizienz = *skillStartLaserEffizienz->zText();
+        data.laserTempo = *skillStartLaserTempo->zText();
+        data.netzwerk = *skillStartNetzwerk->zText();
+        daten->getSpieler( daten->getSpielerIndexById( spielerAuswahl->getAuswahl() + 1 ), [ data ]( SpielerDaten *daten ) -> bool
+        {
+            *daten = data;
+            return 1;
+        } );
+    }
+    me.mx += pos.x;
+    me.my += pos.y;
+}
+
+void SpielerTool::doTastaturEreignis( TastaturEreignis &te )
+{
+    spielerAuswahl->doTastaturEreignis( te );
+    skillStartT->doTastaturEreignis( te );
+    skillStartStabilitätT->doTastaturEreignis( te );
+    skillStartEnergieT->doTastaturEreignis( te );
+    skillStartReparaturT->doTastaturEreignis( te );
+    skillStartAkkuT->doTastaturEreignis( te );
+    skillStartWendigkeitT->doTastaturEreignis( te );
+    skillStartBeschleunigungT->doTastaturEreignis( te );
+    skillStartAntriebEffizienzT->doTastaturEreignis( te );
+    skillStartLaserIntensitätT->doTastaturEreignis( te );
+    skillStartLaserEffizienzT->doTastaturEreignis( te );
+    skillStartLaserTempoT->doTastaturEreignis( te );
+    skillStartNetzwerkT->doTastaturEreignis( te );
+    skillStartStabilität->doTastaturEreignis( te );
+    skillStartEnergie->doTastaturEreignis( te );
+    skillStartReparatur->doTastaturEreignis( te );
+    skillStartAkku->doTastaturEreignis( te );
+    skillStartWendigkeit->doTastaturEreignis( te );
+    skillStartBeschleunigung->doTastaturEreignis( te );
+    skillStartAntriebEffizienz->doTastaturEreignis( te );
+    skillStartLaserIntensität->doTastaturEreignis( te );
+    skillStartLaserEffizienz->doTastaturEreignis( te );
+    skillStartLaserTempo->doTastaturEreignis( te );
+    skillStartNetzwerk->doTastaturEreignis( te );
+    speichern->doTastaturEreignis( te );
+}
+
+bool SpielerTool::tick( double tickVal )
+{
+    bool ret = __super::tick( tickVal );
+    ret |= spielerAuswahl->tick( tickVal );
+    ret |= skillStartT->tick( tickVal );
+    ret |= skillStartStabilitätT->tick( tickVal );
+    ret |= skillStartEnergieT->tick( tickVal );
+    ret |= skillStartReparaturT->tick( tickVal );
+    ret |= skillStartAkkuT->tick( tickVal );
+    ret |= skillStartWendigkeitT->tick( tickVal );
+    ret |= skillStartBeschleunigungT->tick( tickVal );
+    ret |= skillStartAntriebEffizienzT->tick( tickVal );
+    ret |= skillStartLaserIntensitätT->tick( tickVal );
+    ret |= skillStartLaserEffizienzT->tick( tickVal );
+    ret |= skillStartLaserTempoT->tick( tickVal );
+    ret |= skillStartNetzwerkT->tick( tickVal );
+    ret |= skillStartStabilität->tick( tickVal );
+    ret |= skillStartEnergie->tick( tickVal );
+    ret |= skillStartReparatur->tick( tickVal );
+    ret |= skillStartAkku->tick( tickVal );
+    ret |= skillStartWendigkeit->tick( tickVal );
+    ret |= skillStartBeschleunigung->tick( tickVal );
+    ret |= skillStartAntriebEffizienz->tick( tickVal );
+    ret |= skillStartLaserIntensität->tick( tickVal );
+    ret |= skillStartLaserEffizienz->tick( tickVal );
+    ret |= skillStartLaserTempo->tick( tickVal );
+    ret |= skillStartNetzwerk->tick( tickVal );
+    ret |= speichern->tick( tickVal );
+    return ret;
+}
+
+void SpielerTool::render( Bild &rObj )
+{
+    if( rObj.setDrawOptions( pos, gr ) )
+    {
+        spielerAuswahl->render( rObj );
+        skillStartT->render( rObj );
+        skillStartStabilitätT->render( rObj );
+        skillStartEnergieT->render( rObj );
+        skillStartReparaturT->render( rObj );
+        skillStartAkkuT->render( rObj );
+        skillStartWendigkeitT->render( rObj );
+        skillStartBeschleunigungT->render( rObj );
+        skillStartAntriebEffizienzT->render( rObj );
+        skillStartLaserIntensitätT->render( rObj );
+        skillStartLaserEffizienzT->render( rObj );
+        skillStartLaserTempoT->render( rObj );
+        skillStartNetzwerkT->render( rObj );
+        skillStartStabilität->render( rObj );
+        skillStartEnergie->render( rObj );
+        skillStartReparatur->render( rObj );
+        skillStartAkku->render( rObj );
+        skillStartWendigkeit->render( rObj );
+        skillStartBeschleunigung->render( rObj );
+        skillStartAntriebEffizienz->render( rObj );
+        skillStartLaserIntensität->render( rObj );
+        skillStartLaserEffizienz->render( rObj );
+        skillStartLaserTempo->render( rObj );
+        skillStartNetzwerk->render( rObj );
+        speichern->render( rObj );
+        rObj.releaseDrawOptions();
+    }
+}
+
+void SpielerTool::selectPlayer( int id )
+{
+    int index = daten->getSpielerIndexById( id );
+    spielerAuswahl->setAuswahl( id - 1 );
+    const SpielerDaten *spieler = daten->getSpieler( index );
+    skillStartStabilität->setText( Text( spieler->maxStabilität ) );
+    skillStartEnergie->setText( Text( spieler->maxEnergie ) );
+    skillStartReparatur->setText( Text( spieler->reparatur ) );
+    skillStartAkku->setText( Text( spieler->akkuLeistung ) );
+    skillStartWendigkeit->setText( Text( spieler->wendigkeit ) );
+    skillStartBeschleunigung->setText( Text( spieler->beschleunigung ) );
+    skillStartAntriebEffizienz->setText( Text( spieler->antriebEffizienz ) );
+    skillStartLaserIntensität->setText( Text( spieler->laserIntensität ) );
+    skillStartLaserEffizienz->setText( Text( spieler->laserEffizienz ) );
+    skillStartLaserTempo->setText( Text( spieler->laserTempo ) );
+    skillStartNetzwerk->setText( Text( spieler->netzwerk ) );
+}

Asteroids/Editor/Interface/RightTools/SpielerOptionen/SpielerOptionen.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "../RightTools.h"
+#include "../../../../Spiel/Karte/Strukturen.h"
+#include "../../../Karte/EditorKarte.h"
+
+namespace Editor
+{
+    class SpielerTool : public RightTool
+    {
+    private:
+        AuswahlBox * spielerAuswahl;
+        TextFeld *skillStartT;
+        TextFeld *skillStartStabilitätT;
+        TextFeld *skillStartEnergieT;
+        TextFeld *skillStartReparaturT;
+        TextFeld *skillStartAkkuT;
+        TextFeld *skillStartWendigkeitT;
+        TextFeld *skillStartBeschleunigungT;
+        TextFeld *skillStartAntriebEffizienzT;
+        TextFeld *skillStartLaserIntensitätT;
+        TextFeld *skillStartLaserEffizienzT;
+        TextFeld *skillStartLaserTempoT;
+        TextFeld *skillStartNetzwerkT;
+        TextFeld *skillStartStabilität;
+        TextFeld *skillStartEnergie;
+        TextFeld *skillStartReparatur;
+        TextFeld *skillStartAkku;
+        TextFeld *skillStartWendigkeit;
+        TextFeld *skillStartBeschleunigung;
+        TextFeld *skillStartAntriebEffizienz;
+        TextFeld *skillStartLaserIntensität;
+        TextFeld *skillStartLaserEffizienz;
+        TextFeld *skillStartLaserTempo;
+        TextFeld *skillStartNetzwerk;
+        Knopf *speichern;
+        KarteDaten *daten;
+
+    public:
+        SpielerTool( Schrift *zSchrift, KarteDaten *daten );
+        ~SpielerTool();
+        void doMausEreignis( MausEreignis &me ) override;
+        void doTastaturEreignis( TastaturEreignis &te ) override;
+        bool tick( double tickVal ) override;
+        void render( Bild &rObj ) override;
+        void selectPlayer( int id );
+    };
+}

Asteroids/Editor/Interface/RightTools/TeamOptionen/TeamOptionen.cpp

@@ -0,0 +1,227 @@
+#include "TeamOptionen.h"
+#include "../../../../Initialisierung/Initialisierung.h"
+#include "../../../Karte/EditorKarte.h"
+
+using namespace Editor;
+
+TeamTool::TeamTool( Schrift *zSchrift, KarteDaten *daten )
+    : RightTool()
+{
+    int teamAnzahl = daten->getTeamAnzahl();
+    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal, {} );
+    for( int i = 0; i < teamAnzahl; i++ )
+    {
+        teamAuswahl->addEintrag( new Text( Text( "Team " ) += ( i + 1 ) ) );
+    }
+    teamAuswahl->setEventAktion( [ this ]( void *p, AuswahlBox *a, int old, int auswahl )
+    {
+        this->selectTeam( auswahl + 1 );
+    } );
+    skillStartT = initTextFeld( 0, 30, 290, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "---Startwerte---" );
+    skillStartStabilitätT = initTextFeld( 0, 55, 200, 20, zSchrift, TextFeld::Style::Text, "Stabilität" );
+    skillStartEnergieT = initTextFeld( 0, 80, 200, 20, zSchrift, TextFeld::Style::Text, "Energie" );
+    skillStartReparaturT = initTextFeld( 0, 105, 200, 20, zSchrift, TextFeld::Style::Text, "Reparatur" );
+    skillStartAkkuT = initTextFeld( 0, 130, 200, 20, zSchrift, TextFeld::Style::Text, "Akku" );
+    skillStartWendigkeitT = initTextFeld( 0, 155, 200, 20, zSchrift, TextFeld::Style::Text, "Wendigkeit" );
+    skillStartBeschleunigungT = initTextFeld( 0, 180, 200, 20, zSchrift, TextFeld::Style::Text, "Beschleunigung" );
+    skillStartAntriebEffizienzT = initTextFeld( 0, 205, 200, 20, zSchrift, TextFeld::Style::Text, "Antrieb Effizienz" );
+    skillStartLaserIntensitätT = initTextFeld( 0, 230, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Intensität" );
+    skillStartLaserEffizienzT = initTextFeld( 0, 255, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Effizienz" );
+    skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Tempo" );
+    const TeamDaten *Team = daten->getTeam( daten->getTeamIndexById( 1 ) );
+    skillStartStabilität = initTextFeld( 200, 55, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->maxStabilität ) );
+    skillStartEnergie = initTextFeld( 200, 80, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->maxEnergie ) );
+    skillStartReparatur = initTextFeld( 200, 105, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->reparatur ) );
+    skillStartAkku = initTextFeld( 200, 130, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->akkuLeistung ) );
+    skillStartWendigkeit = initTextFeld( 200, 155, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->wendigkeit ) );
+    skillStartBeschleunigung = initTextFeld( 200, 180, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->beschleunigung ) );
+    skillStartAntriebEffizienz = initTextFeld( 200, 205, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->antriebEffizienz ) );
+    skillStartLaserIntensität = initTextFeld( 200, 230, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserIntensität ) );
+    skillStartLaserEffizienz = initTextFeld( 200, 255, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserEffizienz ) );
+    skillStartLaserTempo = initTextFeld( 200, 280, 90, 20, zSchrift, TextFeld::Style::TextFeld, Text( Team->laserTempo ) );
+    speichern = initKnopf( 0, 330, 100, 20, zSchrift, Knopf::Style::Normal, "Speichern" );
+    this->daten = daten;
+}
+
+TeamTool::~TeamTool()
+{
+    teamAuswahl->release();
+    skillStartT->release();
+    skillStartStabilitätT->release();
+    skillStartEnergieT->release();
+    skillStartReparaturT->release();
+    skillStartAkkuT->release();
+    skillStartWendigkeitT->release();
+    skillStartBeschleunigungT->release();
+    skillStartAntriebEffizienzT->release();
+    skillStartLaserIntensitätT->release();
+    skillStartLaserEffizienzT->release();
+    skillStartLaserTempoT->release();
+    skillStartStabilität->release();
+    skillStartEnergie->release();
+    skillStartReparatur->release();
+    skillStartAkku->release();
+    skillStartWendigkeit->release();
+    skillStartBeschleunigung->release();
+    skillStartAntriebEffizienz->release();
+    skillStartLaserIntensität->release();
+    skillStartLaserEffizienz->release();
+    skillStartLaserTempo->release();
+    speichern->release();
+    daten->release();
+}
+
+void TeamTool::doMausEreignis( MausEreignis &me )
+{
+    me.mx -= pos.x;
+    me.my -= pos.y;
+    teamAuswahl->doMausEreignis( me );
+    skillStartT->doMausEreignis( me );
+    skillStartStabilitätT->doMausEreignis( me );
+    skillStartEnergieT->doMausEreignis( me );
+    skillStartReparaturT->doMausEreignis( me );
+    skillStartAkkuT->doMausEreignis( me );
+    skillStartWendigkeitT->doMausEreignis( me );
+    skillStartBeschleunigungT->doMausEreignis( me );
+    skillStartAntriebEffizienzT->doMausEreignis( me );
+    skillStartLaserIntensitätT->doMausEreignis( me );
+    skillStartLaserEffizienzT->doMausEreignis( me );
+    skillStartLaserTempoT->doMausEreignis( me );
+    skillStartStabilität->doMausEreignis( me );
+    skillStartEnergie->doMausEreignis( me );
+    skillStartReparatur->doMausEreignis( me );
+    skillStartAkku->doMausEreignis( me );
+    skillStartWendigkeit->doMausEreignis( me );
+    skillStartBeschleunigung->doMausEreignis( me );
+    skillStartAntriebEffizienz->doMausEreignis( me );
+    skillStartLaserIntensität->doMausEreignis( me );
+    skillStartLaserEffizienz->doMausEreignis( me );
+    skillStartLaserTempo->doMausEreignis( me );
+    bool verarbeitet = me.verarbeitet;
+    speichern->doMausEreignis( me );
+    if( !verarbeitet && me.verarbeitet && me.id == ME_RLinks )
+    {
+        TeamDaten data = *daten->getTeam( daten->getTeamIndexById( teamAuswahl->getAuswahl() + 1 ) );
+        data.maxStabilität = *skillStartStabilität->zText();
+        data.maxEnergie = *skillStartEnergie->zText();
+        data.reparatur = *skillStartReparatur->zText();
+        data.akkuLeistung = *skillStartAkku->zText();
+        data.wendigkeit = *skillStartWendigkeit->zText();
+        data.beschleunigung = *skillStartBeschleunigung->zText();
+        data.antriebEffizienz = *skillStartAntriebEffizienz->zText();
+        data.laserIntensität = *skillStartLaserIntensität->zText();
+        data.laserEffizienz = *skillStartLaserEffizienz->zText();
+        data.laserTempo = *skillStartLaserTempo->zText();
+        daten->getTeam( daten->getTeamIndexById( teamAuswahl->getAuswahl() + 1 ), [ data ]( TeamDaten *daten ) -> bool
+        {
+            *daten = data;
+            return 1;
+        } );
+    }
+    me.mx += pos.x;
+    me.my += pos.y;
+}
+
+void TeamTool::doTastaturEreignis( TastaturEreignis &te )
+{
+    teamAuswahl->doTastaturEreignis( te );
+    skillStartT->doTastaturEreignis( te );
+    skillStartStabilitätT->doTastaturEreignis( te );
+    skillStartEnergieT->doTastaturEreignis( te );
+    skillStartReparaturT->doTastaturEreignis( te );
+    skillStartAkkuT->doTastaturEreignis( te );
+    skillStartWendigkeitT->doTastaturEreignis( te );
+    skillStartBeschleunigungT->doTastaturEreignis( te );
+    skillStartAntriebEffizienzT->doTastaturEreignis( te );
+    skillStartLaserIntensitätT->doTastaturEreignis( te );
+    skillStartLaserEffizienzT->doTastaturEreignis( te );
+    skillStartLaserTempoT->doTastaturEreignis( te );
+    skillStartStabilität->doTastaturEreignis( te );
+    skillStartEnergie->doTastaturEreignis( te );
+    skillStartReparatur->doTastaturEreignis( te );
+    skillStartAkku->doTastaturEreignis( te );
+    skillStartWendigkeit->doTastaturEreignis( te );
+    skillStartBeschleunigung->doTastaturEreignis( te );
+    skillStartAntriebEffizienz->doTastaturEreignis( te );
+    skillStartLaserIntensität->doTastaturEreignis( te );
+    skillStartLaserEffizienz->doTastaturEreignis( te );
+    skillStartLaserTempo->doTastaturEreignis( te );
+    speichern->doTastaturEreignis( te );
+}
+
+bool TeamTool::tick( double tickVal )
+{
+    bool ret = __super::tick( tickVal );
+    ret |= teamAuswahl->tick( tickVal );
+    ret |= skillStartT->tick( tickVal );
+    ret |= skillStartStabilitätT->tick( tickVal );
+    ret |= skillStartEnergieT->tick( tickVal );
+    ret |= skillStartReparaturT->tick( tickVal );
+    ret |= skillStartAkkuT->tick( tickVal );
+    ret |= skillStartWendigkeitT->tick( tickVal );
+    ret |= skillStartBeschleunigungT->tick( tickVal );
+    ret |= skillStartAntriebEffizienzT->tick( tickVal );
+    ret |= skillStartLaserIntensitätT->tick( tickVal );
+    ret |= skillStartLaserEffizienzT->tick( tickVal );
+    ret |= skillStartLaserTempoT->tick( tickVal );
+    ret |= skillStartStabilität->tick( tickVal );
+    ret |= skillStartEnergie->tick( tickVal );
+    ret |= skillStartReparatur->tick( tickVal );
+    ret |= skillStartAkku->tick( tickVal );
+    ret |= skillStartWendigkeit->tick( tickVal );
+    ret |= skillStartBeschleunigung->tick( tickVal );
+    ret |= skillStartAntriebEffizienz->tick( tickVal );
+    ret |= skillStartLaserIntensität->tick( tickVal );
+    ret |= skillStartLaserEffizienz->tick( tickVal );
+    ret |= skillStartLaserTempo->tick( tickVal );
+    ret |= speichern->tick( tickVal );
+    return ret;
+}
+
+void TeamTool::render( Bild &rObj )
+{
+    if( rObj.setDrawOptions( pos, gr ) )
+    {
+        teamAuswahl->render( rObj );
+        skillStartT->render( rObj );
+        skillStartStabilitätT->render( rObj );
+        skillStartEnergieT->render( rObj );
+        skillStartReparaturT->render( rObj );
+        skillStartAkkuT->render( rObj );
+        skillStartWendigkeitT->render( rObj );
+        skillStartBeschleunigungT->render( rObj );
+        skillStartAntriebEffizienzT->render( rObj );
+        skillStartLaserIntensitätT->render( rObj );
+        skillStartLaserEffizienzT->render( rObj );
+        skillStartLaserTempoT->render( rObj );
+        skillStartStabilität->render( rObj );
+        skillStartEnergie->render( rObj );
+        skillStartReparatur->render( rObj );
+        skillStartAkku->render( rObj );
+        skillStartWendigkeit->render( rObj );
+        skillStartBeschleunigung->render( rObj );
+        skillStartAntriebEffizienz->render( rObj );
+        skillStartLaserIntensität->render( rObj );
+        skillStartLaserEffizienz->render( rObj );
+        skillStartLaserTempo->render( rObj );
+        speichern->render( rObj );
+        rObj.releaseDrawOptions();
+    }
+}
+
+void TeamTool::selectTeam( int id )
+{
+    int index = daten->getTeamIndexById( id );
+    teamAuswahl->setAuswahl( id - 1 );
+    const TeamDaten *Team = daten->getTeam( index );
+    skillStartStabilität->setText( Text( Team->maxStabilität ) );
+    skillStartEnergie->setText( Text( Team->maxEnergie ) );
+    skillStartReparatur->setText( Text( Team->reparatur ) );
+    skillStartAkku->setText( Text( Team->akkuLeistung ) );
+    skillStartWendigkeit->setText( Text( Team->wendigkeit ) );
+    skillStartBeschleunigung->setText( Text( Team->beschleunigung ) );
+    skillStartAntriebEffizienz->setText( Text( Team->antriebEffizienz ) );
+    skillStartLaserIntensität->setText( Text( Team->laserIntensität ) );
+    skillStartLaserEffizienz->setText( Text( Team->laserEffizienz ) );
+    skillStartLaserTempo->setText( Text( Team->laserTempo ) );
+}

Asteroids/Editor/Interface/RightTools/TeamOptionen/TeamOptionen.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "../RightTools.h"
+#include "../../../../Spiel/Karte/Strukturen.h"
+#include "../../../Karte/EditorKarte.h"
+
+namespace Editor
+{
+    class TeamTool : public RightTool
+    {
+    private:
+        AuswahlBox * teamAuswahl;
+        TextFeld *skillStartT;
+        TextFeld *skillStartStabilitätT;
+        TextFeld *skillStartEnergieT;
+        TextFeld *skillStartReparaturT;
+        TextFeld *skillStartAkkuT;
+        TextFeld *skillStartWendigkeitT;
+        TextFeld *skillStartBeschleunigungT;
+        TextFeld *skillStartAntriebEffizienzT;
+        TextFeld *skillStartLaserIntensitätT;
+        TextFeld *skillStartLaserEffizienzT;
+        TextFeld *skillStartLaserTempoT;
+        TextFeld *skillStartStabilität;
+        TextFeld *skillStartEnergie;
+        TextFeld *skillStartReparatur;
+        TextFeld *skillStartAkku;
+        TextFeld *skillStartWendigkeit;
+        TextFeld *skillStartBeschleunigung;
+        TextFeld *skillStartAntriebEffizienz;
+        TextFeld *skillStartLaserIntensität;
+        TextFeld *skillStartLaserEffizienz;
+        TextFeld *skillStartLaserTempo;
+        Knopf *speichern;
+        KarteDaten *daten;
+
+    public:
+        TeamTool( Schrift *zSchrift, KarteDaten *daten );
+        ~TeamTool();
+        void doMausEreignis( MausEreignis &me ) override;
+        void doTastaturEreignis( TastaturEreignis &te ) override;
+        bool tick( double tickVal ) override;
+        void render( Bild &rObj ) override;
+        void selectTeam( int id );
+    };
+}

Asteroids/Editor/Karte/EditorKarte.cpp

@@ -0,0 +1,220 @@
+#include "EditorKarte.h"
+
+using namespace Editor;
+
+KarteDaten::KarteDaten( EditorKlient *client )
+{
+    this->client = client;
+    sts = new SpielerTeamStruktur();
+    client->loadSpieler( spieler );
+    client->loadTeams( teams );
+    client->loadObjekte( objekte );
+    exit = 0;
+    ref = 1;
+    start();
+}
+
+KarteDaten::~KarteDaten()
+{
+    exit = 1;
+    if( isRunning() )
+        warteAufThread( INT_MAX );
+    cs.lock();
+    for( auto i = objekte.getArray(); i.set; i++ )
+        delete i.var;
+    for( auto i = spieler.getArray(); i.set; i++ )
+        delete i.var;
+    for( auto i = teams.getArray(); i.set; i++ )
+        delete i.var;
+    sts->release();
+    client->release();
+}
+
+void KarteDaten::addObjekt( ObjektDaten &daten )
+{
+    ObjektDaten *nd = new ObjektDaten( daten );
+    cs.lock();
+    nd->id = objekte.getEintragAnzahl();
+    objekte.add( nd );
+    ObjektDaten td = *nd;
+    EditorKlient *c = client;
+    aktionen.add( [ td, c ]()
+    {
+        c->saveObjekt( &td );
+    } );
+    cs.unlock();
+}
+
+void KarteDaten::removeObjekt( int index )
+{
+    cs.lock();
+    int id = objekte.get( index )->id;
+    delete objekte.get( index );
+    objekte.remove( index );
+    EditorKlient *c = client;
+    aktionen.add( [ id, c ]()
+    {
+        c->deleteObjekt( id );
+    } );
+    cs.unlock();
+}
+
+void KarteDaten::getObjekt( int index, std::function< bool( ObjektDaten* ) > callBack )
+{
+    cs.lock();
+    if( callBack( objekte.get( index ) ) )
+    {
+        ObjektDaten td = *objekte.get( index );
+        EditorKlient *c = client;
+        aktionen.add( [ td, c ]()
+        {
+            c->saveObjekt( &td );
+        } );
+    }
+    cs.unlock();
+}
+
+void KarteDaten::getSpieler( int index, std::function< bool( SpielerDaten* ) > callBack )
+{
+    cs.lock();
+    if( callBack( spieler.get( index ) ) )
+    {
+        SpielerDaten td = *spieler.get( index );
+        EditorKlient *c = client;
+        aktionen.add( [ td, c ]()
+        {
+            c->saveSpieler( &td );
+        } );
+    }
+    cs.unlock();
+}
+
+void KarteDaten::getTeam( int index, std::function< bool( TeamDaten* ) > callBack )
+{
+    cs.lock();
+    if( callBack( teams.get( index ) ) )
+    {
+        TeamDaten td = *teams.get( index );
+        EditorKlient *c = client;
+        aktionen.add( [ td, c ](){
+            c->saveTeam( &td );
+        } );
+    }
+    cs.unlock();
+}
+
+void KarteDaten::thread()
+{
+    while( !exit )
+    {
+        cs.lock();
+        while( hasAktions() )
+        {
+            std::function< void() > ak = aktionen.get( 0 );
+            cs.unlock();
+            ak();
+            cs.lock();
+            aktionen.remove( 0 );
+        }
+        cs.unlock();
+        Sleep( 100 );
+    }
+}
+
+const ObjektDaten *KarteDaten::getObjekt( int index )
+{
+    ObjektDaten *ret = 0;
+    cs.lock();
+    ret = objekte.get( index );
+    cs.unlock();
+    return ret;
+}
+
+const SpielerDaten *KarteDaten::getSpieler( int index )
+{
+    SpielerDaten *ret = 0;
+    cs.lock();
+    ret = spieler.get( index );
+    cs.unlock();
+    return ret;
+}
+
+const TeamDaten *KarteDaten::getTeam( int index )
+{
+    TeamDaten *ret = 0;
+    cs.lock();
+    ret = teams.get( index );
+    cs.unlock();
+    return ret;
+}
+
+int KarteDaten::getSpielerIndexById( int id )
+{
+    int index = 0;
+    cs.lock();
+    for( auto i = spieler.getArray(); i.set; i++ )
+    {
+        if( i.var->id == id )
+            break;
+        index++;
+    }
+    cs.unlock();
+    return index;
+}
+
+int KarteDaten::getSpielerAnzahl() const
+{
+    return spieler.getEintragAnzahl();
+}
+
+int KarteDaten::getTeamIndexById( int id )
+{
+    int index = 0;
+    cs.lock();
+    for( auto i = teams.getArray(); i.set; i++ )
+    {
+        if( i.var->id == id )
+            break;
+        index++;
+    }
+    cs.unlock();
+    return index;
+}
+
+int KarteDaten::getTeamAnzahl() const
+{
+    return teams.getEintragAnzahl();
+}
+
+int KarteDaten::getObjektAnzahl() const
+{
+    return objekte.getEintragAnzahl();
+}
+
+bool KarteDaten::hasError() const
+{
+    return !error.istGleich( "" );
+}
+
+char *KarteDaten::getError() const
+{
+    return error;
+}
+
+bool KarteDaten::hasAktions() const
+{
+    return aktionen.getEintragAnzahl() > 0;
+}
+
+KarteDaten *KarteDaten::getThis()
+{
+    ref++;
+    return this;
+}
+
+KarteDaten *KarteDaten::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Asteroids/Editor/Karte/EditorKarte.h

@@ -1,8 +1,100 @@
 #pragma once
 
-#include "Objekt\Objekt.h"
+#include "../Netzwerk/EditorKlient.h"
+#include <Punkt.h>
+#include <Critical.h>
+#include <functional>
 
-class Karte
+namespace Editor
 {
+    struct SpielerDaten
+    {
+        int id;
+        Punkt pos;
+        double rot;
+        double beschleunigung;
+        int maxStabilität;
+        int maxEnergie;
+        double reparatur;
+        double akkuLeistung;
+        int laserIntensität;
+        int laserEffizienz;
+        int laserTempo;
+        double wendigkeit;
+        double antriebEffizienz;
+        int netzwerk;
+        int skillPunkte;
+        int m2d;
+        int bild;
+    };
 
-};
+    struct TeamDaten
+    {
+        int id;
+        int maxPunkte;
+        double beschleunigung;
+        int maxStabilität;
+        int maxEnergie;
+        double reparatur;
+        double akkuLeistung;
+        int laserIntensität;
+        int laserEffizienz;
+        int laserTempo;
+        double wendigkeit;
+        double antriebEffizienz;
+        int punkte;
+    };
+
+    struct ObjektDaten
+    {
+        Punkt pos;
+        int id;
+        int m2d;
+        int bild;
+        int style;
+        int maxStabilität;
+        int maxEnergie;
+        int energieRadius;
+        double reparatur;
+        double akkuLeistung;
+        char team;
+    };
+
+    class KarteDaten : private Thread
+    {
+    private:
+        EditorKlient * client;
+        SpielerTeamStruktur *sts;
+        Array< SpielerDaten* > spieler;
+        Array< TeamDaten* > teams;
+        Array< ObjektDaten* > objekte;
+        Text error;
+        Array< std::function< void() > > aktionen;
+        Critical cs;
+        bool exit;
+        int ref;
+
+    public:
+        KarteDaten( EditorKlient *client );
+        ~KarteDaten();
+        void addObjekt( ObjektDaten &daten );
+        void removeObjekt( int index );
+        void getObjekt( int index, std::function< bool( ObjektDaten* ) > callBack );
+        void getSpieler( int index, std::function< bool( SpielerDaten* ) > callBack );
+        void getTeam( int index, std::function< bool( TeamDaten* ) > callBack );
+        void thread() override;
+        const ObjektDaten *getObjekt( int index );
+        const SpielerDaten *getSpieler( int index );
+        const TeamDaten *getTeam( int index );
+        int getSpielerIndexById( int id );
+        int getSpielerAnzahl() const;
+        int getTeamIndexById( int id );
+        int getTeamAnzahl() const;
+        int getObjektAnzahl() const;
+        bool hasError() const;
+        char *getError() const;
+        bool hasAktions() const;
+        KarteDaten *getThis();
+        KarteDaten *release();
+    };
+}

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

@@ -1,50 +0,0 @@
-#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

@@ -1,100 +0,0 @@
-#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

@@ -1,37 +0,0 @@
-#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,7 +1,43 @@
 #include "EditorKlient.h"
 #include <Klient.h>
+#include "../Karte/EditorKarte.h"
 
 using namespace Network;
+using namespace Editor;
+
+SpielerTeamStruktur::SpielerTeamStruktur()
+{
+    spielerAnzahl = 0;
+    teamAnzahl = 0;
+    spielerFarbe = new Array< int >();
+    teamFarbe = new Array< int >();
+    teamName = new RCArray< Text >();
+    teamSize = new Array< int >();
+    ref = 1;
+}
+
+SpielerTeamStruktur::~SpielerTeamStruktur()
+{
+    spielerFarbe->release();
+    teamFarbe->release();
+    teamName->release();
+    teamSize->release();
+}
+
+SpielerTeamStrukturV *SpielerTeamStruktur::getThis()
+{
+    ref++;
+    return this;
+}
+
+SpielerTeamStrukturV *SpielerTeamStruktur::release()
+{
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
+}
+
 
 // Inhalt der EditorKlient Klasse aus EditorKlient.h
 // Konstruktor
@@ -23,32 +59,302 @@ EditorKlient::~EditorKlient()
 //          2, falls bereits eine Sitzung existiert
 //          0, sonnst
 int EditorKlient::init()
-{/*
-    klient->lock();
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
     error = "";
-    Klient *k = klient->zKlient();
+    k->sendeEncrypted( "\x0", 1 );
+    char ret;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+        k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret;
+}
+
+// Verwirft die vorhandene Sitzung und erstellt eine neue
+bool EditorKlient::sitzungVerwerfen()
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x1", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+// Speichert Sitzung und beendet Editor
+bool EditorKlient::sitzungBeenden()
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x2", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+bool EditorKlient::saveTeam( const TeamDaten *team )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
     k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->sendeEncrypted( "\xF", 1 );
+        k->sendeEncrypted( (char*)&team->id, 4 );
+        k->sendeEncrypted( (char*)&team->maxPunkte, 4 );
+        k->sendeEncrypted( (char*)&team->beschleunigung, 8 );
+        k->sendeEncrypted( (char*)&team->maxStabilität, 4 );
+        k->sendeEncrypted( (char*)&team->maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&team->reparatur, 8 );
+        k->sendeEncrypted( (char*)&team->akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&team->laserIntensität, 4 );
+        k->sendeEncrypted( (char*)&team->laserEffizienz, 4 );
+        k->sendeEncrypted( (char*)&team->laserTempo, 4 );
+        k->sendeEncrypted( (char*)&team->wendigkeit, 8 );
+        k->sendeEncrypted( (char*)&team->antriebEffizienz, 8 );
+        k->sendeEncrypted( (char*)&team->punkte, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+bool EditorKlient::saveSpieler( const SpielerDaten *spieler )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x6", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&spieler->id, 4 );
+        k->sendeEncrypted( (char*)&spieler->pos.x, 4 );
+        k->sendeEncrypted( (char*)&spieler->pos.y, 4 );
+        k->sendeEncrypted( (char*)&spieler->rot, 8 );
+        k->sendeEncrypted( (char*)&spieler->beschleunigung, 8 );
+        k->sendeEncrypted( (char*)&spieler->maxStabilität, 4 );
+        k->sendeEncrypted( (char*)&spieler->maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&spieler->reparatur, 8 );
+        k->sendeEncrypted( (char*)&spieler->akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&spieler->laserIntensität, 4 );
+        k->sendeEncrypted( (char*)&spieler->laserEffizienz, 4 );
+        k->sendeEncrypted( (char*)&spieler->laserTempo, 4 );
+        k->sendeEncrypted( (char*)&spieler->wendigkeit, 8 );
+        k->sendeEncrypted( (char*)&spieler->antriebEffizienz, 8 );
+        k->sendeEncrypted( (char*)&spieler->netzwerk, 4 );
+        k->sendeEncrypted( (char*)&spieler->skillPunkte, 4 );
+        k->sendeEncrypted( (char*)&spieler->m2d, 4 );
+        k->sendeEncrypted( (char*)&spieler->bild, 4 );
         k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
+    }
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+bool EditorKlient::saveObjekt( const ObjektDaten *objekt )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x8", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&objekt->pos.x, 4 );
+        k->sendeEncrypted( (char*)&objekt->pos.y, 4 );
+        k->sendeEncrypted( (char*)&objekt->id, 4 );
+        k->sendeEncrypted( (char*)&objekt->m2d, 4 );
+        k->sendeEncrypted( (char*)&objekt->bild, 4 );
+        k->sendeEncrypted( (char*)&objekt->style, 4 );
+        k->sendeEncrypted( (char*)&objekt->maxStabilität, 4 );
+        k->sendeEncrypted( (char*)&objekt->maxEnergie, 4 );
+        k->sendeEncrypted( (char*)&objekt->energieRadius, 4 );
+        k->sendeEncrypted( (char*)&objekt->reparatur, 8 );
+        k->sendeEncrypted( (char*)&objekt->akkuLeistung, 8 );
+        k->sendeEncrypted( (char*)&objekt->team, 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+bool EditorKlient::deleteObjekt( int id )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x9", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+bool EditorKlient::loadSpieler( Array< SpielerDaten* > &spieler )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x3", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        int anz = 0;
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
+        for( int i = 0; i < anz; i++ )
         {
-            k->sendeEncrypted( "\x0", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                k->getNachrichtEncrypted( &ret, 1 );
-                return ret;
-            }
+            SpielerDaten *player = new SpielerDaten();
+            k->getNachrichtEncrypted( (char*)&player->id, 4 );
+            k->getNachrichtEncrypted( (char*)&player->pos.x, 4 );
+            k->getNachrichtEncrypted( (char*)&player->pos.y, 4 );
+            k->getNachrichtEncrypted( (char*)&player->rot, 8 );
+            k->getNachrichtEncrypted( (char*)&player->beschleunigung, 8 );
+            k->getNachrichtEncrypted( (char*)&player->maxStabilität, 4 );
+            k->getNachrichtEncrypted( (char*)&player->maxEnergie, 4 );
+            k->getNachrichtEncrypted( (char*)&player->reparatur, 8 );
+            k->getNachrichtEncrypted( (char*)&player->akkuLeistung, 8 );
+            k->getNachrichtEncrypted( (char*)&player->laserIntensität, 4 );
+            k->getNachrichtEncrypted( (char*)&player->laserEffizienz, 4 );
+            k->getNachrichtEncrypted( (char*)&player->laserTempo, 4 );
+            k->getNachrichtEncrypted( (char*)&player->wendigkeit, 8 );
+            k->getNachrichtEncrypted( (char*)&player->antriebEffizienz, 8 );
+            k->getNachrichtEncrypted( (char*)&player->netzwerk, 4 );
+            k->getNachrichtEncrypted( (char*)&player->skillPunkte, 4 );
+            k->getNachrichtEncrypted( (char*)&player->m2d, 4 );
+            k->getNachrichtEncrypted( (char*)&player->bild, 4 );
+            spieler.add( player );
         }
     }
     if( ret == 3 )
     {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -56,34 +362,49 @@ int EditorKlient::init()
         delete[] err;
         ret = 0;
     }
-    klient->unlock();
-    return ret;*/
-    return 0;
+    klient->endEditorMessage();
+    return ret == 1;
 }
 
-// Verwirft die vorhandene Sitzung und erstellt eine neue
-bool EditorKlient::sitzungVerwerfen()
-{/*
-    klient->lock();
+bool EditorKlient::loadTeams( Array< TeamDaten* > &teams )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
     error = "";
-    Klient *k = klient->zKlient();
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
+    char ret;
+    k->sendeEncrypted( "\x4", 1 );
     k->getNachrichtEncrypted( &ret, 1 );
     if( ret == 1 )
     {
-        k->sendeEncrypted( "\xF", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
+        int anz = 0;
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
+        for( int i = 0; i < anz; i++ )
         {
-            k->sendeEncrypted( "\x1", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
+            TeamDaten *team = new TeamDaten();
+            k->getNachrichtEncrypted( (char*)&team->id, 4 );
+            k->getNachrichtEncrypted( (char*)&team->maxPunkte, 4 );
+            k->getNachrichtEncrypted( (char*)&team->beschleunigung, 8 );
+            k->getNachrichtEncrypted( (char*)&team->maxStabilität, 4 );
+            k->getNachrichtEncrypted( (char*)&team->maxEnergie, 4 );
+            k->getNachrichtEncrypted( (char*)&team->reparatur, 8 );
+            k->getNachrichtEncrypted( (char*)&team->akkuLeistung, 8 );
+            k->getNachrichtEncrypted( (char*)&team->laserIntensität, 4 );
+            k->getNachrichtEncrypted( (char*)&team->laserEffizienz, 4 );
+            k->getNachrichtEncrypted( (char*)&team->laserTempo, 4 );
+            k->getNachrichtEncrypted( (char*)&team->wendigkeit, 8 );
+            k->getNachrichtEncrypted( (char*)&team->antriebEffizienz, 8 );
+            k->getNachrichtEncrypted( (char*)&team->punkte, 4 );
+            teams.add( team );
         }
     }
     if( ret == 3 )
     {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
         char *err = new char[ l + 1 ];
         err[ l ] = 0;
         k->getNachrichtEncrypted( err, l );
@@ -91,9 +412,63 @@ bool EditorKlient::sitzungVerwerfen()
         delete[] err;
         ret = 0;
     }
-    klient->unlock();
-    return ret == 1;*/
-    return 0;
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+bool EditorKlient::loadObjekte( Array< ObjektDaten* > &objekte )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\x5", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        int anz = 0;
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
+        for( int i = 0; i < anz; i++ )
+        {
+            ObjektDaten *objekt = new ObjektDaten();
+            k->getNachrichtEncrypted( (char*)&objekt->pos.x, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->pos.y, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->id, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->m2d, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->bild, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->style, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->maxStabilität, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->maxEnergie, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->energieRadius, 4 );
+            k->getNachrichtEncrypted( (char*)&objekt->reparatur, 8 );
+            k->getNachrichtEncrypted( (char*)&objekt->akkuLeistung, 8 );
+            k->getNachrichtEncrypted( (char*)&objekt->team, 1 );
+            objekte.add( objekt );
+        }
+    }
+    if( ret == 3 )
+    {
+        unsigned char l = 0;
+        k->getNachrichtEncrypted( (char*)&l, 1 );
+        char *err = new char[ l + 1 ];
+        err[ l ] = 0;
+        k->getNachrichtEncrypted( err, l );
+        error = err;
+        delete[] err;
+        ret = 0;
+    }
+    klient->endEditorMessage();
+    return ret == 1;
+}
+
+// Lädt die Spieler Team Struktur
+bool EditorKlient::getSpielerTeamStruktur( SpielerTeamStrukturV *sts )
+{
+    return klient->ladeTeamDaten( sts );
 }
 
 // Gibt den Letzten Fehler zurück

Asteroids/Editor/Netzwerk/EditorKlient.h

@@ -2,29 +2,57 @@
 
 #include <KSGNetwork.h>
 
-class EditorKlient
+namespace Editor
 {
-private:
-    KSGClient::EditorServerClient *klient;
-    Text error;
-    int ref;
+    struct TeamDaten;
+    struct SpielerDaten;
+    struct ObjektDaten;
 
-public:
-    // Konstruktor
-    //  k: Der zu verwendende Klient
-    EditorKlient( KSGClient::EditorServerClient *k );
-    // Destruktor
-    ~EditorKlient();
-    // Initialisiert den Server
-    //  return: 1, falls erfolgreich
-    //          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
-    EditorKlient *getThis();
-    EditorKlient *release();
-};
+    class SpielerTeamStruktur : public SpielerTeamStrukturV
+    {
+    public:
+        SpielerTeamStruktur();
+        ~SpielerTeamStruktur();
+        SpielerTeamStrukturV *getThis() override;
+        SpielerTeamStrukturV *release() override;
+    };
+
+    class EditorKlient
+    {
+    private:
+        KSGClient::EditorServerClient *klient;
+        Text error;
+        int ref;
+
+    public:
+        // Konstruktor
+        //  k: Der zu verwendende Klient
+        EditorKlient( KSGClient::EditorServerClient *k );
+        // Destruktor
+        ~EditorKlient();
+        // Initialisiert den Server
+        //  return: 1, falls erfolgreich
+        //          2, falls bereits eine Sitzung existiert
+        //          0, sonnst
+        int init();
+        // Verwirft die vorhandene Sitzung und erstellt eine neue
+        bool sitzungVerwerfen();
+        // Speichert Sitzung und beendet Editor
+        bool sitzungBeenden();
+        // Lädt die Spieler Team Struktur
+        bool getSpielerTeamStruktur( SpielerTeamStrukturV *zSts );
+
+        bool saveTeam( const TeamDaten *team );
+        bool saveSpieler( const SpielerDaten *spieler );
+        bool saveObjekt( const ObjektDaten *objekt );
+        bool deleteObjekt( int id );
+        bool loadSpieler( Array< SpielerDaten* > &spieler );
+        bool loadTeams( Array< TeamDaten* > &teams );
+        bool loadObjekte( Array< ObjektDaten* > &Objekte );
+        // Gibt den Letzten Fehler zurück
+        char *getLastError() const;
+        // Reference Counting
+        EditorKlient *getThis();
+        EditorKlient *release();
+    };
+}

Asteroids/Editor/Prozess.cpp

@@ -1,103 +0,0 @@
-#include "Prozess.h"
-#include <Klient.h>
-
-using namespace Network;
-
-// Inhalt der Klasse Prozess aus Prozess.h
-// Konstruktor
-Prozess::Prozess( KSGClient::EditorServerClient *klient, int aktion, Array< void* > *args, ProzessReturn *r )
-    : Thread()
-{
-    this->k = klient;
-    ak = aktion;
-    this->args = args;
-    ret = r;
-    ref = 1;
-    start();
-}
-
-// Destruktor
-Prozess::~Prozess()
-{
-    args->release();
-    k->release();
-}
-
-// nicht constant
-void Prozess::thread()
-{
-    /*
-    k->lock();
-    Klient *c = k->zKlient();
-    c->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    c->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        c->sendeEncrypted( "\xF", 1 );
-        char ret = 0;
-        c->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            switch( ak )
-            {
-            case 0:
-                init();
-                break;
-            case 1:
-                sitzungWiederherstellen();
-                break;
-            case 2:
-                sitzungVerwerfen();
-                break;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        c->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        c->getNachrichtEncrypted( f, byte );
-        Text fehler = f;
-        delete[] f;
-        Array< void* > args;
-        args.add( (void*)&fehler );
-        if( this->ret )
-            this->ret->prozessEnd( ak, 0, args );
-    }
-    k->unlock();
-    run = 0;*/
-}
-
-// Reference Counting
-Prozess *Prozess::getThis()
-{
-    ref++;
-    return this;
-}
-
-Prozess *Prozess::release()
-{
-    ref--;
-    if( !ref )
-        delete this;
-    return 0;
-}
-
-// privat
-void Prozess::init() // aktion = 0
-{
-
-}
-
-void Prozess::sitzungWiederherstellen() // aktion = 1
-{
-
-}
-
-void Prozess::sitzungVerwerfen() // aktion = 2
-{
-
-}

Asteroids/Editor/Prozess.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <KSGNetwork.h>
-#include <Thread.h>
-
-using namespace Framework;
-
-class ProzessReturn
-{
-public:
-    virtual void prozessEnd( int aktion, bool erfolg, Array< void* > &args ) = 0;
-};
-
-class Prozess : public Thread
-{
-private:
-    KSGClient::EditorServerClient *k;
-    int ak;
-    Array< void* > *args;
-    ProzessReturn *ret;
-    int ref;
-
-public:
-    // Konstruktor
-    Prozess( KSGClient::EditorServerClient *klient, int aktion, Array< void* > *args, ProzessReturn *r );
-    // Destruktor
-    ~Prozess();
-    // nicht constant
-    void thread() override;
-    // Reference Counting
-    Prozess *getThis();
-    Prozess *release();
-
-private:
-    void init(); // aktion = 0
-    void sitzungWiederherstellen(); // aktion = 1
-    void sitzungVerwerfen(); // aktion = 3
-
-};

Asteroids/HistorieStatistik/HistorieStatistik.cpp

@@ -100,11 +100,11 @@ void HistorieStatistik::doMausEreignis( MausEreignis &me )
 {
 	if( !geladen )
 		return;
+    bool vera = me.verarbeitet;
+    fertig->doMausEreignis( me );
+    if( !vera && me.verarbeitet && me.id == ME_RLinks )
+        geschlossen = 1;
 	tabelle->doMausEreignis( me );
-	bool vera = me.verarbeitet;
-	fertig->doMausEreignis( me );
-	if( !vera && me.verarbeitet && me.id == ME_RLinks )
-		geschlossen = 1;
 }
 
 void HistorieStatistik::doTastaturEreignis( TastaturEreignis &te )

Asteroids/Initialisierung/Initialisierung.cpp

@@ -117,7 +117,7 @@ BildZ *initBildZ( int x, int y, int br, int h
 	return ret;
 }
 
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< char * > values )
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< char * > values )
 {
 	AuswahlBox *ret = new AuswahlBox();
 	ret->setStyle( style );

Asteroids/Initialisierung/Initialisierung.h

@@ -25,7 +25,7 @@ KontrollKnopf *initKontrollKnopf( int x, int y, int br, int h
 Fenster *initFenster( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *titel );
 TextFeld *initTextFeld( int x, int y, int br, int hö, Schrift *zSchrift, int style, char *txt );
 BildZ *initBildZ( int x, int y, int br, int hö, int style, Bild *b );
-AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< char * > values );
+AuswahlBox *initAuswahlBox( int x, int y, int br, int hö, Schrift *zSchrift, __int64 style, std::initializer_list< char * > values );
 ObjTabelle *initObjTabelle( int x, int y, int br, int hö, Schrift *zSchrift, int style, std::initializer_list< OBJTabelleSpalteIni > spalten, int überschriftHöhe );
 void initToolTip( Zeichnung *obj, const char *txt, Schrift *schrift, Bildschirm *zBs );
 

Asteroids/Spiel/Schuss/Laser.cpp

@@ -169,6 +169,16 @@ double Laser::getIntensit
 	return intensität + (speed - targetSpeed).getLength() / 10;
 }
 
+Vec2< double > Laser::getPos() const
+{
+    return pos;
+}
+
+Vec2< double > Laser::getSpeed() const
+{
+    return speed;
+}
+
 // Reference Counting
 Laser *Laser::getThis()
 {

Asteroids/Spiel/Schuss/Laser.h

@@ -33,6 +33,8 @@ public:
 	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

@@ -27,6 +27,7 @@ SpielKlasse::SpielKlasse()
 	spieler = new RCArray< Spieler >();
 	teams = new RCArray< Team >();
 	objekte = new RCArray< SpielObjekt >();
+    deads = new RCArray< DeadPlayer >();
 	screen = 0;
 	kam = 0;
 	spielerAnzahl = 0;
@@ -59,6 +60,7 @@ SpielKlasse::~SpielKlasse()
 				teams->z( i )->reset();
 		}
 	}
+    deads->release();
 	stkn->release();
 	if( schrift )
 		schrift->release();
@@ -154,6 +156,17 @@ void SpielKlasse::setKarteId( int karteId )
 
 void SpielKlasse::ladeDaten()
 {
+    Text path = "data/log/0.csv";
+    for( int i = 1; DateiExistiert( path ); i++ )
+    {
+        path = "data/log/";
+        path += i;
+        path += ".csv";
+    }
+    csv.setDatei( path );
+    csv.erstellen();
+    csv.open( Datei::Style::schreiben );
+    csv.schreibe( "Spielernummer;Skill ID\n", 23 );
     // load frame annimation
     Text *gamePath = infoKlient->getDateiGruppePfad( infoKlient->getDateiGruppeIdVonSpiel( infoKlient->getSpielId( karteId ) ) );
     LTDBDatei flammenStartLTDB;
@@ -530,6 +543,27 @@ void SpielKlasse::stknVerarbeitung()
 			rendern = 1;
 			break;
 		case 0xB: // Ende
+            csv.schreibe( "\n\nSpielernummer;Kills;Tode;Schaden gemacht;Schaden bekommen;Schüsse;Treffer\n", 2 );
+            for( int i = 0; i < spielerAnzahl; i++ )
+            {
+                Spieler *s = spieler->z( i );
+                Text line = s->getSpielerNummer();
+                line += ";";
+                line += s->getKills();
+                line += ";";
+                line += s->getTode();
+                line += ";";
+                line += s->getSchadenGemacht();
+                line += ";";
+                line += s->getSchadenBekommen();
+                line += ";";
+                line += s->getSchüsse();
+                line += ";";
+                line += s->getTreffer();
+                line += "\n";
+                csv.schreibe( line, line.getLength() );
+            }
+            csv.close();
 			end = new Ende( schrift );
 			bytes++;
 			län--;
@@ -544,6 +578,11 @@ void SpielKlasse::stknVerarbeitung()
 				län -= 4;
 				char art = *bytes;
 				län--;
+                Text line = sNum;
+                line += ";";
+                line += art;
+                line += "\n";
+                csv.schreibe( line, line.getLength() );
 				for( int i = 0; i < spielerAnzahl; i++ )
 				{
 					if( spieler->z( i )->getSpielerNummer() == sNum )
@@ -656,6 +695,7 @@ void SpielKlasse::stknVerarbeitung()
                                     spieler->z( j )->resetToSaveTime( zeit, map );
                                     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 );
 									bestenliste->updateSpieler( spieler->z( j ) );
                                     break;
@@ -733,7 +773,9 @@ void SpielKlasse::stknVerarbeitung()
 					if( spieler->z( i )->getSpielerNummer() == sNum )
 					{
                         spieler->z( i )->resetToSaveTime( zeit, map );
-						spieler->z( i )->sterben();
+						DeadPlayer *dp = spieler->z( i )->sterben();
+                        if( dp )
+                            deads->add( dp );
                         spieler->z( i )->resetToGameTime( spielZeit, map );
 						bestenliste->updateSpieler( spieler->z( i ) );
 					}
@@ -803,6 +845,15 @@ bool SpielKlasse::tick( double zeit )
 		int y = 0;
 		bool setKam = 0;
 		lock();
+        int deadsCount = deads->getEintragAnzahl();
+        for( int i = 0; i < deadsCount; i++ )
+        {
+            if( deads->z( i )->tick() )
+            {
+                deads->remove( i-- );
+                deadsCount--;
+            }
+        }
 		int objektAnzahl = objekte->getEintragAnzahl();
 		for( int i = 0; i < objektAnzahl; i++ )
 			objekte->z( i )->tick();
@@ -849,6 +900,9 @@ void SpielKlasse::render( Bild &zRObj )
 	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 );

Asteroids/Spiel/SpielKlasse.h

@@ -33,6 +33,8 @@ private:
 	Model2DData *shipData;
 	Bild *shipTextur;
 	SpielerGUI *ship;
+    Datei csv;
+    RCArray< DeadPlayer > *deads;
 	bool rendern;
 	int spielZeit;
 	double rZeit;

Asteroids/Spiel/Spieler/DeadPlayer.cpp

@@ -0,0 +1,68 @@
+#include "DeadPlayer.h"
+#include "../Define.h"
+#include <Textur2D.h>
+#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 )
+{
+    m2a = new Model2D();
+    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->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;
+    this->speedB = speedB;
+    this->rotA = rotA;
+    this->rotB = rotB;
+    alpha = 255;
+    ref = 1;
+}
+
+DeadPlayer::~DeadPlayer()
+{
+    m2a->release();
+    m2b->release();
+}
+
+void DeadPlayer::render( Bild &zRObj )
+{
+    zRObj.setAlpha( (unsigned char)alpha );
+    m2a->render( zRObj );
+    m2b->render( zRObj );
+    zRObj.releaseAlpha();
+}
+
+bool DeadPlayer::tick()
+{
+    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;
+    if( alpha < 0 )
+    {
+        alpha = 0;
+        return 1;
+    }
+    return 0;
+}
+
+DeadPlayer *DeadPlayer::getThis()
+{
+    ref++;
+    return this;
+}
+
+DeadPlayer *DeadPlayer::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

Asteroids/Spiel/Spieler/DeadPlayer.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <Model2D.h>
+
+using namespace Framework;
+
+class DeadPlayer
+{
+private:
+    Model2D *m2a;
+    Model2D *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();
+};

Asteroids/Spiel/Spieler/Spieler.cpp

@@ -3,11 +3,14 @@
 #include "../Karte/Karte.h"
 #include "../Define.h"
 #include <Textur2D.h>
+#include "../Schuss/Laser.h"
 
 // Inhalt der Spieler Klasse aus Spieler.h
 // Konstruktor
 Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift, SpielerStr *zStr )
 {
+    textur = 0;
+    deadPlayer = 0;
     accountId = 0;
     sNum = zStr->id;
     current.farbe = 0;
@@ -68,6 +71,8 @@ Spieler::Spieler( KSGClient::InformationServerClient *zInfoK, Schrift *zSchrift,
 // Destruktor
 Spieler::~Spieler()
 {
+    if( textur )
+        textur->release();
     ship->release();
     info->release();
     if( team )
@@ -81,7 +86,7 @@ Spieler::~Spieler()
 
 double Spieler::calculateLaserCost()
 {
-    double kosten = ( current.laserIntensität + team->laserIntensität + ( current.laserTempo + team->laserTempo ) / 5 ) - ( current.laserEffizienz + team->laserEffizienz );
+    double kosten = ( ( current.laserIntensität + team->laserIntensität ) / 2 + ( current.laserTempo + team->laserTempo ) / 6 ) * ( 1 / ( ( current.laserEffizienz + team->laserEffizienz ) / 25 ) );
     if( kosten < 1 )
         kosten = 1;
     return kosten;
@@ -192,9 +197,11 @@ void Spieler::setSpielerFarbe( int fc, Bild *zTextur )
             shb->alphaPixelDP( i, buffer[ i ] );
         }
     }
-    Textur2D *textur = new Textur2D();
+    if( textur )
+        textur->release();
+    textur = new Textur2D();
     textur->setTexturZ( shb );
-    ship->setTextur( textur, "ship" );
+    ship->setTextur( textur->getThis(), "ship" );
 }
 
 void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
@@ -281,7 +288,7 @@ bool Spieler::tick( int time, Karte *zMap )
                 Vertex hp;
                 Vertex mv;
                 float r;
-                double treibstoff = ( ( current.beschleunigung + team->beschleunigung) / beschleunigungStart ) 
+                double treibstoff = 0.5 * ( ( current.beschleunigung + team->beschleunigung) / beschleunigungStart ) 
                     * akkuLeistungStart * tv * ( 100 / ( current.antriebEffizienz + team->antriebEffizienz ) );
                 current.treibstoffVerbraucht += treibstoff;
                 double factor = 1;
@@ -293,31 +300,26 @@ bool Spieler::tick( int time, Karte *zMap )
                 }
                 current.energie -= treibstoff * factor;
             }
-            else
-            {
-                double movementAngle = atan2( current.speed.y, current.speed.x );
-                if( current.speed.x != 0 )
-                    current.speed.x += 30.0f * cos( movementAngle + PI ) * TICK;
-                if( current.speed.y != 0 )
-                    current.speed.y += 30.0f * sin( movementAngle + PI ) * TICK;
-                if( current.speed.x < 6.f && current.speed.x > -6.f )
-                {
-                    current.speed.x = 0;
-                }
-                if( current.speed.y < 6.f && current.speed.y > -6.f )
-                {
-                    current.speed.y = 0;
-                }
-            }
+            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;
+                current.rSpeed -= (float)(TICK * 0.5);
                 if( current.rSpeed < 0 )
                     current.rSpeed = 0;
             }
             if( current.rSpeed < 0 )
             {
-                current.rSpeed += (float)TICK;
+                current.rSpeed += (float)(TICK * 0.5);
                 if( current.rSpeed > 0 )
                     current.rSpeed = 0;
             }
@@ -326,7 +328,7 @@ bool Spieler::tick( int time, Karte *zMap )
                 Vertex hp;
                 Vertex mv;
                 float r;
-                double treibstoff = 0.5 * ( ( current.wendigkeit + team->wendigkeit ) / wendigkeitStart )
+                double treibstoff = 0.25 * ( ( current.wendigkeit + team->wendigkeit ) / wendigkeitStart )
                     * akkuLeistungStart * tv * ( 100 / ( current.antriebEffizienz + team->antriebEffizienz ) );
                 current.treibstoffVerbraucht += treibstoff;
                 double factor = 1;
@@ -344,7 +346,7 @@ bool Spieler::tick( int time, Karte *zMap )
                 Vertex hp;
                 Vertex mv;
                 float r;
-                double treibstoff = 0.5 * ( ( current.wendigkeit + team->wendigkeit ) / wendigkeitStart )
+                double treibstoff = 0.25 * ( ( current.wendigkeit + team->wendigkeit ) / wendigkeitStart )
                     * akkuLeistungStart * tv * ( 100 / ( current.antriebEffizienz + team->antriebEffizienz ) );
                 current.treibstoffVerbraucht += treibstoff;
                 double factor = 1;
@@ -463,7 +465,7 @@ void Spieler::setSkill( int art )
         team->laserIntensität = team->getLaserIntensitätBonus();
         break;
     case 4: // Laser Effizienz
-        current.laserEffizienz += 2;
+        current.laserEffizienz += 1.5;
         team->laserEffizienz = team->getLaserEffizienzBonus();
         break;
     case 5: // Laser Tempo
@@ -508,6 +510,38 @@ void Spieler::nimmSchaden( double intensit
     current.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 ) )
+    {
+        ship->zModel()->split( hp, speed.rotation( -ship->getDrehung() ) * 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();
+        Array< Polygon2D > *npaA = new Array< Polygon2D >();
+        npaA->add( a );
+        Model2DData *npdA = new Model2DData();
+        npdA->erstelleModell( npaA );
+        Array< Polygon2D > *npaB = new Array< Polygon2D >();
+        npaB->add( b );
+        Model2DData *npdB = new Model2DData();
+        npdB->erstelleModell( npaB );
+        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 );
+    }
+}
+
 void Spieler::machSchaden( double intensität )
 {
     current.schadenGemacht += intensität;
@@ -524,7 +558,7 @@ void Spieler::addKill()
         current.maxReinkAbk = 5;
 }
 
-void Spieler::sterben()
+DeadPlayer *Spieler::sterben()
 {
     current.amLeben = 0;
     current.tode++;
@@ -532,6 +566,7 @@ void Spieler::sterben()
     current.reinkAbk += current.maxReinkAbk;
     current.maxReinkAbk++;
     current.punkte--;
+    return deadPlayer ? deadPlayer->getThis() : 0;
 }
 
 void Spieler::wiederbelebung()

Asteroids/Spiel/Spieler/Spieler.h

@@ -8,6 +8,7 @@
 #include "..\Kamera\Kamera.h"
 #include "../Team/Team.h"
 #include "../Karte/Strukturen.h"
+#include "DeadPlayer.h"
 
 class Team;
 class Laser;
@@ -30,6 +31,7 @@ private:
     int accountId;
     int sNum;
     bool tastatur[ T_MAX ];
+    Textur2D *textur;
     Model2D *ship;
     Team *team;
     KSGClient::InformationServerClient *info;
@@ -90,6 +92,7 @@ private:
     Textur2D *flammenL;
     Textur2D *flammenR;
     TextFeld *nText;
+    DeadPlayer *deadPlayer;
 
     double calculateLaserCost();
 
@@ -112,9 +115,10 @@ public:
 	void renderMinimap( Bild &zRObj, Karte *zMap, int thisSpielerNummer );
 	void setSkill( int art );
 	void nimmSchaden( double intensität );
+    void calcDeadPlayerObject( Laser *zSchuss );
 	void machSchaden( double intensität );
 	void addKill();
-	void sterben();
+    DeadPlayer *sterben();
 	void wiederbelebung();
 	void resetToSaveTime( int t, Karte *zMap );
     void resetToGameTime( int t, Karte *zMap );

Asteroids/Start/DLLStart.cpp

@@ -31,6 +31,6 @@ extern "C"
 
 	__declspec( dllexport ) EditorV *getEditor()
 	{
-		return new Editor();
+		return new Editor::AsteroidsEditor();
 	}
 }