Objekte können im Editor erstellt werden

Asteroids/Asteroids.vcxproj

@@ -177,7 +177,9 @@
     <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\Dialogs\ResourceDialog.h" />
     <ClInclude Include="Editor\Interface\Interface.h" />
+    <ClInclude Include="Editor\Interface\RightTools\ObjektOptionen\ObjektOptionen.h" />
     <ClInclude Include="Editor\Interface\RightTools\RightTools.h" />
     <ClInclude Include="Editor\Interface\RightTools\SpielerOptionen\SpielerOptionen.h" />
     <ClInclude Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.h" />
@@ -215,7 +217,9 @@
     <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\Dialogs\ResourceDialog.cpp" />
     <ClCompile Include="Editor\Interface\Interface.cpp" />
+    <ClCompile Include="Editor\Interface\RightTools\ObjektOptionen\ObjektOptionen.cpp" />
     <ClCompile Include="Editor\Interface\RightTools\RightTools.cpp" />
     <ClCompile Include="Editor\Interface\RightTools\SpielerOptionen\SpielerOptionen.cpp" />
     <ClCompile Include="Editor\Interface\RightTools\TeamOptionen\TeamOptionen.cpp" />

Asteroids/Asteroids.vcxproj.filters

@@ -123,6 +123,12 @@
     <ClInclude Include="Spiel\Skill\Skill.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="Editor\Interface\RightTools\ObjektOptionen\ObjektOptionen.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
+    <ClInclude Include="Editor\Interface\Dialogs\ResourceDialog.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Initialisierung\Initialisierung.cpp">
@@ -230,5 +236,11 @@
     <ClCompile Include="Spiel\Skill\Skill.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="Editor\Interface\RightTools\ObjektOptionen\ObjektOptionen.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="Editor\Interface\Dialogs\ResourceDialog.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Asteroids/Editor/Editor.cpp

