KSGNetwork/KSGNetwork/EditorClient.cpp

#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::EDITOR, Keys::SENDEN );
    k->setSendeKey( key, l );
    delete[] key;
    Keys::getServerKey( &key, l, Keys::EDITOR, 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->teamSize->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->teamSize->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;
}

// Setzt das arbeitsverzeichnis auf den obersten ordner
bool EditorClient::deResetPath()
{
    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( "\x11", 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ä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;
}

// Beginnt eine individuelle Editor Nachricht
//  Gibt den Klient zurück, über den mit dem Server kommuniziert werden kann. Im Fehlerfall wird 0 zurückgegeben
//  Der Thread, der diese Methode aufgerufen hat, sollte nach dem Erfolgreichen Aufruf am Ende der Kommunikation mit dem Server endEditorMessage aufrufen
Network::Klient *EditorClient::beginEditorMessage()
{
    cs.lock();
    if( !k )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    k->sendeEncrypted( "\7", 1 );
    char ret = 0;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( "\xF", 1 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
            return k;
    }
    if( ret == 3 )
    {
        k->getNachrichtEncrypted( &ret, 1 );
        char *msg = new char[ ret + 1 ];
        msg[ ret ] = 0;
        if( ret )
            k->getNachrichtEncrypted( msg, ret );
        err = "error while beginning Editor Message Server returned: ";
        err += msg;
        delete[] msg;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Beendet eine Editor Nachricht
//  sollte nur nach dem erfolgreichem Aufrufen von beginEditorMessage aufgerufen werden (vom selben Thread)
void EditorClient::endEditorMessage()
{
    cs.unlock();
}

// 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;
}