EditorClient hinzugefügt

Include/KSGNetwork.h

@@ -18,6 +18,7 @@ namespace Framework
 namespace GSL
 {
     class GSLSoundV;
+    class GSLDateiV;
 }
 
 namespace Network
@@ -1259,7 +1260,7 @@ namespace KSGClient
         //  zBild: Das neue Bild (ohne erhöhten Reference Counter)
         //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
         //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool deBildSpeichern( Framework::Text *zDatei, Framework::Text *zName, Framework::Bild *zBild, Framework::FBalken *zF ) = 0; // DateienEditor: Speichert Bild
+        virtual bool deBildSpeichern( Framework::Text *zDatei, Framework::Text *zName, Framework::Bild *zBild, Framework::FBalken *zF ) = 0;
         // Lädt eine Liste mit Dateien im aktuellen Ordner des Datei Editors
         //  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit Dateinamen (ohne erhöhten Reference Counter)
         //  Gibt die Anzahl der Dateien zurück
@@ -1295,11 +1296,12 @@ namespace KSGClient
         //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
         virtual Framework::Model2DData *deModelLaden( Framework::Text *zDatei, Framework::Text *zModel, Framework::FBalken *zF ) = 0;
         // Lädt einen Sound herunter und gibt ihn zurück
+        //  file: Ein Zeiger auf die GSLDatei, in der der Sound gespeichert werden soll
         //  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
         //  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
         //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
         //  Gibt bei misserfolg 0 zurück
-        virtual GSL::GSLSoundV *deSoundLaden( Framework::Text *zDatei, Framework::Text *zSound, Framework::FBalken *zF ) = 0;
+        virtual GSL::GSLSoundV *deSoundLaden( GSL::GSLDateiV *file, Framework::Text *zDatei, Framework::Text *zSound, Framework::FBalken *zF ) = 0;
         // Speichert ein Model in eine Modeldatei des Datei Editors
         //  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
         //  zModel: Der Name des Models (ohne erhöhten Reference Counter)

KSGNetwork/EditorClient.cpp