@@ -127,12 +127,12 @@ void AsteroidsEditor::setSichtbar()
                     {
                         Text t = "Fehler beim verwerfen der Sitzung: ";
                         t += k->getLastError();
-                        this->addDialog( new Nachricht( zS, t, mS, 0 ) );
+                        this->addDialog( new Nachricht( zS->getThis(), 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->addDialog( new Frage( zS->getThis(), "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 )
@@ -144,7 +144,7 @@ void AsteroidsEditor::setSichtbar()
             {
                 Status *st = &status;
                 this->status = INITIALIZED;
-                this->addDialog( new Nachricht( zS, Text( "Fehler beim Initialisieren: " ) += k->getLastError(), mS, [ st ]() { *st = EXIT; } ) );
+                this->addDialog( new Nachricht( zS->getThis(), Text( "Fehler beim Initialisieren: " ) += k->getLastError(), mS, [ st ]() { *st = EXIT; } ) );
             }
             zS->release();
             k->release();
@@ -174,7 +174,7 @@ void AsteroidsEditor::doMausEreignis( MausEreignis & me )
             {
                 if( !k->sitzungBeenden() )
                 {
-                    this->addDialog( new Nachricht( zS, Text( "Fehler beim Speichern: " ) += k->getLastError(), mS, 0 ) );
+                    this->addDialog( new Nachricht( zS->getThis(), Text( "Fehler beim Speichern: " ) += k->getLastError(), mS, 0 ) );
                     status = INITIALIZED;
                 }
                 else

Asteroids/Editor/Interface/Dialogs/Dialog.cpp

@@ -6,8 +6,8 @@
 
 // Inhalt der Dialog Klasse aus Dialog.h
 // Konstruktor
-//  zS: Die zu verwendende Schrift
-Dialog::Dialog( TextRenderer *zS )
+//  tr: Die zu verwendende Schrift
+Dialog::Dialog( TextRenderer *tr )
     : Fenster()
 {
     setStyle( Fenster::Style::normal | Fenster::Style::Sichtbar | Fenster::Style::BodyHAlpha | Fenster::Style::BodyHintergrund |
@@ -17,7 +17,7 @@ Dialog::Dialog( TextRenderer *zS )
     setRBreite( 1 );
     setRFarbe( 0xFFFFFFFF );
     setTitel( "Fehler" );
-    zTTextFeld()->setTextRendererZ( zS->getThis() );
+    zTTextFeld()->setTextRendererZ( tr );
     setTSFarbe( 0xFFFFFFFF );
     zTTextFeld()->setSize( 0, 20 );
     zTTextFeld()->addStyle( TextFeld::Style::Sichtbar | TextFeld::Style::Center | TextFeld::Style::Rahmen );

Asteroids/Editor/Interface/Dialogs/Frage.cpp

@@ -4,7 +4,7 @@
 #include "../../../Initialisierung/Initialisierung.h"
 
 // Konstructor
-//  zS: Ein Zeiger auf die zu verwendende Schrift
+//  tr: Ein Zeiger auf die zu verwendende Schrift
 //  frage: Die Frage die an den Benutzer gestellt werden soll
 //  left: Die linke Antwort
 //  right: Die rechte Antwort
@@ -12,23 +12,23 @@
 //  rightAk: Ein Zeiger auf eine Funktion die beim wählen der Rechten Antwort aufgerufen wird
 //  abbruchAk: Ein Zeiger auf eine Funktion die beim Schließen des Fensters aufgerufen wird
 //  maxSize: Die Bildschirmgröße in Pixeln
-Frage::Frage( TextRenderer *zS, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize )
-    : Dialog( zS )
+Frage::Frage( TextRenderer *tr, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize )
+    : Dialog( tr )
 {
     Text *tmp = new Text( frage );
-    zS->setSchriftSize( 12 );
-    zS->textFormatieren( tmp, 300 );
-    int br = zS->getTextBreite( tmp->getText() );
-    int hö = zS->getTextHeight( tmp->getText() );
+    tr->setSchriftSize( 12 );
+    tr->textFormatieren( tmp, 300 );
+    int br = tr->getTextBreite( tmp->getText() );
+    int hö = tr->getTextHeight( tmp->getText() );
     setSize( br + 12, hö + 63 );
     setPosition( maxSize / 2 - getSize() / 2 );
     
-    TextFeld *text = initTextFeld( 5, 5, br, hö, zS->zSchrift(), TextFeld::Style::Text, tmp->getText() );
+    TextFeld *text = initTextFeld( 5, 5, br, hö, tr->zSchrift(), TextFeld::Style::Text, tmp->getText() );
     addMember( text );
     tmp->release();
-    Knopf *r = initKnopf( br - 94, hö + 22, 100, 20, zS->zSchrift(), Knopf::Style::Normal, right );
+    Knopf *r = initKnopf( br - 94, hö + 22, 100, 20, tr->zSchrift(), Knopf::Style::Normal, right );
     addMember( r );
-    Knopf *l = initKnopf( br - 199, hö + 22, 100, 20, zS->zSchrift(), Knopf::Style::Normal, left );
+    Knopf *l = initKnopf( br - 199, hö + 22, 100, 20, tr->zSchrift(), Knopf::Style::Normal, left );
     addMember( l );
 
     bool *verl = &verlassen;

Asteroids/Editor/Interface/Dialogs/Frage.h

@@ -7,7 +7,7 @@ class Frage : public Dialog
 {
 public:
     // Konstructor
-    //  zS: Ein Zeiger auf die zu verwendende Schrift
+    //  tr: Ein Zeiger auf die zu verwendende Schrift
     //  frage: Die Frage die an den Benutzer gestellt werden soll
     //  left: Die linke Antwort
     //  right: Die rechte Antwort
@@ -15,7 +15,7 @@ public:
     //  rightAk: Ein Zeiger auf eine Funktion die beim wählen der Rechten Antwort aufgerufen wird
     //  abbruchAk: Ein Zeiger auf eine Funktion die beim Schließen des Fensters aufgerufen wird
     //  maxSize: Die Bildschirmgröße in Pixeln
-    Frage( TextRenderer *zS, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize );
+    Frage( TextRenderer *tr, char *frage, char *left, char *right, std::function< void() > leftAk, std::function< void() > rightAk, std::function< void() > abbruchAk, Punkt maxSize );
     // Destruktor
     ~Frage();
 };

Asteroids/Editor/Interface/Dialogs/Nachricht.cpp

@@ -9,24 +9,24 @@
 // Inhalt der Fehler Klasse aus Fehler.h
 
 // Konstruktor
-//  zS: Die zu verwendende Schrift
+//  tr: Die zu verwendende Schrift
 //  nachricht: Der Fehler, der angezeigt werden soll
 //  maxSize: Die Bildschirmgröße in Pixeln
-Nachricht::Nachricht( TextRenderer *zS, char *nachricht, Punkt maxSize, std::function< void() > onClose )
-    : Dialog( zS )
+Nachricht::Nachricht( TextRenderer *tr, char *nachricht, Punkt maxSize, std::function< void() > onClose )
+    : Dialog( tr )
 {
     Text *tmp = new Text( nachricht );
-    zS->setSchriftSize( 12 );
-    zS->textFormatieren( tmp, 300 );
-    int br = zS->getTextBreite( tmp->getText() );
-    int hö = zS->getTextHeight( tmp->getText() );
+    tr->setSchriftSize( 12 );
+    tr->textFormatieren( tmp, 300 );
+    int br = tr->getTextBreite( tmp->getText() );
+    int hö = tr->getTextHeight( tmp->getText() );
     setSize( br + 12, hö + 63 );
     setPosition( maxSize / 2 - getSize() / 2 );
 
-    this->text = initTextFeld( 5, 5, br, hö, zS->zSchrift(), TextFeld::Style::Text, tmp->getText() );
+    this->text = initTextFeld( 5, 5, br, hö, tr->zSchrift(), TextFeld::Style::Text, tmp->getText() );
     addMember( text );
     tmp->release();
-    ok = initKnopf( br - 94, hö + 12, 100, 20, zS->zSchrift(), Knopf::Style::Normal, "Ok" );
+    ok = initKnopf( br - 94, hö + 12, 100, 20, tr->zSchrift(), Knopf::Style::Normal, "Ok" );
     addMember( ok );
     bool *verl = &verlassen;
 

Asteroids/Editor/Interface/Dialogs/Nachricht.h

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

Asteroids/Editor/Interface/Dialogs/ResourceDialog.cpp

@@ -0,0 +1,137 @@
+#include "ResourceDialog.h"
+#include "../../../Initialisierung/Initialisierung.h"
+
+using namespace Editor;
+
+// Konstructor
+//  tr: Ein Zeiger auf den zu verwendenden TextRenderer
+//  typ: Beschreibt was der nutzer alles auswählen kann
+//  daten: Ein Zeiger auf die Karte, welche alle möglichen resouren enthält
+//  onClose: Eine Funktion die aufgerufen wird, sobald der Dialog geschlossen wird. Es wird der ausgewählte Pfad oder 0 übergeben.
+//  screenSize: Die größe des Bildschirms zum positionieren des dialogs
+ResourceDialog::ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor::KarteDaten *daten, std::function< void( const char *path ) > onClose, Punkt screenSize )
+    : Dialog( tr )
+{
+    setTitel( "Resource Auswahl" );
+    this->daten = daten;
+    setSize( 400, 468 );
+    setPosition( screenSize / 2 - getSize() / 2 );
+
+    m2v = new M2DVorschau();
+    m2v->setStyle( M2DVorschau::Style::Rahmen | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrMove );
+    m2v->setSize( 390, 390 );
+    m2v->setPosition( 5, 30 );
+
+    bv = initBildZ( 5, 30, 390, 390, BildZ::Style::normal & ~Zeichnung::Style::Sichtbar, 0 );
+
+    paths = initAuswahlBox( 5, 5, 390, 20, tr->zSchrift(), AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    if( ( typ | ALLOW_RESOURCES ) == typ )
+    {
+        int anz = daten->getResourceAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            ResourceDaten *r = daten->getResource( i );
+            if( r->path.hat( ".ltdb/" ) && ( typ | TEXTUR ) == typ )
+                paths->addEintrag( r->path );
+            if( r->path.hat( ".m2/" ) && ( typ | MODEL2D ) == typ )
+                paths->addEintrag( r->path );
+        }
+    }
+    if( ( typ | ALLOW_NEW_RESOURCES ) == typ )
+    {
+        daten->loadUnusedResourcePaths( [ this, typ ]( RCArray< Text > * unusedPaths )
+        {
+            for( auto p = unusedPaths->getIterator(); p; p++ )
+            {
+                if( p->hat( ".ltdb/" ) && ( typ | TEXTUR ) == typ )
+                    paths->addEintrag( p->getText() );
+                if( p->hat( ".m2/" ) && ( typ | MODEL2D ) == typ )
+                    paths->addEintrag( p->getText() );
+            }
+            unusedPaths->release();
+        } );
+    }
+    if( paths->getEintragAnzahl() )
+    {
+        Text path = paths->zEintragText( 0 )->getText();
+        if( path.hat( ".ltdb/" ) )
+        {
+            m2v->removeStyle( Zeichnung::Style::Sichtbar );
+            bv->setBild( this->daten->loadBildFromPath( path.getText() ) );
+            bv->addStyle( Zeichnung::Style::Sichtbar );
+        }
+        else if( path.hat( ".m2/" ) )
+        {
+            bv->removeStyle( Zeichnung::Style::Sichtbar );
+            m2v->setModel2D( this->daten->loadModelFromPath( path.getText() ) );
+            m2v->addStyle( Zeichnung::Style::Sichtbar );
+        }
+        else
+        {
+            m2v->removeStyle( Zeichnung::Style::Sichtbar );
+            bv->removeStyle( Zeichnung::Style::Sichtbar );
+        }
+    }
+    paths->setEventAktion( [ this ]( void *p, AuswahlBox * a, int unused, int auswahl )
+    {
+        Text path = paths->zEintragText( paths->getAuswahl() )->getText();
+        if( path.hat( ".ltdb/" ) )
+        {
+            m2v->removeStyle( Zeichnung::Style::Sichtbar );
+            bv->setBild( this->daten->loadBildFromPath( path.getText() ) );
+            bv->addStyle( Zeichnung::Style::Sichtbar );
+        }
+        else if( path.hat( ".m2/" ) )
+        {
+            bv->removeStyle( Zeichnung::Style::Sichtbar );
+            m2v->setModel2D( this->daten->loadModelFromPath( path.getText() ) );
+            m2v->addStyle( Zeichnung::Style::Sichtbar );
+        }
+        else
+        {
+            m2v->removeStyle( Zeichnung::Style::Sichtbar );
+            bv->removeStyle( Zeichnung::Style::Sichtbar );
+        }
+    } );
+
+    Knopf *ok = initKnopf( 295, 425, 100, 20, tr->zSchrift(), Knopf::Style::Normal, "ok" );
+    addMember( ok );
+    ok->setMausEreignis( [ this, onClose ]( void *p, void *o, MausEreignis me )
+    {
+        if( me.id == ME_RLinks )
+        {
+            removeStyle( Fenster::Style::Sichtbar );
+            onClose( paths->zEintragText( paths->getAuswahl() )->getText() );
+        }
+        return 1;
+    } );
+    Knopf *abbrechen = initKnopf( 5, 425, 100, 20, tr->zSchrift(), Knopf::Style::Normal, "abbrechen" );
+    addMember( abbrechen );
+    auto abbruchAction = [ this, onClose ]( void *p, void *o, MausEreignis me )
+    {
+        if( me.id == ME_RLinks )
+        {
+            removeStyle( Fenster::Style::Sichtbar );
+            onClose( 0 );
+        }
+        return 1;
+    };
+    abbrechen->setMausEreignis( abbruchAction );
+    setClosingMe( abbruchAction );
+    bool *verl = &verlassen;
+    addMember( paths->getThis() );
+    if( !paths->getEintragAnzahl() )
+    {
+        removeStyle( Zeichnung::Style::Sichtbar );
+        onClose( 0 );
+    }
+}
+
+// Destruktor
+ResourceDialog::~ResourceDialog()
+{
+    paths->release();
+    m2v->release();
+    bv->release();
+    daten->release();
+}

Asteroids/Editor/Interface/Dialogs/ResourceDialog.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "Dialog.h"
+#include <AuswahlBox.h>
+#include <Bild.h>
+#include <M2DVorschau.h>
+#include "../../Karte/EditorKarte.h"
+#include <Knopf.h>
+
+enum ResourceDialogType
+{
+    MODEL2D = 1, // es werden Pfade für Model2D Objekte angezeigt
+    TEXTUR = 2, // es werden Pfade für Bilder angezeigt
+    ALLOW_RESOURCES = 4, // Es werden Pfade angezeigt, die bereits in einer Resource gespeichert sind
+    SELECT_OLD_Model2D = 5, // kombiniert MODEL2D und ALLOW_RESOURCES
+    SELECT_OLD_Textur = 6, // Kombiniert TEXTUR und ALLOW_RESOURCES
+    ALLOW_NEW_RESOURCES = 8, // Es werden Pfade angezeigt, die noch nicht in einer Resource gespeichert sind
+    SELECT_NEW_MODEL2D = 9, // kombiniert MODEL2D und ALLOW_NEW_RESOURCES
+    SELECT_NEW_TEXTUR = 10, // kombiniert TEXTUR und ALLOW_NEW_RESOURCES
+    SELECT_MODEL2D = 13, // kombiniert MODEL2D, ALLOW_RESOURCES und ALLOW_NEW_RESOURCES
+    SELECT_TEXTUR = 14, // kombiniert TEXTUR, ALLOW_RESOURCES und ALLOW_NEW_RESOURCES
+};
+
+class ResourceDialog : public Dialog
+{
+private:
+    AuswahlBox *paths;
+    M2DVorschau *m2v;
+    Editor::KarteDaten *daten;
+    BildZ *bv;
+
+public:
+    // Konstructor
+    //  tr: Ein Zeiger auf den zu verwendenden TextRenderer
+    //  typ: Beschreibt was der nutzer alles auswählen kann
+    //  daten: Ein Zeiger auf die Karte, welche alle möglichen resouren enthält
+    //  onClose: Eine Funktion die aufgerufen wird, sobald der Dialog geschlossen wird. Es wird der ausgewählte Pfad oder 0 übergeben.
+    //  screenSize: Die größe des Bildschirms zum positionieren des dialogs
+    ResourceDialog( TextRenderer *tr, ResourceDialogType typ, Editor::KarteDaten *daten, std::function< void( const char *path ) > onClose, Punkt screenSize );
+    // Destruktor
+    ~ResourceDialog();
+};

Asteroids/Editor/Interface/Interface.cpp

@@ -2,6 +2,7 @@
 #include "../../Initialisierung/Initialisierung.h"
 #include "RightTools\SpielerOptionen\SpielerOptionen.h"
 #include "RightTools\TeamOptionen\TeamOptionen.h"
+#include "RightTools/ObjektOptionen/ObjektOptionen.h"
 #include <MausEreignis.h>
 
 using namespace Editor;
@@ -36,6 +37,7 @@ void Interface::setDaten( KarteDaten * daten )
     this->daten = daten;
     right->addTool( new SpielerTool( schrift, (KarteDaten *)daten->getThis() ), "Spieler" );
     right->addTool( new TeamTool( schrift, (KarteDaten *)daten->getThis() ), "Teams" );
+    right->addTool( new ObjektTool( schrift, (KarteDaten *)daten->getThis() ), "Objekte" );
 }
 
 // Verarbeitet eine Mausnachricht

Asteroids/Editor/Interface/RightTools/ObjektOptionen/ObjektOptionen.cpp

@@ -0,0 +1,351 @@
+#include "ObjektOptionen.h"
+#include "../../../../Initialisierung/Initialisierung.h"
+#include <Textur2D.h>
+
+using namespace Editor;
+
+ObjektTool::ObjektTool( Schrift *zSchrift, KarteDaten *daten )
+    : RightTool()
+{
+    dialog = 0;
+    dialog2 = 0;
+    this->daten = daten;
+    schrift = zSchrift->getThis();
+    objekte = new AuswahlListe();
+    objekte->setStyle( AuswahlListe::Style::Normal | AuswahlBox::Style::VScroll );
+    objekte->setRahmenFarbe( 0xFFFFFFFF );
+    objekte->setRahmenBreite( 1 );
+    objekte->setSchriftZ( zSchrift->getThis() );
+    objekte->setSize( 290, 200 );
+    int anz = daten->getObjektAnzahl();
+    for( int i = 0; i < anz; i++ )
+    {
+        const ObjektDaten *o = daten->getObjekt( i );
+        objekte->addEintrag( Text( o->id ) );
+    }
+    neuesObjekt = initKnopf( 0, 205, 290, 20, zSchrift, Knopf::Style::Normal, "Neues Objekt erstellen" );
+    neuesObjekt->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    {
+        if( me.id == ME_RLinks )
+        {
+            cs.lock();
+            if( dialog )
+                dialog->release();
+            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_MODEL2D, (KarteDaten *)this->daten->getThis(), [ this ]( const char *modelPath )
+            {
+                cs.lock();
+                if( dialog2 )
+                    dialog2->release();
+                dialog2 = dialog;
+                dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_TEXTUR, (KarteDaten *)this->daten->getThis(), [ this, modelPath ]( const char *texturPath )
+                {
+                    ObjektDaten o;
+                    this->daten->getResourceIdFromPath( modelPath, [ this, &o, texturPath ]( int id )
+                    {
+                        o.m2d = id;
+                        this->daten->getResourceIdFromPath( texturPath, [ this, &o ]( int id )
+                        {
+                            o.bild = id;
+                            o.scale = 1;
+                            o.maxStabilität = 100;
+                            o.maxEnergie = 100;
+                            o.energieRadius = 0;
+                            o.reparatur = 0;
+                            o.akkuLeistung = 0;
+                            o.team = this->daten->getTeam( 0 )->id;
+                            o.pos.x = 0;
+                            o.pos.y = 0;
+                            o.rot = 0;
+                            this->daten->addObjekt( o, [ this ]( int id )
+                            {
+                                objekte->addEintrag( Text( id ) );
+                                selectObject( id );
+                            } );
+                        } );
+                    } );
+                }, screenSize );
+                cs.unlock();
+            }, screenSize );
+            cs.unlock();
+        }
+        return 1;
+    } );
+    model = new M2DVorschau();
+    model->setStyle( M2DVorschau::Style::Rahmen | M2DVorschau::Style::UsrRot | M2DVorschau::Style::UsrMove );
+    model->setSize( 290, 290 );
+    model->setPosition( 0, 230 );
+    changeModel = initKnopf( 0, 520, 142, 20, zSchrift, Knopf::Style::Normal, "Model ändern" );
+    changeModel->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    {
+        if( me.id == ME_RLinks )
+        {
+            if( dialog )
+                dialog->release();
+            cs.lock();
+            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_MODEL2D, (KarteDaten*)this->daten->getThis(), [ this ]( const char *path )
+            {
+                modelPath = path;
+                model->setModel2D( this->daten->loadModelFromPath( modelPath ) );
+                Textur2D *textur = new Textur2D();
+                textur->setTexturZ( this->daten->loadBildFromPath( texturPath ) );
+                model->zModel()->setTextur( textur );
+            }, screenSize );
+            cs.unlock();
+        }
+        return 1;
+    } );
+    changeTextur = initKnopf( 147, 520, 143, 20, zSchrift, Knopf::Style::Normal, "Textur ändern" );
+    changeTextur->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    {
+        if( me.id == ME_RLinks )
+        {
+            cs.lock();
+            if( dialog )
+                dialog->release();
+            dialog = new ResourceDialog( new TextRenderer( schrift->getThis() ), SELECT_TEXTUR, (KarteDaten *)this->daten->getThis(), [ this ]( const char *path )
+            {
+                texturPath = path;
+                Textur2D *textur = new Textur2D();
+                textur->setTexturZ( this->daten->loadBildFromPath( texturPath ) );
+                model->zModel()->setTextur( textur );
+            }, screenSize );
+            cs.unlock();
+        }
+        return 1;
+    } );
+    stabilitätT = initTextFeld( 0, 545, 100, 20, zSchrift, TextFeld::Style::Text, "Stabilität: " );
+    stabilität = initTextFeld( 100, 545, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    energieT = initTextFeld( 0, 570, 100, 20, zSchrift, TextFeld::Style::Text, "Energie: " );
+    energie = initTextFeld( 100, 570, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    energieRadiusT = initTextFeld( 0, 595, 100, 20, zSchrift, TextFeld::Style::Text, "Radius: " );
+    energieRadius = initTextFeld( 100, 595, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    reparaturT = initTextFeld( 0, 620, 100, 20, zSchrift, TextFeld::Style::Text, "Reparatur: " );
+    reparatur = initTextFeld( 100, 620, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    akkuLeistungT = initTextFeld( 0, 645, 100, 20, zSchrift, TextFeld::Style::Text, "Akku: " );
+    akkuLeistung = initTextFeld( 100, 645, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
+    team = initAuswahlBox( 0, 670, 150, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
+    anz = daten->getTeamAnzahl();
+    for( int i = 0; i < anz; i++ )
+        team->addEintrag( daten->getTeamName( i ) );
+    speichern = initKnopf( 0, 695, 100, 20, zSchrift, Knopf::Style::Normal, "Speichern" );
+    speichern->setMausEreignis( [ this ]( void *p, void *o, MausEreignis me )
+    {
+        if( me.id == ME_RLinks )
+        {
+            ObjektDaten *o = this->daten->getObjekt( this->daten->getObjektIndexById( *objekte->zEintrag( objekte->getAuswahl() )->zText() ) );
+            this->daten->getResourceIdFromPath( modelPath, [ this, o ]( int id )
+            {
+                o->m2d = id;
+                this->daten->getResourceIdFromPath( texturPath, [ this, o ]( int id ) 
+                {
+                    o->bild = id;
+                    o->maxStabilität = *stabilität->zText();
+                    o->maxEnergie = *energie->zText();
+                    o->energieRadius = *energieRadius->zText();
+                    o->reparatur = *reparatur->zText();
+                    o->akkuLeistung = *akkuLeistung->zText();
+                    o->team = team->getAuswahl();
+                    o->update();
+                } );
+            } );
+        }
+        return 1;
+    } );
+    selectObject( 0 );
+}
+
+ObjektTool::~ObjektTool()
+{
+    cs.lock();
+    if( dialog )
+        dialog->release();
+    if( dialog2 )
+        dialog2->release();
+    cs.unlock();
+    objekte->release();
+    neuesObjekt->release();
+    model->release();
+    changeModel->release();
+    changeTextur->release();
+    stabilitätT->release();
+    stabilität->release();
+    energieT->release();
+    energie->release();
+    energieRadiusT->release();
+    energieRadius->release();
+    reparaturT->release();
+    reparatur->release();
+    akkuLeistungT->release();
+    akkuLeistung->release();
+    team->release();
+    speichern->release();
+    daten->release();
+    schrift->release();
+}
+
+void ObjektTool::doMausEreignis( MausEreignis & me )
+{
+    bool vera = me.verarbeitet;
+    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
+        me.verarbeitet = 1;
+    cs.lock();
+    if( dialog )
+        dialog->doMausEreignis( me );
+    cs.unlock();
+    me.mx -= pos.x;
+    me.my -= pos.y;
+    int ausw = objekte->getAuswahl();
+    akkuLeistung->doMausEreignis( me );
+    objekte->doMausEreignis( me );
+    if( objekte->getAuswahl() != ausw && objekte->getAuswahl() >= 0 )
+        selectObject( *objekte->zEintrag( objekte->getAuswahl() )->zText() );
+    if( objekte->getAuswahl() != ausw && objekte->getAuswahl() < 0 )
+        selectObject( 0 );
+    model->doMausEreignis( me );
+    changeModel->doMausEreignis( me );
+    changeTextur->doMausEreignis( me );
+    stabilität->doMausEreignis( me );
+    energie->doMausEreignis( me );
+    energieRadius->doMausEreignis( me );
+    reparatur->doMausEreignis( me );
+    akkuLeistung->doMausEreignis( me );
+    speichern->doMausEreignis( me );
+    me.mx += pos.x;
+    me.my += pos.y;
+    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
+        me.verarbeitet = vera;
+    RightTool::doMausEreignis( me );
+}
+
+void ObjektTool::doTastaturEreignis( TastaturEreignis & te )
+{
+    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
+        return;
+    cs.lock();
+    if( dialog )
+        dialog->doTastaturEreignis( te );
+    cs.unlock();
+    model->doTastaturEreignis( te );
+    stabilität->doTastaturEreignis( te );
+    energie->doTastaturEreignis( te );
+    energieRadius->doTastaturEreignis( te );
+    reparatur->doTastaturEreignis( te );
+    akkuLeistung->doTastaturEreignis( te );
+}
+
+bool ObjektTool::tick( double tickVal )
+{
+    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
+        return RightTool::tick( tickVal );
+    cs.lock();
+    if( dialog )
+        rend |= dialog->tick( tickVal );
+    cs.unlock();
+    rend |= objekte->tick( tickVal );
+    rend |= neuesObjekt->tick( tickVal );
+    rend |= model->tick( tickVal );
+    rend |= changeModel->tick( tickVal );
+    rend |= changeTextur->tick( tickVal );
+    rend |= stabilität->tick( tickVal );
+    rend |= energie->tick( tickVal );
+    rend |= energieRadius->tick( tickVal );
+    rend |= reparatur->tick( tickVal );
+    rend |= akkuLeistung->tick( tickVal );
+    rend |= team->tick( tickVal );
+    rend |= speichern->tick( tickVal );
+    return RightTool::tick( tickVal );
+}
+
+void ObjektTool::render( Bild & rObj )
+{
+    screenSize = rObj.getSize();
+    if( hatStyleNicht( Zeichnung::Style::Sichtbar ) )
+        return;
+    if( rObj.setDrawOptions( pos, gr ) )
+    {
+        objekte->render( rObj );
+        neuesObjekt->render( rObj );
+        model->render( rObj );
+        changeModel->render( rObj );
+        changeTextur->render( rObj );
+        stabilitätT->render( rObj );
+        stabilität->render( rObj );
+        energieT->render( rObj );
+        energie->render( rObj );
+        energieRadiusT->render( rObj );
+        energieRadius->render( rObj );
+        reparaturT->render( rObj );
+        reparatur->render( rObj );
+        akkuLeistungT->render( rObj );
+        akkuLeistung->render( rObj );
+        speichern->render( rObj );
+        team->render( rObj );
+        rObj.releaseDrawOptions();
+    }
+    cs.lock();
+    if( dialog )
+        dialog->render( rObj );
+    cs.unlock();
+}
+
+void ObjektTool::selectObject( int id )
+{
+    if( id == 0 )
+    {
+        model->removeStyle( M2DVorschau::Style::Sichtbar );
+        changeModel->removeStyle( M2DVorschau::Style::Sichtbar );
+        changeTextur->removeStyle( M2DVorschau::Style::Sichtbar );
+        stabilitätT->removeStyle( M2DVorschau::Style::Sichtbar );
+        stabilität->removeStyle( M2DVorschau::Style::Sichtbar );
+        energieT->removeStyle( M2DVorschau::Style::Sichtbar );
+        energie->removeStyle( M2DVorschau::Style::Sichtbar );
+        energieRadiusT->removeStyle( M2DVorschau::Style::Sichtbar );
+        energieRadius->removeStyle( M2DVorschau::Style::Sichtbar );
+        reparaturT->removeStyle( M2DVorschau::Style::Sichtbar );
+        reparatur->removeStyle( M2DVorschau::Style::Sichtbar );
+        akkuLeistungT->removeStyle( M2DVorschau::Style::Sichtbar );
+        akkuLeistung->removeStyle( M2DVorschau::Style::Sichtbar );
+        team->removeStyle( M2DVorschau::Style::Sichtbar );
+        speichern->removeStyle( M2DVorschau::Style::Sichtbar );
+    }
+    else
+    {
+        int index = 0;
+        int anz = objekte->getEintragAnzahl();
+        for( int i = 0; i < anz; i++ )
+        {
+            if( objekte->zEintrag( i )->zText()->istGleich( Text( id ) ) )
+                break;
+            index++;
+        }
+        objekte->setAuswahl( index );
+        ObjektDaten *o = daten->getObjekt( daten->getObjektIndexById( id ) );
+        model->setModel2D( daten->loadModelFromRessource( o->m2d ) );
+        modelPath = daten->getResource( daten->getResourceIndexById( o->m2d ) )->path;
+        Textur2D *textur = new Textur2D();
+        textur->setTexturZ( daten->loadBildFromRessource( o->bild ) );
+        texturPath = daten->getResource( daten->getResourceIndexById( o->bild ) )->path;
+        model->zModel()->setTextur( textur );
+        stabilität->setText( Text( o->maxStabilität ) );
+        energie->setText( Text( o->maxEnergie ) );
+        energieRadius->setText( Text( o->energieRadius ) );
+        reparatur->setText( Text( o->reparatur ) );
+        akkuLeistung->setText( Text( o->akkuLeistung ) );
+        team->setAuswahl( Text( o->team ) );
+        model->addStyle( M2DVorschau::Style::Sichtbar );
+        changeModel->addStyle( M2DVorschau::Style::Sichtbar );
+        changeTextur->addStyle( M2DVorschau::Style::Sichtbar );
+        stabilitätT->addStyle( M2DVorschau::Style::Sichtbar );
+        stabilität->addStyle( M2DVorschau::Style::Sichtbar );
+        energieT->addStyle( M2DVorschau::Style::Sichtbar );
+        energie->addStyle( M2DVorschau::Style::Sichtbar );
+        energieRadiusT->addStyle( M2DVorschau::Style::Sichtbar );
+        energieRadius->addStyle( M2DVorschau::Style::Sichtbar );
+        reparaturT->addStyle( M2DVorschau::Style::Sichtbar );
+        reparatur->addStyle( M2DVorschau::Style::Sichtbar );
+        akkuLeistungT->addStyle( M2DVorschau::Style::Sichtbar );
+        akkuLeistung->addStyle( M2DVorschau::Style::Sichtbar );
+        team->addStyle( M2DVorschau::Style::Sichtbar );
+        speichern->addStyle( M2DVorschau::Style::Sichtbar );
+    }
+}

Asteroids/Editor/Interface/RightTools/ObjektOptionen/ObjektOptionen.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../RightTools.h"
+#include "../../../../Spiel/Karte/Strukturen.h"
+#include "../../../Karte/EditorKarte.h"
+#include "../../Dialogs/ResourceDialog.h"
+#include <Liste.h>
+#include <M2DVorschau.h>
+
+namespace Editor
+{
+    class ObjektTool : public RightTool
+    {
+    private:
+        AuswahlListe *objekte;
+        Knopf *neuesObjekt;
+        M2DVorschau *model;
+        Knopf *changeModel;
+        Knopf *changeTextur;
+        TextFeld *stabilitätT;
+        TextFeld *stabilität;
+        TextFeld *energieT;
+        TextFeld *energie;
+        TextFeld *energieRadiusT;
+        TextFeld *energieRadius;
+        TextFeld *reparaturT;
+        TextFeld *reparatur;
+        TextFeld *akkuLeistungT;
+        TextFeld *akkuLeistung;
+        AuswahlBox *team;
+        Knopf *speichern;
+        KarteDaten *daten;
+        Schrift *schrift;
+        Text modelPath;
+        Text texturPath;
+        ResourceDialog *dialog;
+        ResourceDialog *dialog2;
+        Punkt screenSize;
+
+    public:
+        ObjektTool( Schrift *zSchrift, KarteDaten *daten );
+        ~ObjektTool();
+        void doMausEreignis( MausEreignis &me ) override;
+        void doTastaturEreignis( TastaturEreignis &te ) override;
+        bool tick( double tickVal ) override;
+        void render( Bild &rObj ) override;
+        void selectObject( int id );
+    };
+}

Asteroids/Editor/Interface/RightTools/RightTools.cpp

@@ -30,7 +30,7 @@ RightTools::RightTools( Schrift *zSchrift, Punkt maxSize )
 {
     ref = 1;
     this->maxSize = maxSize;
-    toolAuswahl = initAuswahlBox( 5, 5, 290, 20, zSchrift, AuswahlBox::Style::Normal, {} );
+    toolAuswahl = initAuswahlBox( 5, 5, 290, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     toolAuswahl->setEventAktion( [ this ]( void *, AuswahlBox *, int, int neu )
     {
         this->selectTool( neu );
@@ -100,12 +100,12 @@ 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 );
         }
+        toolAuswahl->render( rObj );
         rObj.releaseDrawOptions();
     }
 }

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

@@ -8,7 +8,7 @@ SpielerTool::SpielerTool( Schrift *zSchrift, KarteDaten *daten )
     : RightTool()
 {
     int spielerAnzahl = daten->getSpielerAnzahl();
-    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal, {} );
+    spielerAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     for( int i = 0; i < spielerAnzahl; i++ )
     {
         spielerAuswahl->addEintrag( new Text( Text( "Spieler " ) += ( i + 1 ) ) );
@@ -32,7 +32,7 @@ SpielerTool::SpielerTool( Schrift *zSchrift, KarteDaten *daten )
     skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, zSchrift, TextFeld::Style::Text, "Schild Effizienz" );
     skillStartNetzwerkT = initTextFeld( 0, 355, 200, 20, zSchrift, TextFeld::Style::Text, "Netzwerk" );
     skillStartPunkteT = initTextFeld( 0, 380, 200, 20, zSchrift, TextFeld::Style::Text, "Punkte" );
-    const SpielerDaten *spieler = daten->getSpieler( daten->getSpielerIndexById( 1 ) );
+    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 ) );
@@ -128,22 +128,22 @@ void SpielerTool::doMausEreignis( MausEreignis &me )
     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.energieSchild = *skillStartEnergieSchild->zText();
-        data.energieSchildEffizienz = *skillStartEnergieSchildEffizienz->zText();
-        data.netzwerk = *skillStartNetzwerk->zText();
-        data.skillPunkte = *skillStartPunkte->zText();
-        data.update();
+        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->energieSchild = *skillStartEnergieSchild->zText();
+        data->energieSchildEffizienz = *skillStartEnergieSchildEffizienz->zText();
+        data->netzwerk = *skillStartNetzwerk->zText();
+        data->skillPunkte = *skillStartPunkte->zText();
+        data->update();
     }
     me.mx += pos.x;
     me.my += pos.y;
@@ -233,7 +233,6 @@ void SpielerTool::render( Bild &rObj )
         return;
     if( rObj.setDrawOptions( pos, gr ) )
     {
-        spielerAuswahl->render( rObj );
         skillStartT->render( rObj );
         skillStartStabilitätT->render( rObj );
         skillStartEnergieT->render( rObj );
@@ -264,6 +263,7 @@ void SpielerTool::render( Bild &rObj )
         skillStartNetzwerk->render( rObj );
         skillStartPunkte->render( rObj );
         speichern->render( rObj );
+        spielerAuswahl->render( rObj );
         rObj.releaseDrawOptions();
     }
 }
@@ -272,7 +272,7 @@ void SpielerTool::selectPlayer( int id )
 {
     int index = daten->getSpielerIndexById( id );
     spielerAuswahl->setAuswahl( id - 1 );
-    const SpielerDaten *spieler = daten->getSpieler( index );
+    SpielerDaten *spieler = daten->getSpieler( index );
     skillStartStabilität->setText( Text( spieler->maxStabilität ) );
     skillStartEnergie->setText( Text( spieler->maxEnergie ) );
     skillStartReparatur->setText( Text( spieler->reparatur ) );

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

@@ -8,10 +8,10 @@ TeamTool::TeamTool( Schrift *zSchrift, KarteDaten *daten )
     : RightTool()
 {
     int teamAnzahl = daten->getTeamAnzahl();
-    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal, {} );
+    teamAuswahl = initAuswahlBox( 0, 0, 150, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, {} );
     for( int i = 0; i < teamAnzahl; i++ )
     {
-        teamAuswahl->addEintrag( new Text( Text( "Team " ) += ( i + 1 ) ) );
+        teamAuswahl->addEintrag( daten->getTeamName( i ) );
     }
     teamAuswahl->setEventAktion( [ this ]( void *p, AuswahlBox *a, int old, int auswahl )
     {
@@ -30,7 +30,7 @@ TeamTool::TeamTool( Schrift *zSchrift, KarteDaten *daten )
     skillStartLaserTempoT = initTextFeld( 0, 280, 200, 20, zSchrift, TextFeld::Style::Text, "Laser Tempo" );
     skillStartEnergieSchildT = initTextFeld( 0, 305, 200, 20, zSchrift, TextFeld::Style::Text, "Energie Schild" );
     skillStartEnergieSchildEffizienzT = initTextFeld( 0, 330, 200, 20, zSchrift, TextFeld::Style::Text, "Schild Effizienz" );
-    const TeamDaten *Team = daten->getTeam( daten->getTeamIndexById( 1 ) );
+    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 ) );
@@ -116,20 +116,20 @@ void TeamTool::doMausEreignis( MausEreignis &me )
     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();
-        data.energieSchild = *skillStartEnergieSchild->zText();
-        data.energieSchildEffizienz = *skillStartEnergieSchildEffizienz->zText();
-        data.update();
+        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();
+        data->energieSchild = *skillStartEnergieSchild->zText();
+        data->energieSchildEffizienz = *skillStartEnergieSchildEffizienz->zText();
+        data->update();
     }
     me.mx += pos.x;
     me.my += pos.y;
@@ -211,7 +211,6 @@ void TeamTool::render( Bild &rObj )
         return;
     if( rObj.setDrawOptions( pos, gr ) )
     {
-        teamAuswahl->render( rObj );
         skillStartT->render( rObj );
         skillStartStabilitätT->render( rObj );
         skillStartEnergieT->render( rObj );
@@ -238,6 +237,7 @@ void TeamTool::render( Bild &rObj )
         skillStartEnergieSchild->render( rObj );
         skillStartEnergieSchildEffizienz->render( rObj );
         speichern->render( rObj );
+        teamAuswahl->render( rObj );
         rObj.releaseDrawOptions();
     }
 }
@@ -246,7 +246,7 @@ void TeamTool::selectTeam( int id )
 {
     int index = daten->getTeamIndexById( id );
     teamAuswahl->setAuswahl( id - 1 );
-    const TeamDaten *Team = daten->getTeam( index );
+    TeamDaten *Team = daten->getTeam( index );
     skillStartStabilität->setText( Text( Team->maxStabilität ) );
     skillStartEnergie->setText( Text( Team->maxEnergie ) );
     skillStartReparatur->setText( Text( Team->reparatur ) );

Asteroids/Editor/Karte/EditorKarte.cpp

@@ -2,6 +2,11 @@
 #include <Model2D.h>
 #include <Bild.h>
 #include <Textur2D.h>
+#include <Datei.h>
+#include <DateiSystem.h>
+#include <M2Datei.h>
+#include <Globals.h>
+#include <DLLRegister.h>
 
 using namespace Editor;
 
@@ -30,6 +35,24 @@ void EdSpieler::update()
 }
 
 
+EdObjekt::EdObjekt( ObjektDaten *model )
+    : EditorObject()
+{
+    mdl = model;
+}
+
+EdObjekt::~EdObjekt()
+{}
+
+void EdObjekt::update()
+{
+    mdl->pos = position;
+    mdl->rot = rotation;
+    mdl->scale = size;
+    mdl->update();
+}
+
+
 UpdateObserver::UpdateObserver( std::function< void() > f )
 {
     this->f = f;
@@ -44,6 +67,8 @@ void UpdateObserver::update( Model *m )
 KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
     : Thread()
 {
+    HMODULE dll = Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
+    getGSLDatei = (GetGSLDatei)GetProcAddress( dll, "getGSLDatei" );
     welt = new Welt2D();
     welt->setCircular( 1 );
     this->client = client;
@@ -87,6 +112,7 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
             bild->release();
         }
         model->setPosition( s->pos );
+        model->setDrehung( (float)s->rot );
         model->setCollision( 0 );
         welt->addObject( model );
         SpielerDaten *d = s._;
@@ -111,12 +137,46 @@ KarteDaten::KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts )
     }
     for( auto o = objekte.getIterator(); o; o++ )
     {
+        Model2DObject *model = new EdObjekt( o._ );
+        Bild *bild;
+        for( auto r = resources.getIterator(); r; r++ )
+        {
+            if( r->id == o->m2d )
+                model->setModel( client->loadModel( r->path ) );
+            if( r->id == o->bild )
+                bild = client->loadBild( r->path );
+        }
+        if( bild )
+        {
+            Textur2D *textur = new Textur2D();
+            textur->setTexturZ( bild );
+            model->setTextur( textur );
+        }
+        model->setPosition( o->pos );
+        model->setDrehung( o->rot );
+        model->setSize( o->scale );
+        model->setCollision( 0 );
+        welt->addObject( model );
         ObjektDaten *d = o._;
-        d->addView( new UpdateObserver( [ this, d ]()
+        d->addView( new UpdateObserver( [ this, d, model ]()
         {
-            aktionen.add( [ this, d ]()
+            aktionen.add( [ this, d, model ]()
             {
                 this->client->saveObjekt( d );
+                Bild *bild;
+                for( auto r = resources.getIterator(); r; r++ )
+                {
+                    if( r->id == d->m2d )
+                        model->setModel( this->client->loadModel( r->path ) );
+                    if( r->id == d->bild )
+                        bild = this->client->loadBild( r->path );
+                }
+                if( bild )
+                {
+                    Textur2D *textur = new Textur2D();
+                    textur->setTexturZ( bild );
+                    model->setTextur( textur );
+                }
             } );
         } ) );
     }
@@ -138,19 +198,64 @@ KarteDaten::~KarteDaten()
     sts->release();
     client->release();
     welt->release();
+    Framework::getDLLRegister()->releaseDLL( "GSL.dll" );
 }
 
-void KarteDaten::addObjekt( ObjektDaten & daten )
+void KarteDaten::addObjekt( ObjektDaten & daten, std::function< void( int ) > callBack )
 {
     ObjektDaten *nd = new ObjektDaten( daten );
     cs.lock();
-    nd->id = objekte.getEintragAnzahl();
+    nd->id = objekte.getEintragAnzahl() + 1;
     objekte.add( nd );
+    Model2DObject *model = new EdObjekt( nd );
+    Bild *bild;
+    for( auto r = resources.getIterator(); r; r++ )
+    {
+        if( r->id == nd->m2d )
+            model->setModel( client->loadModel( r->path ) );
+        if( r->id == nd->bild )
+            bild = client->loadBild( r->path );
+    }
+    if( bild )
+    {
+        Textur2D *textur = new Textur2D();
+        textur->setTexturZ( bild );
+        model->setTextur( textur );
+    }
+    model->setPosition( nd->pos );
+    model->setDrehung( nd->rot );
+    model->setSize( nd->scale );
+    model->setCollision( 0 );
+    welt->addObject( model );
+    nd->addView( new UpdateObserver( [ this, nd, model ]()
+    {
+        aktionen.add( [ this, nd, model ]()
+        {
+            this->client->saveObjekt( nd );
+            Bild *bild;
+            for( auto r = resources.getIterator(); r; r++ )
+            {
+                if( r->id == nd->m2d )
+                    model->setModel( this->client->loadModel( r->path ) );
+                if( r->id == nd->bild )
+                    bild = this->client->loadBild( r->path );
+            }
+            if( bild )
+            {
+                Textur2D *textur = new Textur2D();
+                textur->setTexturZ( bild );
+                model->setTextur( textur );
+            }
+        } );
+    } ) );
     ObjektDaten td = *nd;
     EditorKlient *c = client;
-    aktionen.add( [ td, c ]()
+    aktionen.add( [ td, c, callBack ]()
     {
-        c->saveObjekt( &td );
+        if( c->saveObjekt( &td ) )
+            callBack( td.id );
+        else
+            callBack( 0 );
     } );
     cs.unlock();
 }
@@ -187,7 +292,16 @@ void KarteDaten::thread()
     }
 }
 
-const ObjektDaten *KarteDaten::getObjekt( int index )
+ResourceDaten *KarteDaten::getResource( int index )
+{
+    ResourceDaten *ret = 0;
+    cs.lock();
+    ret = resources.get( index );
+    cs.unlock();
+    return ret;
+}
+
+ObjektDaten *KarteDaten::getObjekt( int index )
 {
     ObjektDaten *ret = 0;
     cs.lock();
@@ -196,7 +310,7 @@ const ObjektDaten *KarteDaten::getObjekt( int index )
     return ret;
 }
 
-const SpielerDaten *KarteDaten::getSpieler( int index )
+SpielerDaten *KarteDaten::getSpieler( int index )
 {
     SpielerDaten *ret = 0;
     cs.lock();
@@ -205,7 +319,7 @@ const SpielerDaten *KarteDaten::getSpieler( int index )
     return ret;
 }
 
-const TeamDaten *KarteDaten::getTeam( int index )
+TeamDaten *KarteDaten::getTeam( int index )
 {
     TeamDaten *ret = 0;
     cs.lock();
@@ -214,6 +328,11 @@ const TeamDaten *KarteDaten::getTeam( int index )
     return ret;
 }
 
+const char *KarteDaten::getTeamName( int index )
+{
+    return sts->teamName->z( teams.get( index )->id - 1 )->getText();
+}
+
 int KarteDaten::getSpielerIndexById( int id )
 {
     int index = 0;
@@ -252,11 +371,44 @@ int KarteDaten::getTeamAnzahl() const
     return teams.getEintragAnzahl();
 }
 
+int KarteDaten::getObjektIndexById( int id )
+{
+    int index = 0;
+    cs.lock();
+    for( auto i = objekte.getIterator(); i; i++ )
+    {
+        if( i->id == id )
+            break;
+        index++;
+    }
+    cs.unlock();
+    return index;
+}
+
 int KarteDaten::getObjektAnzahl() const
 {
     return objekte.getEintragAnzahl();
 }
 
+int KarteDaten::getResourceIndexById( int id )
+{
+    int index = 0;
+    cs.lock();
+    for( auto i = resources.getIterator(); i; i++ )
+    {
+        if( i->id == id )
+            break;
+        index++;
+    }
+    cs.unlock();
+    return index;
+}
+
+int KarteDaten::getResourceAnzahl()
+{
+    return resources.getEintragAnzahl();
+}
+
 bool KarteDaten::hasError() const
 {
     return !error.istGleich( "" );
@@ -282,6 +434,166 @@ Welt2D *KarteDaten::zWelt() const
     return welt;
 }
 
+void KarteDaten::getResourceIdFromPath( const char *path, std::function< void( int ) > callBack )
+{
+    for( auto r = resources.getIterator(); r; r++ )
+    {
+        if( r->path.istGleich( path ) )
+        {
+            callBack( r->id );
+            return;
+        }
+    }
+    aktionen.add( [ this, path, callBack ]()
+    {
+        int id = client->addResource( path );
+        if( !id )
+        {
+            callBack( 0 );
+            return;
+        }
+        ResourceDaten *nr = new ResourceDaten();
+        nr->id = id;
+        nr->path = path;
+        cs.lock();
+        resources.add( nr );
+        cs.unlock();
+        callBack( id );
+    } );
+}
+
+bool KarteDaten::doesResourceExist( const char *path )
+{
+    for( auto r = resources.getIterator(); r; r++ )
+    {
+        if( r->path.istGleich( path ) )
+            return 1;
+    }
+    return 0;
+}
+
+Model2DData *KarteDaten::loadModelFromRessource( int id )
+{
+    for( auto r = resources.getIterator(); r; r++ )
+    {
+        if( r->id == id )
+            return client->loadModel( r->path );
+    }
+    return 0;
+}
+
+Bild *KarteDaten::loadBildFromRessource( int id )
+{
+    for( auto r = resources.getIterator(); r; r++ )
+    {
+        if( r->id == id )
+            return client->loadBild( r->path );
+    }
+    return 0;
+}
+
+Model2DData *KarteDaten::loadModelFromPath( const char *path )
+{
+    return client->loadModel( path );
+}
+
+Bild *KarteDaten::loadBildFromPath( const char *path )
+{
+    return client->loadBild( path );
+}
+
+void KarteDaten::loadUnusedResourcePaths( std::function< void( RCArray< Text > * ) > callBack )
+{
+    cs.lock();
+    aktionen.add( [ this, callBack ]()
+    {
+        RCArray< Text > *result = new RCArray< Text >();
+        loadSpielResourcePathsFromFolder( "data/spiele/Asteroids", result );
+        RCArray< Text > *mapPaths = client->getAllMapResourcePaths();
+        for( auto mp = mapPaths->getIterator(); mp; mp++ )
+        {
+            if( !doesResourceExist( mp->getText() ) )
+                result->add( mp->getThis() );
+        }
+        mapPaths->release();
+        callBack( result );
+    } );
+}
+
+void KarteDaten::loadSpielResourcePathsFromFolder( const char *folderPath, RCArray< Text > * zPaths )
+{
+    Datei f;
+    f.setDatei( folderPath );
+    if( f.istOrdner() )
+    {
+        RCArray< Text > *list = f.getDateiListe();
+        for( auto n = list->getIterator(); n; n++ )
+        {
+            Text path( folderPath );
+            path += Text( "/" ) + (const char *)n->getText();
+            loadSpielResourcePathsFromFolder( path, zPaths );
+        }
+        list->release();
+    }
+    else
+    {
+        if( f.zPfad()->hat( ".ltdb" ) )
+        {
+            LTDBDatei d;
+            d.setDatei( new Text( folderPath ) );
+            d.leseDaten( 0 );
+            int anz = d.getBildAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                Text *path = new Text( folderPath );
+                path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
+                path->append( (const char *)( Text( "/" ) + (const char *)d.zBildListe()->z( i )->getText() ) );
+                if( doesResourceExist( path->getText() ) )
+                    path->release();
+                else
+                    zPaths->add( path );
+            }
+        }
+        if( f.zPfad()->hat( ".m2" ) )
+        {
+            M2Datei d;
+            d.setPfad( folderPath );
+            d.leseDaten();
+            int anz = d.getModelAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                Text *path = new Text( folderPath );
+                path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
+                path->append( (const char *)( Text( "/" ) + (const char *)d.zModelName( i )->getText() ) );
+                if( doesResourceExist( path->getText() ) )
+                    path->release();
+                else
+                    zPaths->add( path );
+            }
+        }
+        if( f.zPfad()->hat( ".gsl" ) )
+        {
+            HMODULE dll = Framework::getDLLRegister()->ladeDLL( "GSL.dll", "data/bin/GSL.dll" );
+            GSL::GSLDateiV *d = getGSLDatei();
+            d->setDatei( (char *)folderPath );
+            d->leseDaten();
+            int anz = d->getSoundAnzahl();
+            for( int i = 0; i < anz; i++ )
+            {
+                Text *path = new Text( folderPath );
+                path->ersetzen( 0, (int)strlen( "data/spiele/Asteroids" ), "spiel:" );
+                Text *name = d->getSoundName( i );
+                path->append( (const char *)( Text( "/" ) + (const char *)name->getText() ) );
+                name->release();
+                if( doesResourceExist( path->getText() ) )
+                    path->release();
+                else
+                    zPaths->add( path );
+            }
+        }
+    }
+}
+
 // löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
 Thread *KarteDaten::release()
 {

Asteroids/Editor/Karte/EditorKarte.h

@@ -7,6 +7,7 @@
 #include <functional>
 #include <Welt2D.h>
 #include <Model2D.h>
+#include <GSLDateiV.h>
 
 namespace Editor
 {
@@ -61,6 +62,8 @@ namespace Editor
     struct ObjektDaten : public Model
     {
         Punkt pos;
+        float rot;
+        float scale;
         int id;
         int m2d;
         int bild;
@@ -92,6 +95,17 @@ namespace Editor
         void update();
     };
 
+    class EdObjekt : public EditorObject
+    {
+    private:
+        ObjektDaten *mdl;
+
+    public:
+        EdObjekt( ObjektDaten *model );
+        ~EdObjekt();
+        void update();
+    };
+
     class UpdateObserver : public View
     {
     private:
@@ -102,14 +116,16 @@ namespace Editor
         void update( Model *m ) override;
     };
 
+    typedef GSL::GSLDateiV *( *GetGSLDatei )( );
+
     class KarteDaten : public Thread
     {
     private:
-        EditorKlient * client;
+        EditorKlient *client;
         SpielerTeamStruktur *sts;
-        Array< SpielerDaten* > spieler;
-        Array< TeamDaten* > teams;
-        Array< ObjektDaten* > objekte;
+        Array< SpielerDaten * > spieler;
+        Array< TeamDaten * > teams;
+        Array< ObjektDaten * > objekte;
         Array< ResourceDaten * > resources;
         Text error;
         Array< std::function< void() > > aktionen;
@@ -117,27 +133,42 @@ namespace Editor
         Welt2D *welt;
         RCArray< View > views;
         Punkt size;
+        GetGSLDatei getGSLDatei;
         bool exit;
 
+        void loadSpielResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths );
+
     public:
         KarteDaten( EditorKlient *client, SpielerTeamStruktur *sts );
         ~KarteDaten();
-        void addObjekt( ObjektDaten &daten );
+        void addObjekt( ObjektDaten &daten, std::function< void( int ) > callBack );
         void removeObjekt( int index );
         void thread() override;
-        const ObjektDaten *getObjekt( int index );
-        const SpielerDaten *getSpieler( int index );
-        const TeamDaten *getTeam( int index );
+        ResourceDaten *getResource( int index );
+        ObjektDaten *getObjekt( int index );
+        SpielerDaten *getSpieler( int index );
+        TeamDaten *getTeam( int index );
+        const char *getTeamName( int index );
         int getSpielerIndexById( int id );
         int getSpielerAnzahl() const;
         int getTeamIndexById( int id );
         int getTeamAnzahl() const;
+        int getObjektIndexById( int id );
         int getObjektAnzahl() const;
+        int getResourceIndexById( int id );
+        int getResourceAnzahl();
         bool hasError() const;
         char *getError() const;
         bool hasAktions() const;
         Welt2D *getWelt() const;
         Welt2D *zWelt() const;
+        void getResourceIdFromPath( const char *path, std::function< void( int ) > callBack );
+        bool doesResourceExist( const char *path );
+        Model2DData *loadModelFromRessource( int id );
+        Bild *loadBildFromRessource( int id );
+        Model2DData *loadModelFromPath( const char *path );
+        Bild *loadBildFromPath( const char *path );
+        void loadUnusedResourcePaths( std::function< void( RCArray< Text > * ) > callBack );
         // löscht das objekt wenn es nicht mehr gebraucht wird und beendet den Thread
         Thread *release() override;
     };

Asteroids/Editor/Netzwerk/EditorKlient.cpp

@@ -258,6 +258,8 @@ bool EditorKlient::saveObjekt( const ObjektDaten *objekt )
     {
         k->sendeEncrypted( (char *)& objekt->pos.x, 4 );
         k->sendeEncrypted( (char *)& objekt->pos.y, 4 );
+        k->sendeEncrypted( (char *)& objekt->rot, 4 );
+        k->sendeEncrypted( (char *)& objekt->scale, 4 );
         k->sendeEncrypted( (char *)& objekt->id, 4 );
         k->sendeEncrypted( (char *)& objekt->m2d, 4 );
         k->sendeEncrypted( (char *)& objekt->bild, 4 );
@@ -362,6 +364,47 @@ bool EditorKlient::loadResources( Array< ResourceDaten * > &resources )
     return ret == 1;
 }
 
+int EditorKlient::addResource( const char *path )
+{
+    Network::Klient *k = klient->beginEditorMessage();
+    if( !k )
+    {
+        error = klient->getLetzterFehler();
+        return 0;
+    }
+    error = "";
+    char ret;
+    k->sendeEncrypted( "\xC", 1 );
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        unsigned char len = (unsigned char)strlen( path );
+        k->sendeEncrypted( (char *)& len, 1 );
+        k->sendeEncrypted( path, len );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            int id = 0;
+            k->getNachrichtEncrypted( (char *)& id, 4 );
+            klient->endEditorMessage();
+            return id;
+        }
+    }
+    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 0;
+}
+
 bool EditorKlient::loadSpieler( Array< SpielerDaten * > &spieler )
 {
     Network::Klient *k = klient->beginEditorMessage();
@@ -492,6 +535,8 @@ bool EditorKlient::loadObjekte( Array< ObjektDaten * > &objekte )
             ObjektDaten *objekt = new ObjektDaten();
             k->getNachrichtEncrypted( (char *)& objekt->pos.x, 4 );
             k->getNachrichtEncrypted( (char *)& objekt->pos.y, 4 );
+            k->getNachrichtEncrypted( (char *)& objekt->rot, 4 );
+            k->getNachrichtEncrypted( (char *)& objekt->scale, 4 );
             k->getNachrichtEncrypted( (char *)& objekt->id, 4 );
             k->getNachrichtEncrypted( (char *)& objekt->m2d, 4 );
             k->getNachrichtEncrypted( (char *)& objekt->bild, 4 );
@@ -610,6 +655,55 @@ Model2DData *EditorKlient::loadModel( const char *templatePath )
     return 0;
 }
 
