#include "EditorKlient.h"
#include "EditorKarte.h"
#include "Reader.h"
#include <Network.h>
#include <Klient.h>

using namespace Editor;
/*
SpielerTeamStruktur::SpielerTeamStruktur()
{
    spielerAnzahl = 0;
    teamAnzahl = 0;
    spielerFarbe = new Array< int >();
    teamFarbe = new Array< int >();
    teamName = new RCArray< Text >();
    teamSize = new Array< int >();
    ref = 1;
}

SpielerTeamStruktur::~SpielerTeamStruktur()
{
    spielerFarbe->release();
    teamFarbe->release();
    teamName->release();
    teamSize->release();
}

SpielerTeamStrukturV *SpielerTeamStruktur::getThis()
{
    ref++;
    return this;
}

SpielerTeamStrukturV *SpielerTeamStruktur::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}


// Konstruktor
//  k: Der zu verwendende Klient
EditorKlient::EditorKlient( KSGClient::EditorServerClient *k )
    : ReferenceCounter()
{
    klient = k;
}

// Destruktor
EditorKlient::~EditorKlient()
{
    klient->release();
}

// Initialisiert den Server
//  return: 1, falls erfolgreich
//          2, falls bereits eine Sitzung existiert
//          0, sonnst
int EditorKlient::init()
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    k->sendeEncrypted( "\x0", 1 );
    char ret;
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
        k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret;
}

// Verwirft die vorhandene Sitzung und erstellt eine neue
bool EditorKlient::sitzungVerwerfen()
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x1", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

// Speichert Sitzung und beendet Editor
bool EditorKlient::sitzungBeenden()
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x2", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

// Lädt die Spieler Team Struktur
bool EditorKlient::getSpielerTeamStruktur( SpielerTeamStrukturV *zSts )
{
    return klient->ladeTeamDaten( zSts );
}

bool EditorKlient::loadMapSize( Punkt &size )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x3", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->getNachrichtEncrypted( (char *)&size.x, 4 );
        k->getNachrichtEncrypted( (char *)&size.y, 4 );
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadSpieler( Array< SpielerDaten * > &spieler )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x5", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            SpielerDaten *s = new SpielerDaten();
            k->getNachrichtEncrypted( (char *)&s->id, 4 );
            k->getNachrichtEncrypted( (char *)&s->spawn.x, 4 );
            k->getNachrichtEncrypted( (char *)&s->spawn.y, 4 );
            spieler.add( s );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadTeams( Array< TeamDaten * > &teams )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x4", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            TeamDaten *t = new TeamDaten();
            k->getNachrichtEncrypted( (char *)&t->id, 4 );
            k->getNachrichtEncrypted( (char *)&t->maxWbzeit, 4 );
            k->getNachrichtEncrypted( (char *)&t->punkte, 4 );
            teams.add( t );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadBarieren( Array< BariereDaten * > &barieren )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x6", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            BariereDaten *b = new BariereDaten();
            k->getNachrichtEncrypted( (char *)&b->id, 4 );
            k->getNachrichtEncrypted( (char *)&b->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&b->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&b->size.x, 4 );
            k->getNachrichtEncrypted( (char *)&b->size.y, 4 );
            k->getNachrichtEncrypted( (char *)&b->style, 4 );
            k->getNachrichtEncrypted( (char *)&b->verschiebungWeite, 4 );
            k->getNachrichtEncrypted( (char *)&b->autoSchaltungMaxTime, 4 );
            k->getNachrichtEncrypted( (char *)&b->team, 4 );
            barieren.add( b );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadBasen( Array< BaseDaten * > &basen )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x7", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            BaseDaten *b = new BaseDaten();
            k->getNachrichtEncrypted( (char *)&b->id, 4 );
            k->getNachrichtEncrypted( (char *)&b->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&b->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&b->size.x, 4 );
            k->getNachrichtEncrypted( (char *)&b->size.y, 4 );
            k->getNachrichtEncrypted( (char *)&b->maxTime, 4 );
            k->getNachrichtEncrypted( (char *)&b->team, 4 );
            k->getNachrichtEncrypted( (char *)&b->showTimer, 1 );
            k->getNachrichtEncrypted( (char *)&b->timer.x, 4 );
            k->getNachrichtEncrypted( (char *)&b->timer.y, 4 );
            k->getNachrichtEncrypted( (char *)&b->timerFarbe, 4 );
            basen.add( b );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadDrops( Array< DropDaten * > &drops )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x8", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            DropDaten *d = new DropDaten();
            k->getNachrichtEncrypted( (char *)&d->id, 4 );
            k->getNachrichtEncrypted( (char *)&d->minPos.x, 4 );
            k->getNachrichtEncrypted( (char *)&d->minPos.y, 4 );
            k->getNachrichtEncrypted( (char *)&d->maxPos.x, 4 );
            k->getNachrichtEncrypted( (char *)&d->maxPos.y, 4 );
            k->getNachrichtEncrypted( (char *)&d->maxTime, 4 );
            k->getNachrichtEncrypted( (char *)&d->numDrops, 4 );
            for( int j = 0; j < ITEMANZAHL; j++ )
                k->getNachrichtEncrypted( (char *)&d->wahrscheinlichkeit[ j ], 4 );
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ (__int64)len + 1 ];
            k->getNachrichtEncrypted( name, len );
            name[ len ] = 0;
            d->name = name;
            delete[] name;
            drops.add( d );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadSchalter( Array< SchalterDaten * > &schalter )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x9", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            SchalterDaten *s = new SchalterDaten();
            k->getNachrichtEncrypted( (char *)&s->id, 4 );
            k->getNachrichtEncrypted( (char *)&s->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&s->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&s->size.x, 4 );
            k->getNachrichtEncrypted( (char *)&s->size.y, 4 );
            k->getNachrichtEncrypted( (char *)&s->aktiv, 1 );
            schalter.add( s );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadSchienen( Array< SchieneDaten * > &schienen )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\xA", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            SchieneDaten *s = new SchieneDaten();
            k->getNachrichtEncrypted( (char *)&s->id, 4 );
            k->getNachrichtEncrypted( (char *)&s->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&s->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&s->size.x, 4 );
            k->getNachrichtEncrypted( (char *)&s->size.y, 4 );
            schienen.add( s );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadTimer( Array< TimerDaten * > &timer )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\xB", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            TimerDaten *t = new TimerDaten();
            k->getNachrichtEncrypted( (char *)&t->id, 4 );
            k->getNachrichtEncrypted( (char *)&t->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&t->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&t->maxZeit, 4 );
            k->getNachrichtEncrypted( (char *)&t->sichtbar, 1 );
            k->getNachrichtEncrypted( (char *)&t->autoWiederhohlung, 1 );
            k->getNachrichtEncrypted( (char *)&t->runns, 1 );
            k->getNachrichtEncrypted( (char *)&t->farbe, 4 );
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ (__int64)len + 1 ];
            name[ len ] = 0;
            k->getNachrichtEncrypted( name, len );
            t->name = name;
            delete[]name;
            timer.add( t );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadTunnel( Array< TunnelDaten * > &tunnel )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\xC", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            TunnelDaten *t = new TunnelDaten();
            k->getNachrichtEncrypted( (char *)&t->id, 4 );
            k->getNachrichtEncrypted( (char *)&t->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&t->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&t->size.x, 4 );
            k->getNachrichtEncrypted( (char *)&t->size.y, 4 );
            k->getNachrichtEncrypted( (char *)&t->ziel.x, 4 );
            k->getNachrichtEncrypted( (char *)&t->ziel.y, 4 );
            k->getNachrichtEncrypted( (char *)&t->aktiv, 1 );
            tunnel.add( t );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadUmlenkung( Array< UmlenkungDaten * > &umlenkung )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\xD", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            UmlenkungDaten *u = new UmlenkungDaten();
            k->getNachrichtEncrypted( (char *)&u->id, 4 );
            k->getNachrichtEncrypted( (char *)&u->pos.x, 4 );
            k->getNachrichtEncrypted( (char *)&u->pos.y, 4 );
            k->getNachrichtEncrypted( (char *)&u->size.x, 4 );
            k->getNachrichtEncrypted( (char *)&u->size.y, 4 );
            k->getNachrichtEncrypted( (char *)&u->richtung, 1 );
            k->getNachrichtEncrypted( (char *)&u->maxAbklingzeit, 4 );
            k->getNachrichtEncrypted( (char *)&u->drehend, 1 );
            k->getNachrichtEncrypted( (char *)&u->aktiv, 1 );
            umlenkung.add( u );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadTrigger( Array< TriggerDaten * > &trigger )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\xE", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            TriggerDaten *t = new TriggerDaten();
            k->getNachrichtEncrypted( (char *)&t->id, 4 );
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ (__int64)len + 1 ];
            name[ len ] = 0;
            k->getNachrichtEncrypted( name, len );
            t->name = name;
            delete[]name;
            int ereignisAnzahl;
            int bedingungAnzahl;
            int aktionAnzahl;
            k->getNachrichtEncrypted( (char *)&ereignisAnzahl, 4 );
            k->getNachrichtEncrypted( (char *)&bedingungAnzahl, 4 );
            k->getNachrichtEncrypted( (char *)&aktionAnzahl, 4 );
            for( int j = 0; j < ereignisAnzahl; j++ )
            {
                int typ;
                k->getNachrichtEncrypted( (char *)&typ, 4 );
                t->ereignisse->add( (EreignisTyp)typ );
            }
            Network::EncryptedNetworkReader reader( k );
            for( int j = 0; j < bedingungAnzahl; j++ )
                t->bedingungen->add( new Bedingung( MapReader::readAktion( reader ) ) );
            for( int j = 0; j < aktionAnzahl; j++ )
                t->aktionen->add( MapReader::readAktion( reader ) );
            trigger.add( t );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::loadVariable( Array< VariableDaten * > &variable )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\xF", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        int anz;
        k->getNachrichtEncrypted( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            VariableDaten *v = new VariableDaten();
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ (__int64)len + 1 ];
            k->getNachrichtEncrypted( name, len );
            name[ len ] = 0;
            v->oldName = name;
            v->name = name;
            delete[]name;
            char typ;
            k->getNachrichtEncrypted( &typ, 1 );
            char def;
            k->getNachrichtEncrypted( &def, 1 );
            if( !def )
                v->var = new Variable( NICHTS );
            else
            {
                switch( typ )
                {
                case NICHTS:
                    v->var = new Variable( NICHTS );
                    break;
                case INTEGER:
                {
                    int val;
                    k->getNachrichtEncrypted( (char *)&val, 4 );
                    v->var = new Integer( val );
                    break;
                }
                case BOOLEAN:
                {
                    bool val;
                    k->getNachrichtEncrypted( (char *)&val, 1 );
                    v->var = new Boolean( val );
                    break;
                }
                case STRING:
                {
                    char len;
                    k->getNachrichtEncrypted( (char *)&len, 1 );
                    char *value = new char[ (__int64)len + 1 ];
                    k->getNachrichtEncrypted( value, len );
                    value[ (int)len ] = 0;
                    v->var = new String( value );
                    delete[] value;
                    break;
                }
                case RICHTUNG:
                {
                    char len;
                    k->getNachrichtEncrypted( (char *)&len, 1 );
                    char *value = new char[ (__int64)len + 1 ];
                    k->getNachrichtEncrypted( value, len );
                    value[ (int)len ] = 0;
                    v->var = new String( getRichtungFromString( Text( value ) ) );
                    delete[] value;
                    break;
                }
                case FLOAT:
                {
                    float val;
                    k->getNachrichtEncrypted( (char *)&val, 4 );
                    v->var = new Float( val );
                    break;
                }
                case TASTE:
                {
                    char val;
                    k->getNachrichtEncrypted( &val, 1 );
                    v->var = new Integer( val, 1 );
                    break;
                }
                case SPIELER:
                case TIMER:
                case TEAM:
                case BARIERE:
                case SCHALTER:
                case SCHIENE:
                case TUNNEL:
                case UMLENKUNG:
                case TRIGGER:
                case BASE:
                {
                    int id;
                    k->getNachrichtEncrypted( (char *)&id, 4 );
                    v->var = new Template( (VariableTyp)typ, id );
                    break;
                }
                case GEGENSTAND:
                {
                    int id;
                    k->getNachrichtEncrypted( (char *)&id, 4 );
                    v->var = new GegenstandTypVar( (GegenstandTyp)id );
                    break;
                }
                default:
                    v->var = new Variable( NICHTS );
                }
            }
            variable.add( v );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveMapSize( Punkt size )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x10", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&size.x, 4 );
        k->sendeEncrypted( (char *)&size.y, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveTeam( const TeamDaten *team )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x11", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&team->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&team->maxWbzeit, 4 );
            k->sendeEncrypted( (char *)&team->punkte, 4 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveSpieler( const SpielerDaten *spieler )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x12", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&spieler->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&spieler->spawn.x, 4 );
            k->sendeEncrypted( (char *)&spieler->spawn.y, 4 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveBariere( const BariereDaten *bariere )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x13", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&bariere->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&bariere->pos.x, 4 );
            k->sendeEncrypted( (char *)&bariere->pos.y, 4 );
            k->sendeEncrypted( (char *)&bariere->size.x, 4 );
            k->sendeEncrypted( (char *)&bariere->size.y, 4 );
            k->sendeEncrypted( (char *)&bariere->style, 4 );
            k->sendeEncrypted( (char *)&bariere->verschiebungWeite, 4 );
            k->sendeEncrypted( (char *)&bariere->autoSchaltungMaxTime, 4 );
            k->sendeEncrypted( (char *)&bariere->team, 4 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveBase( const BaseDaten *base )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x14", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&base->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&base->pos.x, 4 );
            k->sendeEncrypted( (char *)&base->pos.y, 4 );
            k->sendeEncrypted( (char *)&base->size.x, 4 );
            k->sendeEncrypted( (char *)&base->size.y, 4 );
            k->sendeEncrypted( (char *)&base->maxTime, 4 );
            k->sendeEncrypted( (char *)&base->team, 4 );
            k->sendeEncrypted( (char *)&base->showTimer, 1 );
            k->sendeEncrypted( (char *)&base->timer.x, 4 );
            k->sendeEncrypted( (char *)&base->timer.y, 4 );
            k->sendeEncrypted( (char *)&base->timerFarbe, 4 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveDrop( const DropDaten *drop )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x15", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&drop->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&drop->minPos.x, 4 );
            k->sendeEncrypted( (char *)&drop->minPos.y, 4 );
            k->sendeEncrypted( (char *)&drop->maxPos.x, 4 );
            k->sendeEncrypted( (char *)&drop->maxPos.y, 4 );
            k->sendeEncrypted( (char *)&drop->maxTime, 4 );
            k->sendeEncrypted( (char *)&drop->numDrops, 4 );
            for( int j = 0; j < ITEMANZAHL; j++ )
                k->sendeEncrypted( (char *)&drop->wahrscheinlichkeit[ j ], 4 );
            unsigned char len = (unsigned char)drop->name.getLength();
            k->sendeEncrypted( (char *)&len, 1 );
            k->sendeEncrypted( drop->name, len );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveSchalter( const SchalterDaten *schalter )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x16", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&schalter->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&schalter->pos.x, 4 );
            k->sendeEncrypted( (char *)&schalter->pos.y, 4 );
            k->sendeEncrypted( (char *)&schalter->size.x, 4 );
            k->sendeEncrypted( (char *)&schalter->size.y, 4 );
            k->sendeEncrypted( (char *)&schalter->aktiv, 1 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveSchiene( const SchieneDaten *schiene )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x17", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&schiene->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&schiene->pos.x, 4 );
            k->sendeEncrypted( (char *)&schiene->pos.y, 4 );
            k->sendeEncrypted( (char *)&schiene->size.x, 4 );
            k->sendeEncrypted( (char *)&schiene->size.y, 4 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveTimer( const TimerDaten *timer )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x18", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&timer->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&timer->pos.x, 4 );
            k->sendeEncrypted( (char *)&timer->pos.y, 4 );
            k->sendeEncrypted( (char *)&timer->maxZeit, 4 );
            k->sendeEncrypted( (char *)&timer->sichtbar, 1 );
            k->sendeEncrypted( (char *)&timer->autoWiederhohlung, 1 );
            k->sendeEncrypted( (char *)&timer->runns, 1 );
            k->sendeEncrypted( (char *)&timer->farbe, 4 );
            unsigned char len = (unsigned char)timer->name.getLength();
            k->sendeEncrypted( (char *)&len, 1 );
            k->sendeEncrypted( timer->name, len );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveTunnel( const TunnelDaten *tunnel )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x19", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&tunnel->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&tunnel->pos.x, 4 );
            k->sendeEncrypted( (char *)&tunnel->pos.y, 4 );
            k->sendeEncrypted( (char *)&tunnel->size.x, 4 );
            k->sendeEncrypted( (char *)&tunnel->size.y, 4 );
            k->sendeEncrypted( (char *)&tunnel->ziel.x, 4 );
            k->sendeEncrypted( (char *)&tunnel->ziel.y, 4 );
            k->sendeEncrypted( (char *)&tunnel->aktiv, 1 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveUmlenkung( const UmlenkungDaten *umlenkung )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x1A", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&umlenkung->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            k->sendeEncrypted( (char *)&umlenkung->pos.x, 4 );
            k->sendeEncrypted( (char *)&umlenkung->pos.y, 4 );
            k->sendeEncrypted( (char *)&umlenkung->size.x, 4 );
            k->sendeEncrypted( (char *)&umlenkung->size.y, 4 );
            k->sendeEncrypted( (char *)&umlenkung->richtung, 1 );
            k->sendeEncrypted( (char *)&umlenkung->maxAbklingzeit, 4 );
            k->sendeEncrypted( (char *)&umlenkung->drehend, 1 );
            k->sendeEncrypted( (char *)&umlenkung->aktiv, 1 );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveTrigger( const TriggerDaten *trigger )
{
    Network::Klient *k = klient->beginEditorMessage();
    if( !k )
    {
        error = klient->getLetzterFehler();
        return 0;
    }
    error = "";
    char ret;
    k->sendeEncrypted( "\x1B", 1 );
    k->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        k->sendeEncrypted( (char *)&trigger->id, 4 );
        k->getNachrichtEncrypted( &ret, 1 );
        if( ret == 1 )
        {
            unsigned char len = (unsigned char)trigger->name.getLength();
            k->sendeEncrypted( (char *)&len, 1 );
            k->sendeEncrypted( trigger->name, len );
            int ereignisAnzahl = trigger->ereignisse->getEintragAnzahl();
            int bedingungAnzahl = trigger->bedingungen->getEintragAnzahl();
            int aktionAnzahl = trigger->aktionen->getEintragAnzahl();
            k->sendeEncrypted( (char *)&ereignisAnzahl, 4 );
            k->sendeEncrypted( (char *)&bedingungAnzahl, 4 );
            k->sendeEncrypted( (char *)&aktionAnzahl, 4 );
            for( int j = 0; j < ereignisAnzahl; j++ )
            {
                int typ = (int)trigger->ereignisse->get( j );
                k->sendeEncrypted( (char *)&typ, 4 );
            }
            Network::EncryptedNetworkWriter writer( k );
            for( int j = 0; j < bedingungAnzahl; j++ )
                MapReader::writeAktion( trigger->bedingungen->z( j )->zExpression(), writer );
            for( int j = 0; j < aktionAnzahl; j++ )
                MapReader::writeAktion( trigger->aktionen->z( j ), writer );
            k->getNachrichtEncrypted( &ret, 1 );
        }
    }
    if( ret == 3 )
    {
        unsigned char l = 0;
        k->getNachrichtEncrypted( (char *)&l, 1 );
        char *err = new char[ (__int64)l + 1 ];
        err[ l ] = 0;
        k->getNachrichtEncrypted( err, l );
        error = err;
        delete[] err;
        ret = 0;
    }
    klient->endEditorMessage();
    return ret == 1;
}

bool EditorKlient::saveVariable( const VariableDaten *variable )
{

    return 0;
}

bool EditorKlient::deleteBariere( int id )
{

    return 0;
}

bool EditorKlient::deleteBase( int id )
{

    return 0;
}

bool EditorKlient::deleteDrop( int id )
{

    return 0;
}

bool EditorKlient::deleteSchalter( int id )
{

    return 0;
}

bool EditorKlient::deleteSchiene( int id )
{

    return 0;
}

bool EditorKlient::deleteTimer( int id )
{

    return 0;
}

bool EditorKlient::deleteTunnel( int id )
{

    return 0;
}

bool EditorKlient::deleteUmlenkung( int id )
{

    return 0;
}

bool EditorKlient::deleteTrigger( int id )
{

    return 0;
}

bool EditorKlient::deleteVariable( int id )
{

    return 0;
}

// Gibt den Letzten Fehler zurück
char *EditorKlient::getLastError() const
{
    return error;
}*/