@@ -0,0 +1,3202 @@
+#include "EditorClient.h"
+#include <Klient.h>
+#include "Keys.h"
+#include <Datei.h>
+#include <Zeit.h>
+#include <Bild.h>
+#include <Fortschritt.h>
+#include <Model2D.h>
+#include <GSLDateiV.h>
+
+using namespace KSGClient;
+
+
+class DownloadSound : public GSL::GSLSoundV
+{
+private:
+    bool istM;
+    int sample;
+    __int64 län;
+    Network::Klient *k;
+    FBalken *f;
+    int ref;
+
+public:
+    // Konstruktor
+    DownloadSound( Network::Klient *zK, FBalken *zF )
+    {
+        k = zK;
+        f = zF;
+        ref = 1;
+    }
+    // nicht constant
+    // GSL
+    void playSound() override
+    {}
+    void setPause( bool p ) override
+    {}
+    void stopSound() override
+    {}
+    void warteAufSound( int zeit ) override
+    {}
+    // Lautstärke: 0 - 0xFFFF
+    void setVolume( unsigned int links, unsigned int rechts ) override
+    {}
+    // zum Speichern
+    void open() override
+    {
+        char m = 0;
+        k->getNachrichtEncrypted( &m, 1 );
+        istM = ( m == 1 );
+        sample = 0;
+        k->getNachrichtEncrypted( (char*)&sample, 4 );
+        län = 0;
+        k->getNachrichtEncrypted( (char*)&län, 8 );
+        f->setAktionAnzahl( län );
+    }
+    int getDaten( char *buffer, int län ) override
+    {
+        int l = län < this->län ? län : (int)this->län;
+        if( !l )
+            return -1;
+        k->getNachricht( buffer, l );
+        this->län -= l;
+        f->aktionPlus( l );
+        return l;
+    }
+    void close() override
+    {}
+    bool istMono() const override
+    {
+        return istM;
+    }
+    int getSampleRate() const override
+    {
+        return sample;
+    }
+    __int64 getDatLength() const override
+    {
+        return län;
+    }
+    // Reference Counting
+    GSL::GSLSoundV *getThis() override
+    {
+        ref++;
+        return this;
+    }
+    GSL::GSLSoundV *release() override
+    {
+        ref--;
+        if( !ref )
+            delete this;
+        return 0;
+    }
+};
+
+// Inhalt der KSGClient Klasse
+
+// Konstruktor
+EditorClient::EditorClient( int kId, unsigned short port, char *ip, char *key, unsigned char keyLen )
+{
+    ref = 1;
+    this->ip = ip;
+    this->port = port;
+    cId = kId;
+    k = 0;
+    this->key = new char[ keyLen ];
+    memcpy( this->key, key, keyLen );
+    this->keyLen = keyLen;
+}
+
+// Destruktor
+EditorClient::~EditorClient()
+{
+    trenne( 1 );
+    delete[] key;
+}
+
+// verbindet sich mit dem zugewiesenen Editor Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::verbinde()
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::LOGIN, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::LOGIN, Keys::EMPFANGEN );
+    k->setEmpfangKey( key, l );
+    delete[] key;
+    if( k->verbinde( port, ip ) )
+    {
+        if( k->sendeEncrypted( "\1", 1 ) )
+        {
+            k->sendeEncrypted( (char*)&cId, 4 );
+            char serverReturn = 0;
+            k->getNachrichtEncrypted( &serverReturn, 1 );
+            if( serverReturn == 3 )
+            {
+                char byte = 0;
+                k->getNachrichtEncrypted( &byte, 1 );
+                char *f = new char[ byte + 1 ];
+                f[ byte ] = 0;
+                k->getNachrichtEncrypted( f, byte );
+                err = "error while identifying client Editor Server returned: ";
+                err += f;
+                delete[]f;
+                trenne( 0 );
+                cs.unlock();
+                return 0;
+            }
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
+        }
+        else
+        {
+            err = "network error while sending to Editor Server";
+            k = k->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "network error while connecting to Editor Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Erstellt eine neue Karte
+//  name: Der Name der Karte
+//  spielArt: Die Id des Spiels
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::karteErstellen( char *name, int spielArt )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xA", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        char l = (char)textLength( name );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( name, l );
+        k->sendeEncrypted( (char*)&spielArt, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// lädt eine bestimmte Karte
+//  id: Die Id der Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ladeKarte( int id )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x6", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( (char*)&id, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// gibt eine Liste mit Abbildern der geladenen Karte zurück
+//  name: Enthält nach erfolgreichem Aufruf eine Liste mit Namen der Abbilder
+//  datum: Enthält nach erfolgreichem Aufruf eine Liste mit dem Datum der Erstellung für jedes Abbild
+//  Gibt die Anzahl der Abbilder zurück
+int EditorClient::getAbbildListe( Framework::RCArray< Framework::Text > *name, Framework::RCArray< Framework::Zeit > *datum )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        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++ )
+            {
+                char l = 0;
+                k->getNachrichtEncrypted( &l, 1 );
+                char *n = new char[ l + 1 ];
+                n[ l ] = 0;
+                k->getNachrichtEncrypted( n, l );
+                name->set( new Text( n ), i );
+                delete[] n;
+                Zeit *dat = new Zeit();
+                int d = 0;
+                k->getNachrichtEncrypted( (char*)&d, 4 );
+                dat->setJahr( d );
+                k->getNachrichtEncrypted( (char*)&d, 4 );
+                dat->setMonat( d );
+                k->getNachrichtEncrypted( (char*)&d, 4 );
+                dat->setTag( d );
+                k->getNachrichtEncrypted( (char*)&d, 4 );
+                dat->setStunde( d );
+                k->getNachrichtEncrypted( (char*)&d, 4 );
+                dat->setMinute( d );
+                k->getNachrichtEncrypted( (char*)&d, 4 );
+                dat->setSekunde( d );
+                datum->set( dat, i );
+            }
+            cs.unlock();
+            return anz;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Erstellt ein neues Abbild der geladenen Karte
+//  name: Der Name des Abbildes
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::abbildErstellen( char *name )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x1", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            char l = (char)textLength( name );
+            k->sendeEncrypted( &l, 1 );
+            if( l )
+                k->sendeEncrypted( name, l );
+            k->getNachrichtEncrypted( &ret, 1 );
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Löscht ein altes Abbild der geladenen Karte
+//  name: Der Name des Abbildes
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::abbildLöschen( char *name )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x2", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            char l = (char)textLength( name );
+            k->sendeEncrypted( &l, 1 );
+            if( l )
+                k->sendeEncrypted( name, l );
+            k->getNachrichtEncrypted( &ret, 1 );
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Stellt ein altes Abbild der geladenen Karte wieder her
+//  name: Der Name des Abbildes
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::abbildHerstellen( char *name )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x3", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            char l = (char)textLength( name );
+            k->sendeEncrypted( &l, 1 );
+            if( l )
+                k->sendeEncrypted( name, l );
+            k->getNachrichtEncrypted( &ret, 1 );
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Verüffentlich eine neue Version der geladenen Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::veröffentlichen()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x4", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+            k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Veröffentlich eine neue Version der Shop Seite der geladenen Karte
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::shopSeiteVeröffentlichen()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x6", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+            k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Läht die Vorschau der Shop Seite der geladenen Karte herrunter und speichert sie unter data/tmp/ke/ssv
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ladeShopSeiteVorschau()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x8", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            int anz = 0;
+            k->getNachrichtEncrypted( (char*)&anz, 4 );
+            Text pf = "data/tmp/ke/ssv";
+            for( int i = 0; i < anz; i++ )
+            {
+                char l = 0;
+                k->getNachrichtEncrypted( &l, 1 );
+                char *pfad = new char[ l + 1 ];
+                pfad[ l ] = 0;
+                k->getNachrichtEncrypted( pfad, l );
+                Text p = pf.getText();
+                p += pfad;
+                delete[] pfad;
+                Datei d;
+                d.setDatei( p );
+                d.erstellen();
+                d.open( Datei::Style::schreiben );
+                __int64 größe = 0;
+                k->getNachrichtEncrypted( (char*)&größe, 8 );
+                char *buffer = new char[ 2048 ];
+                while( größe > 0 )
+                {
+                    int l = größe > 2048 ? 2048 : (int)größe;
+                    k->getNachricht( buffer, l );
+                    d.schreibe( buffer, l );
+                    größe -= l;
+                }
+                delete[] buffer;
+                d.close();
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Erstellt eine neue Shop Seiten Datei
+//  name: Der Name der Datei
+//  typ: 0=Ordner, 1=Bild, 2=Text
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ssDateiErstellen( char *name, int typ )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x1", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char t = typ;
+                k->sendeEncrypted( &t, 1 );
+                char l = (char)textLength( name );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( name, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Öffnet einen Ordner der Shop Seite
+//  name: Der Name des Ordners
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ssOrdnerÖffnen( char *name )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x2", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( name );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( name, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt das ein Bild der Shop Seite und gibt es zurück
+//  datei: Der Name der Bilddatei
+//  bild: Der Name des Bildes
+//  Gibt bei misserfolg 0 zurück
+Framework::Bild *EditorClient::ssBildLaden( char *datei, char *bild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x3", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( datei );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( datei, l );
+                l = (char)textLength( bild );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( bild, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    Bild *ret = new Bild();
+                    int br = 0;
+                    int hö = 0;
+                    k->getNachrichtEncrypted( (char*)&br, 4 );
+                    k->getNachrichtEncrypted( (char*)&hö, 4 );
+                    ret->neuBild( br, hö, 0 );
+                    char *buffer = (char*)ret->getBuffer();
+                    __int64 län = br * hö * 4;
+                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
+                    {
+                        k->getNachricht( &( buffer[ i ] ), l );
+                        i += l;
+                        län -= l;
+                    }
+                    cs.unlock();
+                    return ret;
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Löscht eine Datei der Shop Seite
+//  name: Der Name der Datei
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ssDateiLöschen( char *name )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x4", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( name );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( name, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Läd eine KSGS Datei der Shop Seite und gibt den Quellcode zurück
+//  datei: Der Name der Datei
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *EditorClient::ssTextLaden( char *datei )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xA", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( datei );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( datei, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int län = 0;
+                    k->getNachrichtEncrypted( (char*)&län, 4 );
+                    char *txt = new char[ län + 1 ];
+                    txt[ län ] = 0;
+                    for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
+                        k->getNachricht( &( txt[ i ] ), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                    if( ret == 1 )
+                    {
+                        Text *t = new Text( txt );
+                        delete[] txt;
+                        cs.unlock();
+                        return t;
+                    }
+                    delete[] txt;
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Spechert eine KSGS Datei der Shop Seite
+//  datei: Der Name der Datei
+//  zText: Ein Zeiger auf den neuen Quellcode (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ssTextSpeichern( char *datei, Framework::Text *zText )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x5", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( datei );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( datei, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int län = zText->getLength();
+                    k->sendeEncrypted( (char*)&län, 4 );
+                    for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
+                        k->sende( &( zText->getText()[ i ] ), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Löscht ein Bild der Shop Seite
+//  datei: Der Name der Bilddatei
+//  bild: Der Name des Bildes
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ssBildLöschen( char *datei, char *bild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x6", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( datei );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( datei, l );
+                l = (char)textLength( bild );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( bild, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Speichert ein Bild einer ShopSeite
+//  datei: Der name der Bilddatei
+//  name: Der Name des Bildes
+//  zBild: Ein Zeiger auf das Bild (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ssBildSpeichern( char *datei, char *name, Framework::Bild *zBild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x7", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( datei );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( datei, l );
+                l = (char)textLength( name );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( name, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int br = zBild->getBreite();
+                    int hö = zBild->getHeight();
+                    k->sendeEncrypted( (char*)&br, 4 );
+                    k->sendeEncrypted( (char*)&hö, 4 );
+                    __int64 län = br * hö * 4;
+                    char *buffer = (char*)zBild->getBuffer();
+                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
+                        k->sende( &( buffer[ i ] ), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt eine Liste mit Dateien von der Shop Seite
+//  zList: Enthält nach erfolgreichem Aufruf die Liste mit Dateinamen
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+int EditorClient::ssGetDateiListe( Framework::RCArray< Framework::Text > *zList )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x8", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int anz = 0;
+                k->getNachrichtEncrypted( (char*)&anz, 4 );
+                for( int i = 0; i < anz; i++ )
+                {
+                    char l = 0;
+                    k->getNachrichtEncrypted( &l, 1 );
+                    char *n = new char[ l + 1 ];
+                    n[ l ] = 0;
+                    k->getNachrichtEncrypted( n, l );
+                    zList->add( new Text( n ) );
+                    delete[] n;
+                }
+                cs.unlock();
+                return anz;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return -1;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Lädt die Bild Liste einer Bild Datei der Shop Seite
+//  name: Der Name der Bilddatei
+//  zList: Enthält nach erfolgreichem Aufruf eine Liste mit Bildnamen
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+int EditorClient::ssGetBildListe( char *name, Framework::RCArray< Framework::Text > *zList )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x7", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x9", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)textLength( name );
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( name, l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int anz = 0;
+                    k->getNachrichtEncrypted( (char*)&anz, 4 );
+                    for( int i = 0; i < anz; i++ )
+                    {
+                        l = 0;
+                        k->getNachrichtEncrypted( &l, 1 );
+                        char *n = new char[ l + 1 ];
+                        n[ l ] = 0;
+                        k->getNachrichtEncrypted( n, l );
+                        zList->add( new Text( n ) );
+                        delete[] n;
+                    }
+                    cs.unlock();
+                    return anz;
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return -1;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Lädt die Shop Daten
+//  es: Enthält nach erfolgreichem aufruf den Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+//  tp: Enthält nach erfolgreichem Aufruf den Preis der Testversion in Kupfer
+//  vp: Enthält nach erfolgreichem Aufruf den Preis der Vollversion in Kupfer
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::getShopDaten( int &es, int &tp, int &vp )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x9", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->getNachrichtEncrypted( (char*)&es, 4 );
+            k->getNachrichtEncrypted( (char*)&tp, 4 );
+            k->getNachrichtEncrypted( (char*)&vp, 4 );
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Setzt die Shop Daten
+//  es: der Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+//  tp: der Preis der Testversion in Kupfer
+//  vp: der Preis der Vollversion in Kupfer
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::setShopDaten( int es, int tp, int vp )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xA", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( (char*)&es, 4 );
+            k->sendeEncrypted( (char*)&tp, 4 );
+            k->sendeEncrypted( (char*)&vp, 4 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                cs.unlock();
+                return 1;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// gibt die Kartenbeschreibung als KSGScript Quellcode zurück
+//  Gibt bei misserfolg 0 zurück
+Framework::Text *EditorClient::beschreibungLaden()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x1", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int län = 0;
+                k->getNachrichtEncrypted( (char*)&län, 4 );
+                char *txt = new char[ län + 1 ];
+                txt[ län ] = 0;
+                for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
+                    k->getNachricht( &( txt[ i ] ), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    Text *t = new Text( txt );
+                    delete[] txt;
+                    cs.unlock();
+                    return t;
+                }
+                delete[] txt;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// gibt das Titelbild der Karte zurück
+//  Gibt bei misserfolg 0 zurück
+Framework::Bild *EditorClient::titelbildLaden()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x2", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                Bild *ret = new Bild();
+                int br = 0;
+                int hö = 0;
+                k->getNachrichtEncrypted( (char*)&br, 4 );
+                k->getNachrichtEncrypted( (char*)&hö, 4 );
+                ret->neuBild( br, hö, 0 );
+                char *buffer = (char*)ret->getBuffer();
+                __int64 län = br * hö * 4;
+                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
+                {
+                    k->getNachricht( &( buffer[ i ] ), l );
+                    i += l;
+                    län -= l;
+                }
+                cs.unlock();
+                return ret;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// gibt das Minimap Bild der Karte zurück
+//  Gibt bei misserfolg 0 zurück
+Framework::Bild *EditorClient::minimapLaden()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x3", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                Bild *ret = new Bild();
+                int br = 0;
+                int hö = 0;
+                k->getNachrichtEncrypted( (char*)&br, 4 );
+                k->getNachrichtEncrypted( (char*)&hö, 4 );
+                ret->neuBild( br, hö, 0 );
+                char *buffer = (char*)ret->getBuffer();
+                __int64 län = br * hö * 4;
+                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
+                {
+                    k->getNachricht( &( buffer[ i ] ), l );
+                    i += l;
+                    län -= l;
+                }
+                cs.unlock();
+                return ret;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// gibt das Ladebild der Karte zurück
+//  Gibt bei misserfolg 0 zurück
+Framework::Bild *EditorClient::ladebildLaden()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x4", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                Bild *ret = new Bild();
+                int br = 0;
+                int hö = 0;
+                k->getNachrichtEncrypted( (char*)&br, 4 );
+                k->getNachrichtEncrypted( (char*)&hö, 4 );
+                ret->neuBild( br, hö, 0 );
+                char *buffer = (char*)ret->getBuffer();
+                __int64 län = br * hö * 4;
+                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
+                {
+                    k->getNachricht( &( buffer[ i ] ), l );
+                    i += l;
+                    län -= l;
+                }
+                cs.unlock();
+                return ret;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// speichert den KSGScript Quellcode der Kartenbeschreibung
+//  zText: Der KSGScript Quellcode (ohne erhöhten reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::beschreibungSpeichern( Framework::Text *zText )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x5", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int län = zText->getLength();
+                k->sendeEncrypted( (char*)&län, 4 );
+                for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
+                    k->sende( &( zText->getText()[ i ] ), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// speichert das Titelbild der Karte
+//  zBild: das neue Titelbild
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::titelbildSpeichern( Framework::Bild *zBild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x6", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int br = zBild->getBreite();
+                int hö = zBild->getHeight();
+                k->sendeEncrypted( (char*)&br, 4 );
+                k->sendeEncrypted( (char*)&hö, 4 );
+                __int64 län = br * hö * 4;
+                char *buffer = (char*)zBild->getBuffer();
+                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
+                    k->sende( &( buffer[ i ] ), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// speichert das Minimapbild der Karte
+//  zBild: das neue Minimapbild
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::minimapSpeichern( Framework::Bild *zBild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x7", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int br = zBild->getBreite();
+                int hö = zBild->getHeight();
+                k->sendeEncrypted( (char*)&br, 4 );
+                k->sendeEncrypted( (char*)&hö, 4 );
+                __int64 län = br * hö * 4;
+                char *buffer = (char*)zBild->getBuffer();
+                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
+                    k->sende( &( buffer[ i ] ), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// speichert das Ladebild der Karte
+//  zBild: das neue Ladebild
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ladebildSpeichern( Framework::Bild *zBild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xB", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x8", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int br = zBild->getBreite();
+                int hö = zBild->getHeight();
+                k->sendeEncrypted( (char*)&br, 4 );
+                k->sendeEncrypted( (char*)&hö, 4 );
+                __int64 län = br * hö * 4;
+                char *buffer = (char*)zBild->getBuffer();
+                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
+                    k->sende( &( buffer[ i ] ), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// lädt die Spieler Team Daten der Karte
+//  sts: Enthält nach erfolgreichem Aufruf die Spieler Team Daten
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::ladeTeamDaten( SpielerTeamStrukturV *sts )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xC", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x1", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                k->getNachrichtEncrypted( (char*)&sts->spielerAnzahl, 4 );
+                k->getNachrichtEncrypted( (char*)&sts->teamAnzahl, 4 );
+                for( int i = 0; i < sts->spielerAnzahl; i++ )
+                {
+                    int f = 0;
+                    k->getNachrichtEncrypted( (char*)&f, 4 );
+                    sts->spielerFarbe->set( f, i );
+                }
+                for( int i = 0; i < sts->teamAnzahl; i++ )
+                {
+                    int f = 0;
+                    k->getNachrichtEncrypted( (char*)&f, 4 );
+                    sts->teamFarbe->set( f, i );
+                }
+                for( int i = 0; i < sts->teamAnzahl; i++ )
+                {
+                    char l = 0;
+                    k->getNachrichtEncrypted( &l, 1 );
+                    char *n = new char[ l + 1 ];
+                    n[ l ] = 0;
+                    k->getNachrichtEncrypted( n, l );
+                    sts->teamName->set( new Text( n ), i );
+                    delete[] n;
+                }
+                for( int i = 0; i < sts->teamAnzahl; i++ )
+                {
+                    int g = 0;
+                    k->getNachrichtEncrypted( (char*)&g, 4 );
+                    sts->teamGröße->set( g, i );
+                }
+                cs.unlock();
+                return 1;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// speichert die Team Daten
+//  sts: die neuen Spieler Team Daten
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::speicherTeamDaten( SpielerTeamStrukturV *sts )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xC", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x2", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                k->sendeEncrypted( (char*)&sts->spielerAnzahl, 4 );
+                k->sendeEncrypted( (char*)&sts->teamAnzahl, 4 );
+                for( int i = 0; i < sts->spielerAnzahl; i++ )
+                {
+                    int f = sts->spielerFarbe->get( i );
+                    k->sendeEncrypted( (char*)&f, 4 );
+                }
+                for( int i = 0; i < sts->teamAnzahl; i++ )
+                {
+                    int f = sts->teamFarbe->get( i );
+                    k->sendeEncrypted( (char*)&f, 4 );
+                }
+                for( int i = 0; i < sts->teamAnzahl; i++ )
+                {
+                    char l = (char)sts->teamName->z( i )->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( sts->teamName->z( i )->getText(), l );
+                }
+                for( int i = 0; i < sts->teamAnzahl; i++ )
+                {
+                    int g = sts->teamGröße->get( i );
+                    k->sendeEncrypted( (char*)&g, 4 );
+                }
+                cs.unlock();
+                return 1;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Erstellt neue Datei im Datei Editor
+//  typ: 0=ordner 1=bild 2=modell2d 3=sound
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deNeueDatei( char typ, Framework::Text *zName )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x1", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                k->sendeEncrypted( &typ, 1 );
+                char l = (char)zName->getLength();
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( zName->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Öffnet Ordner im Datei Editor
+//  zName: Der Name des Ordners
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deOrdnerÖffnen( Framework::Text *zName )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x2", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char län = (char)zName->getLength();
+                k->sendeEncrypted( &län, 1 );
+                if( län )
+                    k->sendeEncrypted( zName->getText(), län );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Gibt ein Bild aus dem Datei Editor zurück
+//  zDatei: Der Name der Datei (ohne erhöhten Reference Counter)
+//  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
+//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+//  Gibt bei misserfolg 0 zurück
+Framework::Bild *EditorClient::deBildLaden( Framework::Text *zDatei, Framework::Text *zBild, Framework::FBalken *zF )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    Bild *retB = 0;
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x3", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char län = (char)zDatei->getLength();
+                k->sendeEncrypted( &län, 1 );
+                if( län )
+                    k->sendeEncrypted( zDatei->getText(), län );
+                län = (char)zBild->getLength();
+                k->sendeEncrypted( &län, 1 );
+                if( län )
+                    k->sendeEncrypted( zBild->getText(), län );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int br = 0;
+                    int hö = 0;
+                    k->getNachrichtEncrypted( (char*)&br, 4 );
+                    k->getNachrichtEncrypted( (char*)&hö, 4 );
+                    retB = new Bild();
+                    retB->neuBild( br, hö, 0 );
+                    char *buffer = (char*)retB->getBuffer();
+                    __int64 län = br * hö * 4;
+                    zF->setAktionAnzahl( län );
+                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
+                    {
+                        k->getNachricht( &( buffer[ i ] ), l );
+                        i += l;
+                        län -= l;
+                        zF->aktionPlus( l );
+                    }
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    if( !ret && retB )
+        retB = retB->release();
+    if( !retB )
+        err = "Unbekannter Fehler";
+    return retB;
+}
+
+// Löscht eine Datei aus dem Datei Editor
+//  zName: Der Name der Datei
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deDateiLöschen( Framework::Text *zName )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x4", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char län = (char)zName->getLength();
+                k->sendeEncrypted( &län, 1 );
+                if( län )
+                    k->sendeEncrypted( zName->getText(), län );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Löscht Bild aus Datei im Datei Editor
+//  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
+//  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deBildLöschen( Framework::Text *zDatei, Framework::Text *zBild )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x5", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( zDatei->getText(), l );
+                l = (char)zBild->getLength();
+                k->sendeEncrypted( &l, 1 );
+                if( l )
+                    k->sendeEncrypted( zBild->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Speichert Bild in Datei im Datei Editor
+//  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
+//  zName: Der Name des Bildes (ohne erhöhten Reference Counter)
+//  zBild: Das neue Bild (ohne erhöhten Reference Counter)
+//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deBildSpeichern( Framework::Text *zDatei, Framework::Text *zName, Framework::Bild *zBild, Framework::FBalken *zF )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x6", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char län = (char)zDatei->getLength();
+                k->sendeEncrypted( &län, 1 );
+                if( län )
+                    k->sendeEncrypted( zDatei->getText(), län );
+                län = (char)zName->getLength();
+                k->sendeEncrypted( &län, 1 );
+                if( län )
+                    k->sendeEncrypted( zName->getText(), län );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int br = zBild->getBreite();
+                    int hö = zBild->getHeight();
+                    k->sendeEncrypted( (char*)&br, 4 );
+                    k->sendeEncrypted( (char*)&hö, 4 );
+                    char *buffer = (char*)zBild->getBuffer();
+                    __int64 gr = br * hö * 4;
+                    zF->setAktionAnzahl( gr );
+                    for( int i = 0, l = gr > 2048 ? 2048 : (int)gr; gr > 0; i += l, gr -= l, l = gr > 2048 ? 2048 : (int)gr )
+                    {
+                        k->sende( &( buffer[ i ] ), l );
+                        zF->aktionPlus( l );
+                    }
+                    k->getNachrichtEncrypted( &ret, 1 );
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt eine Liste mit Dateien im aktuellen Ordner des Datei Editors
+//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit Dateinamen (ohne erhöhten Reference Counter)
+//  Gibt die Anzahl der Dateien zurück
+int EditorClient::deGetDateiListe( Framework::RCArray< Framework::Text > *zNamen )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x7", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                int anz = 0;
+                k->getNachrichtEncrypted( (char*)&anz, 4 );
+                for( int i = 0; i < anz; i++ )
+                {
+                    char l = 0;
+                    k->getNachrichtEncrypted( &l, 1 );
+                    char *n = new char[ l + 1 ];
+                    n[ l ] = 0;
+                    if( l )
+                        k->getNachrichtEncrypted( n, l );
+                    zNamen->add( new Text( n ) );
+                    delete[] n;
+                }
+                cs.unlock();
+                return anz;
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return -1;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt eine Liste mit Bildern aus einer Bilddatei des Datei Editors
+//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Bildnamen (ohne erhöhten Reference Counter)
+//  Gibt die Anzahl der Bilder zurück
+int EditorClient::deGetBildListe( Framework::Text *zDatei, Framework::RCArray< Framework::Text > *zNamen )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x8", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int anz = 0;
+                    k->getNachrichtEncrypted( (char*)&anz, 4 );
+                    for( int i = 0; i < anz; i++ )
+                    {
+                        k->getNachrichtEncrypted( &l, 1 );
+                        char *n = new char[ l + 1 ];
+                        n[ l ] = 0;
+                        if( l )
+                            k->getNachrichtEncrypted( n, l );
+                        zNamen->add( new Text( n ) );
+                        delete[] n;
+                    }
+                    cs.unlock();
+                    return anz;
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt eine Liste mit 2D Modellen aus einer Modeldatei im Datei Editor
+//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Modelnamen (ohne erhöhten Reference Counter)
+//  Gibt die Anzahl der Modelle zurück
+int EditorClient::deGetModelListe( Framework::Text *zDatei, Framework::RCArray< Framework::Text > *zNamen )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x9", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int anz = 0;
+                    k->getNachrichtEncrypted( (char*)&anz, 4 );
+                    for( int i = 0; i < anz; i++ )
+                    {
+                        k->getNachrichtEncrypted( &l, 1 );
+                        char *n = new char[ l + 1 ];
+                        n[ l ] = 0;
+                        if( l )
+                            k->getNachrichtEncrypted( n, l );
+                        zNamen->add( new Text( n ) );
+                        delete[] n;
+                    }
+                    cs.unlock();
+                    return anz;
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt eine Liste mit Sounds aus einer Sounddatei im Datei Editor
+//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Soundnamen (ohne erhöhten Reference Counter)
+//  Gibt die Anzahl der Sounds zurück
+int EditorClient::deGetSoundListe( Framework::Text *zDatei, Framework::RCArray<  Framework::Text > *zNamen )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xA", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    int anz = 0;
+                    k->getNachrichtEncrypted( (char*)&anz, 4 );
+                    for( int i = 0; i < anz; i++ )
+                    {
+                        k->getNachrichtEncrypted( &l, 1 );
+                        char *n = new char[ l + 1 ];
+                        n[ l ] = 0;
+                        if( l )
+                            k->getNachrichtEncrypted( n, l );
+                        zNamen->add( new Text( n ) );
+                        delete[] n;
+                    }
+                    cs.unlock();
+                    return anz;
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Löscht ein Model aus einer Modeldatei des Datei Editors
+//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+//  zModel: Der Name des Models (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deModelLöschen( Framework::Text *zDatei, Framework::Text *zModel )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xB", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    l = (char)zModel->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( zModel->getText(), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Löscht einen Sound aus einer Sounddatei des Datei Editors
+//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deSoundLöschen( Framework::Text *zDatei, Framework::Text *zSound )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xC", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    l = (char)zSound->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( zSound->getText(), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt ein Model aus einer Modeldatei des Datei Editors
+//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+//  zModel: Enthält nach erfolgreichem Aufruf das Model (ohne erhöhten Reference Counter)
+//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+Framework::Model2DData *EditorClient::deModelLaden( Framework::Text *zDatei, Framework::Text *zModel, Framework::FBalken *zF )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xD", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    l = (char)zModel->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( zModel->getText(), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                    if( ret == 1 )
+                    {
+                        int anz = 0;
+                        k->getNachrichtEncrypted( (char*)&anz, 4 );
+                        zF->setAktionAnzahl( anz );
+                        Array< Polygon2D > *pol = new Array< Polygon2D >();
+                        for( int i = 0; i < anz; i++ )
+                        {
+                            Polygon2D p;
+                            p.schwerpunkt = new Vertex( 0, 0 );
+                            p.vertex = new Array< Vertex >();
+                            p.tKordinaten = new Array< Vertex >();
+                            k->getNachrichtEncrypted( (char*)&p.transparent, 1 );
+                            char nLän = 0;
+                            k->getNachrichtEncrypted( &nLän, 1 );
+                            char *txt = new char[ nLän + 1 ];
+                            if( nLän )
+                                k->getNachrichtEncrypted( txt, nLän );
+                            txt[ nLän ] = 0;
+                            p.name = new Text( txt );
+                            delete[] txt;
+                            int anz2 = 0;
+                            k->getNachrichtEncrypted( (char*)&anz2, 4 );
+                            for( int j = 0; j < anz2; j++ )
+                            {
+                                Vertex v;
+                                k->getNachrichtEncrypted( (char*)&v.x, 4 );
+                                k->getNachrichtEncrypted( (char*)&v.y, 4 );
+                                *p.schwerpunkt += v * (float)( 1.0 / anz2 );
+                                Vertex t;
+                                k->getNachrichtEncrypted( (char*)&t.x, 4 );
+                                k->getNachrichtEncrypted( (char*)&t.y, 4 );
+                                p.vertex->add( v );
+                                p.tKordinaten->add( t );
+                            }
+                            pol->add( p );
+                            zF->aktionPlus();
+                        }
+                        Model2DData *data = new Model2DData();
+                        data->erstelleModell( pol );
+                        cs.unlock();
+                        return data;
+                    }
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Lädt einen Sound herunter und gibt ihn zurück
+//  file: Ein Zeiger auf die GSLDatei, in der der Sound gespeichert werden soll
+//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+//  Gibt bei misserfolg 0 zurück
+GSL::GSLSoundV *EditorClient::deSoundLaden( GSL::GSLDateiV *file, Framework::Text *zDatei, Framework::Text *zSound, Framework::FBalken *zF )
+{
+    file->setDatei( (char*)"data/tmp/editor/dateien/sounds/tmp.gsl" );
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        file->release();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xE", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    l = (char)zSound->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( zSound->getText(), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                    if( ret == 1 )
+                    {
+                        DownloadSound dws( k, zF );
+                        file->speicherSound( &dws, zSound->getText() );
+                        GSL::GSLSoundV *s = file->getSound( zSound->getText() );
+                        file->release();
+                        cs.unlock();
+                        return s;
+                    }
+                }
+            }
+        }
+    }
+    file->release();
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Speichert ein Model in eine Modeldatei des Datei Editors
+//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+//  zModel: Der Name des Models (ohne erhöhten Reference Counter)
+//  zData: Die Daten des Models (ohne erhöhten Reference Counter)
+//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deModelSpeichern( Framework::Text *zDatei, Framework::Text *zModel, Framework::Model2DData *zData, Framework::FBalken *zF )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\xF", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    l = (char)zModel->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( zModel->getText(), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                    if( ret == 1 )
+                    {
+                        int anz = zData->polygons ? zData->polygons->getEintragAnzahl() : 0;
+                        zF->setAktionAnzahl( anz );
+                        k->sendeEncrypted( (char*)&anz, 4 );
+                        for( int i = 0; i < anz; i++ )
+                        {
+                            Polygon2D pol = zData->polygons->get( i );
+                            k->sendeEncrypted( (char*)&pol.transparent, 1 );
+                            char nLän = pol.name->getLength();
+                            k->sendeEncrypted( &nLän, 1 );
+                            if( nLän )
+                                k->sendeEncrypted( pol.name->getText(), nLän );
+                            int anz2 = pol.vertex->getEintragAnzahl();
+                            k->sendeEncrypted( (char*)&anz2, 4 );
+                            for( int j = 0; j < anz2; j++ )
+                            {
+                                Vertex v = pol.vertex->get( j );
+                                Vertex p;
+                                if( pol.tKordinaten )
+                                    p = pol.tKordinaten->hat( j ) ? pol.tKordinaten->get( j ) : Vertex( 0, 0 );
+                                k->sendeEncrypted( (char*)&v.x, 4 );
+                                k->sendeEncrypted( (char*)&v.y, 4 );
+                                k->sendeEncrypted( (char*)&p.x, 4 );
+                                k->sendeEncrypted( (char*)&p.y, 4 );
+                            }
+                            zF->aktionPlus();
+                        }
+                        k->getNachrichtEncrypted( &ret, 1 );
+                    }
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Speichert einen Sound in einer Sounddatei des Datei Editors
+//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+//  zData: Die Daten des Sounts (ohne erhöhten Reference Counter)
+//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::deSoundSpeichern( Framework::Text *zDatei, Framework::Text *zSound, GSL::GSLSoundV *zData, Framework::FBalken *zF )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xD", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            k->sendeEncrypted( "\x10", 1 );
+            k->getNachrichtEncrypted( &ret, 1 );
+            if( ret == 1 )
+            {
+                char l = (char)zDatei->getLength();
+                k->sendeEncrypted( &l, 1 );
+                k->sendeEncrypted( zDatei->getText(), l );
+                k->getNachrichtEncrypted( &ret, 1 );
+                if( ret == 1 )
+                {
+                    l = (char)zSound->getLength();
+                    k->sendeEncrypted( &l, 1 );
+                    k->sendeEncrypted( zSound->getText(), l );
+                    k->getNachrichtEncrypted( &ret, 1 );
+                    if( ret == 1 )
+                    {
+                        char channels = zData->istMono() ? 1 : 2;
+                        k->sendeEncrypted( &channels, 1 );
+                        int sample = zData->getSampleRate();
+                        k->sendeEncrypted( (char*)&sample, 4 );
+                        __int64 slän = zData->getDatLength();
+                        k->sendeEncrypted( (char*)&slän, 8 );
+                        zF->setAktionAnzahl( slän );
+                        zData->open();
+                        char *buffer = new char[ 2048 ];
+                        while( slän > 0 )
+                        {
+                            int l = slän > 2048 ? 2048 : (int)slän;
+                            zData->getDaten( buffer, l );
+                            k->sende( buffer, l );
+                            slän -= l;
+                            zF->aktionPlus( l );
+                        }
+                        delete[] buffer;
+                        zData->close();
+                    }
+                }
+            }
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Lädt die Kauf Statistik der geladenen Karte
+//  verkauft: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Käufe der Karte der letzten 30 Tage
+//  einkommen: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der verdinten Kupfer in den letzten 30 Tagen
+//  gespielt: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Spielen der letzten 30 Tage
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+int EditorClient::getVerkaufStatistik( Framework::Array< int > *verkauft, Framework::Array< int > *einkommen, Framework::Array< int > *gespielt )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\x10", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            int kaufAnz = 0;
+            k->getNachrichtEncrypted( (char*)&kaufAnz, 4 );
+            char anz = 0;
+            k->getNachrichtEncrypted( &anz, 1 );
+            for( int i = 0; i < anz; i++ )
+            {
+                int kupfer = 0;
+                int kauf = 0;
+                int games = 0;
+                k->getNachrichtEncrypted( (char*)&kupfer, 4 );
+                k->getNachrichtEncrypted( (char*)&kauf, 4 );
+                k->getNachrichtEncrypted( (char*)&games, 4 );
+                einkommen->add( kupfer );
+                verkauft->add( kauf );
+                gespielt->add( games );
+            }
+            cs.unlock();
+            return kaufAnz;
+        }
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool EditorClient::initEditor()
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        k->sendeEncrypted( "\xE", 1 );
+        k->getNachrichtEncrypted( &ret, 1 );
+    }
+    if( ret == 3 )
+    {
+        char byte = 0;
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = f;
+        delete[] f;
+        cs.unlock();
+        return 0;
+    }
+    if( ret != 1 )
+        err = "Unbekannter Fehler";
+    cs.unlock();
+    return ret == 1;
+}
+
+// Erhält die Verbindung aufrecht
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+bool EditorClient::keepAlive()
+{
+    if( !cs.tryLock() )
+        return 1;
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    char res = 0;
+    bool ok = k->sendeEncrypted( "\x5", 1 );
+    ok &= k->getNachrichtEncrypted( &res, 1 );
+    cs.unlock();
+    if( res != 1 || !ok )
+        trenne( 0 );
+    if( res != 1 )
+        err = "Unbekannter Fehler";
+    return res == 1;
+}
+
+// Trennt die Verbindung zum Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+bool EditorClient::trenne( bool abmelden )
+{
+    cs.lock();
+    verbinde();
+    if( !k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    if( abmelden )
+    {
+        k->sendeEncrypted( "\4", 1 );
+        char ret = 0;
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 3 )
+        { // error
+            k->getNachrichtEncrypted( &ret, 1 );
+            char *msg = new char[ ret + 1 ];
+            msg[ ret ] = 0;
+            if( ret )
+                k->getNachrichtEncrypted( msg, ret );
+            err = "error while unregister Client Editor Server returned: ";
+            err += msg;
+            delete[] msg;
+        }
+    }
+    k->sendeEncrypted( "\3", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 3 )
+    { // error
+        k->getNachrichtEncrypted( &ret, 1 );
+        char *msg = new char[ ret + 1 ];
+        msg[ ret ] = 0;
+        if( ret )
+            k->getNachrichtEncrypted( msg, ret );
+        err = "error while trenne Editor Server returned: ";
+        err += msg;
+        delete[] msg;
+    }
+    k->trenne();
+    k = k->release();
+    cs.unlock();
+    return 1;
+}
+
+// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+bool EditorClient::istVerbunden() const
+{
+    return k != 0;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *EditorClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+EditorServerClient *EditorClient::getThis()
+{
+    ref++;
+    return this;
+}
+
+// Verringert den Reference Counter um 1 und gibt 0 zurück.
+//  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
+EditorServerClient *EditorClient::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

KSGNetwork/EditorClient.h

@@ -0,0 +1,274 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird verwendet um Karten für Spiele zu erstellen
+    //  Kann nur von eingeloggten Clients verwendet werden
+    class EditorClient : public EditorServerClient
+    {
+    private:
+        int ref;
+        Framework::Text ip;
+        unsigned short port;
+        int cId;
+        Network::Klient *k;
+        char *key;
+        unsigned char keyLen;
+        Framework::Critical cs;
+        Framework::Text err;
+
+    public:
+        // Konstruktor
+        EditorClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~EditorClient();
+        // verbindet sich mit dem zugewiesenen Editor Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // Erstellt eine neue Karte
+        //  name: Der Name der Karte
+        //  spielArt: Die Id des Spiels
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool karteErstellen( char *name, int spielArt ) override;
+        // lädt eine bestimmte Karte
+        //  id: Die Id der Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ladeKarte( int id ) override;
+        // gibt eine Liste mit Abbildern der geladenen Karte zurück
+        //  name: Enthält nach erfolgreichem Aufruf eine Liste mit Namen der Abbilder
+        //  datum: Enthält nach erfolgreichem Aufruf eine Liste mit dem Datum der Erstellung für jedes Abbild
+        //  Gibt die Anzahl der Abbilder zurück
+        int getAbbildListe( Framework::RCArray< Framework::Text > *name, Framework::RCArray< Framework::Zeit > *datum ) override;
+        // Erstellt ein neues Abbild der geladenen Karte
+        //  name: Der Name des Abbildes
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool abbildErstellen( char *name ) override;
+        // Löscht ein altes Abbild der geladenen Karte
+        //  name: Der Name des Abbildes
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool abbildLöschen( char *name ) override;
+        // Stellt ein altes Abbild der geladenen Karte wieder her
+        //  name: Der Name des Abbildes
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool abbildHerstellen( char *name ) override;
+        // Verüffentlich eine neue Version der geladenen Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool veröffentlichen() override;
+        // Veröffentlich eine neue Version der Shop Seite der geladenen Karte
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool shopSeiteVeröffentlichen() override;
+        // Läht die Vorschau der Shop Seite der geladenen Karte herrunter und speichert sie unter data/tmp/ke/ssv
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ladeShopSeiteVorschau() override;
+        // Erstellt eine neue Shop Seiten Datei
+        //  name: Der Name der Datei
+        //  typ: 0=Ordner, 1=Bild, 2=Text
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ssDateiErstellen( char *name, int typ ) override;
+        // Öffnet einen Ordner der Shop Seite
+        //  name: Der Name des Ordners
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ssOrdnerÖffnen( char *name ) override;
+        // Lädt das ein Bild der Shop Seite und gibt es zurück
+        //  datei: Der Name der Bilddatei
+        //  bild: Der Name des Bildes
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Bild *ssBildLaden( char *datei, char *bild ) override;
+        // Löscht eine Datei der Shop Seite
+        //  name: Der Name der Datei
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ssDateiLöschen( char *name ) override;
+        // Läd eine KSGS Datei der Shop Seite und gibt den Quellcode zurück
+        //  datei: Der Name der Datei
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *ssTextLaden( char *datei ) override;
+        // Spechert eine KSGS Datei der Shop Seite
+        //  datei: Der Name der Datei
+        //  zText: Ein Zeiger auf den neuen Quellcode (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ssTextSpeichern( char *datei, Framework::Text *zText ) override;
+        // Löscht ein Bild der Shop Seite
+        //  datei: Der Name der Bilddatei
+        //  bild: Der Name des Bildes
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ssBildLöschen( char *datei, char *bild ) override;
+        // Speichert ein Bild einer ShopSeite
+        //  datei: Der name der Bilddatei
+        //  name: Der Name des Bildes
+        //  zBild: Ein Zeiger auf das Bild (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ssBildSpeichern( char *datei, char *name, Framework::Bild *zBild ) override;
+        // Lädt eine Liste mit Dateien von der Shop Seite
+        //  zList: Enthält nach erfolgreichem Aufruf die Liste mit Dateinamen
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        int ssGetDateiListe( Framework::RCArray< Framework::Text > *zList ) override;
+        // Lädt die Bild Liste einer Bild Datei der Shop Seite
+        //  name: Der Name der Bilddatei
+        //  zList: Enthält nach erfolgreichem Aufruf eine Liste mit Bildnamen
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        int ssGetBildListe( char *name, Framework::RCArray< Framework::Text > *zList ) override;
+        // Lädt die Shop Daten
+        //  es: Enthält nach erfolgreichem aufruf den Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+        //  tp: Enthält nach erfolgreichem Aufruf den Preis der Testversion in Kupfer
+        //  vp: Enthält nach erfolgreichem Aufruf den Preis der Vollversion in Kupfer
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool getShopDaten( int &es, int &tp, int &vp ) override;
+        // Setzt die Shop Daten
+        //  es: der Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+        //  tp: der Preis der Testversion in Kupfer
+        //  vp: der Preis der Vollversion in Kupfer
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool setShopDaten( int es, int tp, int vp ) override;
+        // gibt die Kartenbeschreibung als KSGScript Quellcode zurück
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Text *beschreibungLaden() override;
+        // gibt das Titelbild der Karte zurück
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Bild *titelbildLaden() override;
+        // gibt das Minimap Bild der Karte zurück
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Bild *minimapLaden() override;
+        // gibt das Ladebild der Karte zurück
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Bild *ladebildLaden() override;
+        // speichert den KSGScript Quellcode der Kartenbeschreibung
+        //  zText: Der KSGScript Quellcode (ohne erhöhten reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool beschreibungSpeichern( Framework::Text *zText ) override;
+        // speichert das Titelbild der Karte
+        //  zBild: das neue Titelbild
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool titelbildSpeichern( Framework::Bild *zBild ) override;
+        // speichert das Minimapbild der Karte
+        //  zBild: das neue Minimapbild
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool minimapSpeichern( Framework::Bild *zBild ) override;
+        // speichert das Ladebild der Karte
+        //  zBild: das neue Ladebild
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ladebildSpeichern( Framework::Bild *zBild ) override;
+        // lädt die Spieler Team Daten der Karte
+        //  sts: Enthält nach erfolgreichem Aufruf die Spieler Team Daten
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool ladeTeamDaten( SpielerTeamStrukturV *sts ) override;
+        // speichert die Team Daten
+        //  sts: die neuen Spieler Team Daten
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool speicherTeamDaten( SpielerTeamStrukturV *sts ) override;
+        // Erstellt neue Datei im Datei Editor
+        //  typ: 0=ordner 1=bild 2=modell2d 3=sound
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deNeueDatei( char typ, Framework::Text *zName ) override;
+        // Öffnet Ordner im Datei Editor
+        //  zName: Der Name des Ordners
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deOrdnerÖffnen( Framework::Text *zName ) override;
+        // Gibt ein Bild aus dem Datei Editor zurück
+        //  zDatei: Der Name der Datei (ohne erhöhten Reference Counter)
+        //  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
+        //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+        //  Gibt bei misserfolg 0 zurück
+        Framework::Bild *deBildLaden( Framework::Text *zDatei, Framework::Text *zBild, Framework::FBalken *zF ) override;
+        // Löscht eine Datei aus dem Datei Editor
+        //  zName: Der Name der Datei
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deDateiLöschen( Framework::Text *zName ) override;
+        // Löscht Bild aus Datei im Datei Editor
+        //  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
+        //  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deBildLöschen( Framework::Text *zDatei, Framework::Text *zBild ) override;
+        // Speichert Bild in Datei im Datei Editor
+        //  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
+        //  zName: Der Name des Bildes (ohne erhöhten Reference Counter)
+        //  zBild: Das neue Bild (ohne erhöhten Reference Counter)
+        //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deBildSpeichern( Framework::Text *zDatei, Framework::Text *zName, Framework::Bild *zBild, Framework::FBalken *zF ) override;
+        // Lädt eine Liste mit Dateien im aktuellen Ordner des Datei Editors
+        //  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit Dateinamen (ohne erhöhten Reference Counter)
+        //  Gibt die Anzahl der Dateien zurück
+        int deGetDateiListe( Framework::RCArray< Framework::Text > *zNamen ) override;
+        // Lädt eine Liste mit Bildern aus einer Bilddatei des Datei Editors
+        //  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Bildnamen (ohne erhöhten Reference Counter)
+        //  Gibt die Anzahl der Bilder zurück
+        int deGetBildListe( Framework::Text *zDatei, Framework::RCArray< Framework::Text > *zNamen ) override;
+        // Lädt eine Liste mit 2D Modellen aus einer Modeldatei im Datei Editor
+        //  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+        //  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Modelnamen (ohne erhöhten Reference Counter)
+        //  Gibt die Anzahl der Modelle zurück
+        int deGetModelListe( Framework::Text *zDatei, Framework::RCArray< Framework::Text > *zNamen ) override;
+        // Lädt eine Liste mit Sounds aus einer Sounddatei im Datei Editor
+        //  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+        //  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Soundnamen (ohne erhöhten Reference Counter)
+        //  Gibt die Anzahl der Sounds zurück
+        int deGetSoundListe( Framework::Text *zDatei, Framework::RCArray<  Framework::Text > *zNamen ) override;
+        // Löscht ein Model aus einer Modeldatei des Datei Editors
+        //  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+        //  zModel: Der Name des Models (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deModelLöschen( Framework::Text *zDatei, Framework::Text *zModel ) override;
+        // Löscht einen Sound aus einer Sounddatei des Datei Editors
+        //  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+        //  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deSoundLöschen( Framework::Text *zDatei, Framework::Text *zSound ) override;
+        // Lädt ein Model aus einer Modeldatei des Datei Editors
+        //  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+        //  zModel: Enthält nach erfolgreichem Aufruf das Model (ohne erhöhten Reference Counter)
+        //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        Framework::Model2DData *deModelLaden( Framework::Text *zDatei, Framework::Text *zModel, Framework::FBalken *zF ) override;
+        // Lädt einen Sound herunter und gibt ihn zurück
+        //  file: Ein Zeiger auf die GSLDatei, in der der Sound gespeichert werden soll
+        //  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+        //  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+        //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+        //  Gibt bei misserfolg 0 zurück
+        GSL::GSLSoundV *deSoundLaden( GSL::GSLDateiV *file, Framework::Text *zDatei, Framework::Text *zSound, Framework::FBalken *zF ) override;
+        // Speichert ein Model in eine Modeldatei des Datei Editors
+        //  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+        //  zModel: Der Name des Models (ohne erhöhten Reference Counter)
+        //  zData: Die Daten des Models (ohne erhöhten Reference Counter)
+        //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deModelSpeichern( Framework::Text *zDatei, Framework::Text *zModel, Framework::Model2DData *zData, Framework::FBalken *zF ) override;
+        // Speichert einen Sound in einer Sounddatei des Datei Editors
+        //  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+        //  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+        //  zData: Die Daten des Sounts (ohne erhöhten Reference Counter)
+        //  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool deSoundSpeichern( Framework::Text *zDatei, Framework::Text *zSound, GSL::GSLSoundV *zData, Framework::FBalken *zF ) override;
+        // Lädt die Kauf Statistik der geladenen Karte
+        //  verkauft: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Käufe der Karte der letzten 30 Tage
+        //  einkommen: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der verdinten Kupfer in den letzten 30 Tagen
+        //  gespielt: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Spielen der letzten 30 Tage
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        int getVerkaufStatistik( Framework::Array< int > *verkauft, Framework::Array< int > *einkommen, Framework::Array< int > *gespielt ) override;
+        // Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool initEditor() override;
+        // Erhält die Verbindung aufrecht
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+        bool keepAlive() override;
+        // Trennt die Verbindung zum Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+        bool trenne( bool abmelden ) override;
+        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+        bool istVerbunden() const override;
+        // gibt den Letzten Fehlertext zuück
+        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+        char *getLetzterFehler() const override;
+        // Erhöht den Reference Counter um 1 un gibt this zurück
+        EditorServerClient *getThis() override;
+        // Verringert den Reference Counter um 1 und gibt 0 zurück.
+        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
+        EditorServerClient *release() override;
+    };
+}

KSGNetwork/KSGNetwork.vcxproj

@@ -70,15 +70,15 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <IncludePath>..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(IncludePath)</IncludePath>
+    <IncludePath>..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;..\..\..\..\Allgemein\GSL\GSL\Include;$(IncludePath)</IncludePath>
     <LibraryPath>..\..\..\..\Allgemein\Framework\x64\Debug;..\..\..\..\Allgemein\Network\x64\Debug;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <IncludePath>..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <IncludePath>..\..\..\..\Allgemein\GSL\GSL\Include;..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
     <LibraryPath>..\..\..\..\Allgemein\Framework\x64\Release;..\..\..\..\Allgemein\Network\x64\Release;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <IncludePath>..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <IncludePath>..\..\..\..\Allgemein\GSL\GSL\Include;..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
     <LibraryPath>..\..\..\..\Allgemein\Framework\x32\Release;..\..\..\..\Allgemein\Network\x32\Release;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@@ -150,6 +150,7 @@
     <ClInclude Include="..\Include\KSGNetwork.h" />
     <ClInclude Include="AnmeldungClient.h" />
     <ClInclude Include="ChatClient.h" />
+    <ClInclude Include="EditorClient.h" />
     <ClInclude Include="ErhaltungClient.h" />
     <ClInclude Include="HistorieClient.h" />
     <ClInclude Include="InformationClient.h" />
@@ -168,6 +169,7 @@
   <ItemGroup>
     <ClCompile Include="AnmeldungClient.cpp" />
     <ClCompile Include="ChatClient.cpp" />
+    <ClCompile Include="EditorClient.cpp" />
     <ClCompile Include="ErhaltungClient.cpp" />
     <ClCompile Include="HistorieClient.cpp" />
     <ClCompile Include="InformationClient.cpp" />
@@ -178,7 +180,7 @@
     <ClCompile Include="MinigameClient.cpp" />
     <ClCompile Include="NewsClient.cpp" />
     <ClCompile Include="PatchClient.cpp" />
-    <ClCompile Include="RegisterServer.cpp" />
+    <ClCompile Include="RegisterClient.cpp" />
     <ClCompile Include="ShopClient.cpp" />
     <ClCompile Include="SpielClient.cpp" />
   </ItemGroup>

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -66,6 +66,9 @@
     <ClInclude Include="MinigameClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="EditorClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MainClient.cpp">
@@ -83,9 +86,6 @@
     <ClCompile Include="NewsClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
-    <ClCompile Include="RegisterServer.cpp">
-      <Filter>Quelldateien</Filter>
-    </ClCompile>
     <ClCompile Include="LoginClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
@@ -113,5 +113,11 @@
     <ClCompile Include="MinigameClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="EditorClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
+    <ClCompile Include="RegisterClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>