+RCArray< Text > *EditorKlient::getAllMapResourcePaths()
+{
+    klient->deResetPath();
+    RCArray< Text > *result = new RCArray< Text >();
+    loadMapResourcePathsFromFolder( "map:", result );
+    return result;
+}
+
+void EditorKlient::loadMapResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths )
+{
+    RCArray< Text > *files = new RCArray< Text >();
+    klient->deGetDateiListe( files );
+    for( auto f = files->getIterator(); f; f++ )
+    {
+        Text path( folderPath );
+        path += Text( "/" ) + *f._;
+        if( !f->hat( "." ) )
+        {
+            klient->deOrdnerÖffnen( f );
+            loadMapResourcePathsFromFolder( path, zPaths );
+        }
+        else if( f->hat( ".ltdb" ) )
+        {
+            RCArray< Text > *bilder = new RCArray< Text >();
+            klient->deGetBildListe( f, bilder );
+            for( auto n = bilder->getIterator(); n; n++ )
+                zPaths->add( new Text( path + "/" + *n._ ) );
+            bilder->release();
+        }
+        else if( f->hat( ".m2" ) )
+        {
+            RCArray< Text > *models = new RCArray< Text >();
+            klient->deGetModelListe( f, models );
+            for( auto n = models->getIterator(); n; n++ )
+                zPaths->add( new Text( path + "/" + *n._ ) );
+            models->release();
+        }
+        else if( f->hat( ".gsl" ) )
+        {
+            RCArray< Text > *sounds = new RCArray< Text >();
+            klient->deGetSoundListe( f, sounds );
+            for( auto n = sounds->getIterator(); n; n++ )
+                zPaths->add( new Text( path + "/" + *n._ ) );
+            sounds->release();
+        }
+    }
+    files->release();
+}
+
 // Lädt die Spieler Team Struktur
 bool EditorKlient::getSpielerTeamStruktur( SpielerTeamStrukturV * sts )
 {

Asteroids/Editor/Netzwerk/EditorKlient.h

@@ -26,6 +26,8 @@ namespace Editor
         Text error;
         int ref;
 
+        void loadMapResourcePathsFromFolder( const char *folderPath, RCArray< Text > *zPaths );
+
     public:
         // Konstruktor
         //  k: Der zu verwendende Klient
@@ -49,11 +51,13 @@ namespace Editor
         bool saveObjekt( const ObjektDaten *objekt );
         bool deleteObjekt( int id );
         bool loadResources( Array< ResourceDaten * > &resources );
+        int addResource( const char *path );
         bool loadSpieler( Array< SpielerDaten* > &spieler );
         bool loadTeams( Array< TeamDaten* > &teams );
         bool loadObjekte( Array< ObjektDaten* > &Objekte );
         Bild *loadBild( const char *templatePath );
         Model2DData *loadModel( const char *templatePath );
+        RCArray< Text > *getAllMapResourcePaths();
         // Gibt den Letzten Fehler zurück
         char *getLastError() const;
         // Reference Counting

Asteroids/Spiel/Karte/Strukturen.cpp

@@ -6,202 +6,204 @@
 // Konstruktor
 RessourceStr::RessourceStr( Datei *zDatei, int karteId, Text *zGamePath )
 {
-	zDatei->lese( (char*)&id, 4 );
-	char län = 0;
-	zDatei->lese( &län, 1 );
-	Text txt;
-	txt.fillText( '0', län + 1 );
-	zDatei->lese( txt, län );
-	txt.getText()[ län ] = 0;
-	pfad = 0;
-	if( txt.positionVon( "spiel:" ) == 0 )
-	{
-		pfad = new Text( zGamePath->getText() );
-		if( pfad )
-			pfad->append( txt.getTeilText( 6 ) );
-	}
-	if( txt.positionVon( "map:" ) == 0 )
+    zDatei->lese( (char *)& id, 4 );
+    char län = 0;
+    zDatei->lese( &län, 1 );
+    Text txt;
+    txt.fillText( '0', län + 1 );
+    zDatei->lese( txt, län );
+    txt.getText()[ län ] = 0;
+    pfad = 0;
+    if( txt.positionVon( "spiel:" ) == 0 )
+    {
+        pfad = new Text( zGamePath->getText() );
+        if( pfad )
+            pfad->append( txt.getTeilText( 6 ) );
+    }
+    if( txt.positionVon( "map:" ) == 0 )
     {
         pfad = new Text( "data/tmp/Karten/" );
         pfad->append( karteId );
         pfad->append( "/spiel/files" );
-		pfad->append( txt.getTeilText( 4 ) );
-	}
-	m2d = 0;
-	bild = 0;
-	if( pfad && pfad->hat( ".m2/" ) )
-	{
-		int pos = pfad->positionVon( ".m2/", pfad->anzahlVon( ".m2/" ) - 1 );
-		M2Datei *datei = new M2Datei( pfad->getTeilText( 0, pos + 3 ) );
-		datei->leseDaten();
-		m2d = datei->ladeModel( pfad->getTeilText( pos + 4 ) );
-		datei->release();
-	}
-	if( pfad && pfad->hat( ".ltdb/" ) )
-	{
-		int pos = pfad->positionVon( ".ltdb/", pfad->anzahlVon( ".ltdb/" ) - 1 );
-		LTDBDatei *datei = new LTDBDatei();
-		datei->setDatei( pfad->getTeilText( 0, pos + 5 ) );
-		datei->leseDaten( 0 );
-		bild = datei->laden( 0, pfad->getTeilText( pos + 6 ) );
-		datei->release();
-	}
-	ref = 1;
+        pfad->append( txt.getTeilText( 4 ) );
+    }
+    m2d = 0;
+    bild = 0;
+    if( pfad && pfad->hat( ".m2/" ) )
+    {
+        int pos = pfad->positionVon( ".m2/", pfad->anzahlVon( ".m2/" ) - 1 );
+        M2Datei * datei = new M2Datei( pfad->getTeilText( 0, pos + 3 ) );
+        datei->leseDaten();
+        m2d = datei->ladeModel( pfad->getTeilText( pos + 4 ) );
+        datei->release();
+    }
+    if( pfad && pfad->hat( ".ltdb/" ) )
+    {
+        int pos = pfad->positionVon( ".ltdb/", pfad->anzahlVon( ".ltdb/" ) - 1 );
+        LTDBDatei * datei = new LTDBDatei();
+        datei->setDatei( pfad->getTeilText( 0, pos + 5 ) );
+        datei->leseDaten( 0 );
+        bild = datei->laden( 0, pfad->getTeilText( pos + 6 ) );
+        datei->release();
+    }
+    ref = 1;
 }
 
 // Destruktor
 RessourceStr::~RessourceStr()
 {
-	if( pfad )
-		pfad->release();
-	if( m2d )
-		m2d->release();
-	if( bild )
-		bild->release();
+    if( pfad )
+        pfad->release();
+    if( m2d )
+        m2d->release();
+    if( bild )
+        bild->release();
 }
 
 // constant
 int RessourceStr::getId() const
 {
-	return id;
+    return id;
 }
 
 Model2DData *RessourceStr::zReccourceM2() const
 {
-	return m2d;
+    return m2d;
 }
 
 Bild *RessourceStr::zReccourceTxt() const
 {
-	return bild;
+    return bild;
 }
 
 // Reference Counting
 RessourceStr *RessourceStr::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 RessourceStr *RessourceStr::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
 // Inhalt der ZeichnungStr Klasse aus Strukturen.h
 // Konstruktor
-ObjektStr::ObjektStr( Datei *zDatei )
-{
-	zDatei->lese( (char*)&pos.x, 4 );
-	zDatei->lese( (char*)&pos.y, 4 );
-	zDatei->lese( (char*)&id, 4 );
-	zDatei->lese( (char*)&m2d, 4 );
-	zDatei->lese( (char*)&bild, 4 );
-	zDatei->lese( (char*)&style, 4 );
-	zDatei->lese( (char*)&maxStabilität, 4 );
-	zDatei->lese( (char*)&maxEnergie, 4 );
-	zDatei->lese( (char*)&energieRadius, 4 );
-	zDatei->lese( (char*)&reparatur, 8 );
-	zDatei->lese( (char*)&akkuLeistung, 8 );
-	zDatei->lese( &team, 1 );
-	ref = 1;
+ObjektStr::ObjektStr( Datei * zDatei )
+{
+    zDatei->lese( (char *)& pos.x, 4 );
+    zDatei->lese( (char *)& pos.y, 4 );
+    zDatei->lese( (char *)& rot, 4 );
+    zDatei->lese( (char *)& scale, 4 );
+    zDatei->lese( (char *)& id, 4 );
+    zDatei->lese( (char *)& m2d, 4 );
+    zDatei->lese( (char *)& bild, 4 );
+    zDatei->lese( (char *)& style, 4 );
+    zDatei->lese( (char *)& maxStabilität, 4 );
+    zDatei->lese( (char *)& maxEnergie, 4 );
+    zDatei->lese( (char *)& energieRadius, 4 );
+    zDatei->lese( (char *)& reparatur, 8 );
+    zDatei->lese( (char *)& akkuLeistung, 8 );
+    zDatei->lese( &team, 1 );
+    ref = 1;
 }
 
 // Reference Counting
 ObjektStr *ObjektStr::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 ObjektStr *ObjektStr::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 
 // Inhalt der SpielerStr Klasse aus Strukturen.h
 // Konstruktor
-SpielerStr::SpielerStr( Datei *zDatei )
-{
-	zDatei->lese( (char*)&id, 4 );
-	zDatei->lese( (char*)&pos.x, 4 );
-	zDatei->lese( (char*)&pos.y, 4 );
-	zDatei->lese( (char*)&rot, 8 );
-	zDatei->lese( (char*)&beschleunigung, 8 );
-	zDatei->lese( (char*)&maxStabilität, 4 );
-	zDatei->lese( (char*)&maxEnergie, 4 );
-	zDatei->lese( (char*)&reparatur, 8 );
-	zDatei->lese( (char*)&akkuLeistung, 8 );
-	zDatei->lese( (char*)&laserIntensität, 4 );
-	zDatei->lese( (char*)&laserEffizienz, 4 );
-	zDatei->lese( (char*)&laserTempo, 4 );
-	zDatei->lese( (char*)&wendigkeit, 8 );
-    zDatei->lese( (char*)&antriebEffizienz, 8 );
-    zDatei->lese( (char*)&energieSchild, 8 );
-    zDatei->lese( (char*)&energieSchildEffizienz, 8 );
-	zDatei->lese( (char*)&netzwerk, 4 );
-	zDatei->lese( (char*)&skillPunkte, 4 );
-	zDatei->lese( (char*)&m2d, 4 );
-	zDatei->lese( (char*)&bild, 4 );
-	ref = 1;
+SpielerStr::SpielerStr( Datei * zDatei )
+{
+    zDatei->lese( (char *)& id, 4 );
+    zDatei->lese( (char *)& pos.x, 4 );
+    zDatei->lese( (char *)& pos.y, 4 );
+    zDatei->lese( (char *)& rot, 8 );
+    zDatei->lese( (char *)& beschleunigung, 8 );
+    zDatei->lese( (char *)& maxStabilität, 4 );
+    zDatei->lese( (char *)& maxEnergie, 4 );
+    zDatei->lese( (char *)& reparatur, 8 );
+    zDatei->lese( (char *)& akkuLeistung, 8 );
+    zDatei->lese( (char *)& laserIntensität, 4 );
+    zDatei->lese( (char *)& laserEffizienz, 4 );
+    zDatei->lese( (char *)& laserTempo, 4 );
+    zDatei->lese( (char *)& wendigkeit, 8 );
+    zDatei->lese( (char *)& antriebEffizienz, 8 );
+    zDatei->lese( (char *)& energieSchild, 8 );
+    zDatei->lese( (char *)& energieSchildEffizienz, 8 );
+    zDatei->lese( (char *)& netzwerk, 4 );
+    zDatei->lese( (char *)& skillPunkte, 4 );
+    zDatei->lese( (char *)& m2d, 4 );
+    zDatei->lese( (char *)& bild, 4 );
+    ref = 1;
 }
 
 // Reference Counting
 SpielerStr *SpielerStr::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 SpielerStr *SpielerStr::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }
 
 // Inhalt der TeamStr Klasse aus Strukturen.h
 // Konstruktor
-TeamStr::TeamStr( Datei *zDatei )
-{
-	zDatei->lese( (char*)&id, 4 );
-	zDatei->lese( (char*)&maxPunkte, 4 );
-	zDatei->lese( (char*)&beschleunigung, 8 );
-	zDatei->lese( (char*)&maxStabilität, 4 );
-	zDatei->lese( (char*)&maxEnergie, 4 );
-	zDatei->lese( (char*)&reparatur, 8 );
-	zDatei->lese( (char*)&akkuLeistung, 8 );
-	zDatei->lese( (char*)&laserIntensität, 4 );
-	zDatei->lese( (char*)&laserEffizienz, 4 );
-	zDatei->lese( (char*)&laserTempo, 4 );
-	zDatei->lese( (char*)&wendigkeit, 8 );
-    zDatei->lese( (char*)&antriebEffizienz, 8 );
-    zDatei->lese( (char*)&energieSchild, 8 );
-    zDatei->lese( (char*)&energieSchildEffizienz, 8 );
-	zDatei->lese( (char*)&punkte, 4 );
-	ref = 1;
+TeamStr::TeamStr( Datei * zDatei )
+{
+    zDatei->lese( (char *)& id, 4 );
+    zDatei->lese( (char *)& maxPunkte, 4 );
+    zDatei->lese( (char *)& beschleunigung, 8 );
+    zDatei->lese( (char *)& maxStabilität, 4 );
+    zDatei->lese( (char *)& maxEnergie, 4 );
+    zDatei->lese( (char *)& reparatur, 8 );
+    zDatei->lese( (char *)& akkuLeistung, 8 );
+    zDatei->lese( (char *)& laserIntensität, 4 );
+    zDatei->lese( (char *)& laserEffizienz, 4 );
+    zDatei->lese( (char *)& laserTempo, 4 );
+    zDatei->lese( (char *)& wendigkeit, 8 );
+    zDatei->lese( (char *)& antriebEffizienz, 8 );
+    zDatei->lese( (char *)& energieSchild, 8 );
+    zDatei->lese( (char *)& energieSchildEffizienz, 8 );
+    zDatei->lese( (char *)& punkte, 4 );
+    ref = 1;
 }
 
 // Reference Counting
 TeamStr *TeamStr::getThis()
 {
-	ref++;
-	return this;
+    ref++;
+    return this;
 }
 
 TeamStr *TeamStr::release()
 {
-	ref--;
-	if( !ref )
-		delete this;
-	return 0;
+    ref--;
+    if( !ref )
+        delete this;
+    return 0;
 }

Asteroids/Spiel/Karte/Strukturen.h

@@ -38,6 +38,8 @@ private:
 
 public:
 	Punkt pos;
+    float rot;
+    float scale;
 	int id;
 	int m2d;
 	int bild;