#include "Editor.h"
#include <Datei.h>
#include "Reader.h"

// Inhalt der Editor Klasse aus Editor.h
// Konstruktor
Editor::Editor()
{
    ref = 1;
}

// Destruktor
Editor::~Editor()
{}

// nicht constant
void Editor::setPfad( char *pfad )
{
    this->pfad = pfad;
    this->pfad += "/editor";
}

void Editor::open()
{

}

bool Editor::nachricht( SKlient *k )
{
    err = "";
    char n = 0;
    k->getNachrichtEncrypted( &n, 1 );
    switch( n )
    {
    case 0: // Initialisierung
        k->sendeEncrypted( "\1", 1 );
        if( DateiExistiert( pfad ) )
            k->sendeEncrypted( "\2", 1 );
        else
        {
            if( createSitzung() )
                k->sendeEncrypted( "\1", 1 );
            else
                return 0;
        }
        return 1;
    case 1: // Sitzung verwerfen
        if( createSitzung() )
            k->sendeEncrypted( "\1", 1 );
        else
            return 0;
        return 1;
    case 2: // Sitzung speichern und beenden
        if( saveSitzung() )
            k->sendeEncrypted( "\1", 1 );
        else
            return 0;
        return 1;
    case 3: // Get Size
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/size";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::lesen ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int width;
            int height;
            d.lese( (char *)&width, 4 );
            d.lese( (char *)&height, 4 );
            k->sendeEncrypted( (char *)&width, 4 );
            k->sendeEncrypted( (char *)&height, 4 );
            d.close();
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 4: // Lade Team Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/team";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei team;
                team.setDatei( pf );
                team.open( Datei::Style::lesen );
                int id = *files->z( i );
                int maxWbZeit;
                int punkte;
                team.lese( (char *)&maxWbZeit, 4 );
                team.lese( (char *)&punkte, 4 );
                team.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&maxWbZeit, 4 );
                k->sendeEncrypted( (char *)&punkte, 4 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 5: // Lade Spieler Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/player";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei player;
                player.setDatei( pf );
                player.open( Datei::Style::lesen );
                int id = *files->z( i );
                int spawnX;
                int spawnY;
                player.lese( (char *)&spawnX, 4 );
                player.lese( (char *)&spawnY, 4 );
                player.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&spawnX, 4 );
                k->sendeEncrypted( (char *)&spawnY, 4 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 6: // Lade Bariere Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/bariere";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int breite;
                int height;
                int style;
                int verschiebungWeite;
                int autoSchaltungMaxTime;
                int team;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&breite, 4 );
                object.lese( (char *)&height, 4 );
                object.lese( (char *)&style, 4 );
                object.lese( (char *)&verschiebungWeite, 4 );
                object.lese( (char *)&autoSchaltungMaxTime, 4 );
                object.lese( (char *)&team, 4 );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&breite, 4 );
                k->sendeEncrypted( (char *)&height, 4 );
                k->sendeEncrypted( (char *)&style, 4 );
                k->sendeEncrypted( (char *)&verschiebungWeite, 4 );
                k->sendeEncrypted( (char *)&autoSchaltungMaxTime, 4 );
                k->sendeEncrypted( (char *)&team, 4 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 7: // Lade Base Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/base";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int breite;
                int height;
                int maxTime;
                int team;
                bool showTimer;
                int timerX;
                int timerY;
                int timerFarbe;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&breite, 4 );
                object.lese( (char *)&height, 4 );
                object.lese( (char *)&maxTime, 4 );
                object.lese( (char *)&team, 4 );
                object.lese( (char *)&showTimer, 1 );
                object.lese( (char *)&timerX, 4 );
                object.lese( (char *)&timerY, 4 );
                object.lese( (char *)&timerFarbe, 4 );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&breite, 4 );
                k->sendeEncrypted( (char *)&height, 4 );
                k->sendeEncrypted( (char *)&maxTime, 4 );
                k->sendeEncrypted( (char *)&team, 4 );
                k->sendeEncrypted( (char *)&showTimer, 1 );
                k->sendeEncrypted( (char *)&timerX, 4 );
                k->sendeEncrypted( (char *)&timerY, 4 );
                k->sendeEncrypted( (char *)&timerFarbe, 4 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 8: // Lade Drop Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/drop";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int minX;
                int minY;
                int maxX;
                int maxY;
                int maxTime;
                int numDrops;
                float wahrscheinlichkeit[ ITEMANZAHL ];
                unsigned char len;
                object.lese( (char *)&minX, 4 );
                object.lese( (char *)&minY, 4 );
                object.lese( (char *)&maxX, 4 );
                object.lese( (char *)&maxY, 4 );
                object.lese( (char *)&maxTime, 4 );
                object.lese( (char *)&numDrops, 4 );
                for( int i = 0; i < ITEMANZAHL; i++ )
                    object.lese( (char *)&wahrscheinlichkeit[ i ], 4 );
                object.lese( (char *)&len, 1 );
                char *name = new char[ len ];
                object.lese( name, len );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&minX, 4 );
                k->sendeEncrypted( (char *)&minY, 4 );
                k->sendeEncrypted( (char *)&maxX, 4 );
                k->sendeEncrypted( (char *)&maxY, 4 );
                k->sendeEncrypted( (char *)&maxTime, 4 );
                k->sendeEncrypted( (char *)&numDrops, 4 );
                for( int i = 0; i < ITEMANZAHL; i++ )
                    k->sendeEncrypted( (char *)&wahrscheinlichkeit[ i ], 4 );
                k->sendeEncrypted( (char *)&len, 1 );
                k->sendeEncrypted( name, len );
                delete[] name;
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 9: // Lade Schalter Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/schalter";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int breite;
                int height;
                bool aktive;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&breite, 4 );
                object.lese( (char *)&height, 4 );
                object.lese( (char *)&aktive, 1 );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&breite, 4 );
                k->sendeEncrypted( (char *)&height, 4 );
                k->sendeEncrypted( (char *)&aktive, 1 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0xA: // Lade Schiene Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/schiene";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int breite;
                int height;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&breite, 4 );
                object.lese( (char *)&height, 4 );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&breite, 4 );
                k->sendeEncrypted( (char *)&height, 4 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0xB: // Lade Schiene Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/timer";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int maxZeit;
                bool sichtbar;
                bool autoWiederhohlung;
                bool runns;
                int farbe;
                unsigned char len;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&maxZeit, 4 );
                object.lese( (char *)&sichtbar, 1 );
                object.lese( (char *)&autoWiederhohlung, 1 );
                object.lese( (char *)&runns, 1 );
                object.lese( (char *)&farbe, 4 );
                object.lese( (char *)&len, 1 );
                char *name = new char[ len ];
                object.lese( name, len );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&maxZeit, 4 );
                k->sendeEncrypted( (char *)&sichtbar, 1 );
                k->sendeEncrypted( (char *)&autoWiederhohlung, 1 );
                k->sendeEncrypted( (char *)&runns, 1 );
                k->sendeEncrypted( (char *)&farbe, 4 );
                k->sendeEncrypted( (char *)&len, 1 );
                k->sendeEncrypted( name, len );
                delete[]name;
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0xC: // Lade Tunnel Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/tunnel";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int breite;
                int height;
                int zielX;
                int zielY;
                bool aktiv;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&breite, 4 );
                object.lese( (char *)&height, 4 );
                object.lese( (char *)&zielX, 4 );
                object.lese( (char *)&zielY, 4 );
                object.lese( (char *)&aktiv, 1 );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&breite, 4 );
                k->sendeEncrypted( (char *)&height, 4 );
                k->sendeEncrypted( (char *)&zielX, 4 );
                k->sendeEncrypted( (char *)&zielY, 4 );
                k->sendeEncrypted( (char *)&aktiv, 1 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0xD: // Lade Umlenkung Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/umlenkung";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                object.open( Datei::Style::lesen );
                int id = *files->z( i );
                int x;
                int y;
                int breite;
                int height;
                char richtung;
                int maxAbklingzeit;
                bool drehend;
                bool aktiv;
                object.lese( (char *)&x, 4 );
                object.lese( (char *)&y, 4 );
                object.lese( (char *)&breite, 4 );
                object.lese( (char *)&height, 4 );
                object.lese( (char *)&richtung, 1 );
                object.lese( (char *)&maxAbklingzeit, 4 );
                object.lese( (char *)&drehend, 1 );
                object.lese( (char *)&aktiv, 1 );
                object.close();
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&x, 4 );
                k->sendeEncrypted( (char *)&y, 4 );
                k->sendeEncrypted( (char *)&breite, 4 );
                k->sendeEncrypted( (char *)&height, 4 );
                k->sendeEncrypted( (char *)&richtung, 1 );
                k->sendeEncrypted( (char *)&maxAbklingzeit, 4 );
                k->sendeEncrypted( (char *)&drehend, 1 );
                k->sendeEncrypted( (char *)&aktiv, 1 );
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0xE: // Lade Trigger Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/trigger";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                __int64 size = object.getSize();
                object.open( Datei::Style::lesen );
                char buffer[ 2048 ];
                int id = *files->z( i );
                k->sendeEncrypted( (char *)&id, 4 );
                k->sendeEncrypted( (char *)&size, 8 );
                while( size > 0 )
                {
                    object.lese( buffer, MIN( 2048, (int)size ) );
                    k->sendeEncrypted( buffer, MIN( 2048, (int)size ) );
                    size -= 2048;
                }
                object.close();
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0xF: // Lade Variable Daten
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/variable";
        Datei d;
        d.setDatei( tmpPf );
        RCArray< Text > *files = d.getDateiListe();
        if( files )
        {
            k->sendeEncrypted( "\1", 1 );
            int anz = files->getEintragAnzahl();
            k->sendeEncrypted( (char *)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                Text pf = tmpPf;
                pf += "/";
                pf += files->z( i )->getText();
                Datei object;
                object.setDatei( pf );
                __int64 size = object.getSize();
                object.open( Datei::Style::lesen );
                char buffer[ 2048 ];
                unsigned char len = (unsigned char)(files->z( i )->getLength() - 2);
                k->sendeEncrypted( (char *)&len, 1 );
                k->sendeEncrypted( *files->z( i ), len );
                k->sendeEncrypted( (char *)&size, 8 );
                while( size > 0 )
                {
                    object.lese( buffer, MIN( 2048, (int)size ) );
                    k->sendeEncrypted( buffer, MIN( 2048, (int)size ) );
                    size -= 2048;
                }
                object.close();
            }
        }
        else
        {
            err = "Fehler beim laden von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0x10: // Change Map Size
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/size";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int width;
            int height;
            k->getNachrichtEncrypted( (char *)&width, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            if( width <= 0 || height <= 0 )
            {
                err = "Illegal Argument Exception";
                return 0;
            }
            k->sendeEncrypted( "\1", 1 );
            d.schreibe( (char *)&width, 4 );
            d.schreibe( (char *)&height, 4 );
            d.close();
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
        return 1;
    }
    case 0x11: // Change Team data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/team/";
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int maxWbZeit;
            int punkte;
            k->getNachrichtEncrypted( (char *)&maxWbZeit, 4 );
            k->getNachrichtEncrypted( (char *)&punkte, 4 );
            d.schreibe( (char *)&maxWbZeit, 4 );
            d.schreibe( (char *)&punkte, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x12: // Change Player data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/player/";
        tmpPf += id;
        tmpPf += ".p";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int spawnX;
            int spawnY;
            k->getNachrichtEncrypted( (char *)&spawnX, 4 );
            k->getNachrichtEncrypted( (char *)&spawnY, 4 );
            d.schreibe( (char *)&spawnX, 4 );
            d.schreibe( (char *)&spawnY, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x13: // Change Bariere data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/bariere/";
        tmpPf += id;
        tmpPf += ".b";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int breite;
            int height;
            int style;
            int verschiebungWeite;
            int autoSchaltungMaxTime;
            int team;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&style, 4 );
            k->getNachrichtEncrypted( (char *)&verschiebungWeite, 4 );
            k->getNachrichtEncrypted( (char *)&autoSchaltungMaxTime, 4 );
            k->getNachrichtEncrypted( (char *)&team, 4 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&style, 4 );
            d.schreibe( (char *)&verschiebungWeite, 4 );
            d.schreibe( (char *)&autoSchaltungMaxTime, 4 );
            d.schreibe( (char *)&team, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x14: // Change Base data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/base/";
        tmpPf += id;
        tmpPf += ".b";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int breite;
            int height;
            int maxTime;
            int team;
            bool showTimer;
            int timerX;
            int timerY;
            int timerFarbe;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
            k->getNachrichtEncrypted( (char *)&team, 4 );
            k->getNachrichtEncrypted( (char *)&showTimer, 1 );
            k->getNachrichtEncrypted( (char *)&timerX, 4 );
            k->getNachrichtEncrypted( (char *)&timerY, 4 );
            k->getNachrichtEncrypted( (char *)&timerFarbe, 4 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&maxTime, 4 );
            d.schreibe( (char *)&team, 4 );
            d.schreibe( (char *)&showTimer, 1 );
            d.schreibe( (char *)&timerX, 4 );
            d.schreibe( (char *)&timerY, 4 );
            d.schreibe( (char *)&timerFarbe, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x15: // Change Drop data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/drop/";
        tmpPf += id;
        tmpPf += ".d";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int minX;
            int minY;
            int maxX;
            int maxY;
            int maxTime;
            int numDrops;
            float wahrscheinlichkeit[ ITEMANZAHL ];
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&minX, 4 );
            k->getNachrichtEncrypted( (char *)&minY, 4 );
            k->getNachrichtEncrypted( (char *)&maxX, 4 );
            k->getNachrichtEncrypted( (char *)&maxY, 4 );
            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
            k->getNachrichtEncrypted( (char *)&numDrops, 4 );
            for( int i = 0; i < ITEMANZAHL; i++ )
                k->getNachrichtEncrypted( (char *)&wahrscheinlichkeit[ i ], 4 );
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ len ];
            k->getNachrichtEncrypted( name, len );
            d.schreibe( (char *)&minX, 4 );
            d.schreibe( (char *)&minY, 4 );
            d.schreibe( (char *)&maxX, 4 );
            d.schreibe( (char *)&maxY, 4 );
            d.schreibe( (char *)&maxTime, 4 );
            d.schreibe( (char *)&numDrops, 4 );
            for( int i = 0; i < ITEMANZAHL; i++ )
                d.schreibe( (char *)&wahrscheinlichkeit[ i ], 4 );
            d.schreibe( (char *)&len, 1 );
            d.schreibe( name, len );
            delete[]name;
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x16: // Change Schalter data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/schalter/";
        tmpPf += id;
        tmpPf += ".s";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int breite;
            int height;
            bool aktive;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&aktive, 1 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&aktive, 1 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x17: // Change Schiene data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/schiene/";
        tmpPf += id;
        tmpPf += ".s";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int breite;
            int height;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x18: // Change Timer data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/timer/";
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int maxZeit;
            bool sichtbar;
            bool autoWiederhohlung;
            bool runns;
            int farbe;
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&maxZeit, 4 );
            k->getNachrichtEncrypted( (char *)&sichtbar, 1 );
            k->getNachrichtEncrypted( (char *)&autoWiederhohlung, 1 );
            k->getNachrichtEncrypted( (char *)&runns, 1 );
            k->getNachrichtEncrypted( (char *)&farbe, 4 );
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ len ];
            k->getNachrichtEncrypted( name, len );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&maxZeit, 4 );
            d.schreibe( (char *)&sichtbar, 1 );
            d.schreibe( (char *)&autoWiederhohlung, 1 );
            d.schreibe( (char *)&runns, 1 );
            d.schreibe( (char *)&farbe, 4 );
            d.schreibe( (char *)&len, 1 );
            d.schreibe( name, len );
            delete[]name;
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x19: // Change Tunnel data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/tunnel/";
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int breite;
            int height;
            int zielX;
            int zielY;
            bool aktiv;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&zielX, 4 );
            k->getNachrichtEncrypted( (char *)&zielY, 4 );
            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&zielX, 4 );
            d.schreibe( (char *)&zielY, 4 );
            d.schreibe( (char *)&aktiv, 1 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x1A: // Change Umlenkung data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/umlenkung/";
        tmpPf += id;
        tmpPf += ".u";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            int x;
            int y;
            int breite;
            int height;
            char richtung;
            int maxAbklingzeit;
            bool drehend;
            bool aktiv;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&richtung, 1 );
            k->getNachrichtEncrypted( (char *)&maxAbklingzeit, 4 );
            k->getNachrichtEncrypted( (char *)&drehend, 1 );
            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&richtung, 1 );
            d.schreibe( (char *)&maxAbklingzeit, 4 );
            d.schreibe( (char *)&drehend, 1 );
            d.schreibe( (char *)&aktiv, 1 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x1B: // Change Trigger data
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/trigger/";
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            __int64 size;
            k->getNachrichtEncrypted( (char *)&size, 8 );
            char buffer[ 2048 ];
            while( size > 0 )
            {
                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
                d.schreibe( buffer, MIN( 2048, (int)size ) );
                size -= 2048;
            }
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x1C: // Change Variable data
    {
        k->sendeEncrypted( "\1", 1 );
        unsigned char len;
        k->getNachrichtEncrypted( (char *)&len, 1 );
        char *originalName = new char[ len + 1 ];
        k->getNachrichtEncrypted( (char *)&originalName, len );
        originalName[ len ] = 0;
        Text tmpPf = pfad.getText();
        tmpPf += "/variable/";
        tmpPf += originalName;
        tmpPf += ".v";
        Datei d;
        d.setDatei( tmpPf );
        k->getNachrichtEncrypted( (char *)&len, 1 );
        char *name = new char[ len + 1 ];
        k->getNachrichtEncrypted( (char *)&name, len );
        name[ len ] = 0;
        if( !Text( name ).istGleich( originalName ) )
        {
            Text tmpPf = pfad.getText();
            tmpPf += "/variable/";
            tmpPf += name;
            tmpPf += ".v";
            if( !d.umbenennen( tmpPf ) )
            {
                err = "Fehler beim schreiben von ";
                err += tmpPf.getText();
                return 0;
            }
        }
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            __int64 size;
            k->getNachrichtEncrypted( (char *)&size, 8 );
            char buffer[ 2048 ];
            while( size > 0 )
            {
                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
                d.schreibe( buffer, MIN( 2048, (int)size ) );
                size -= 2048;
            }
            d.close();
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
        delete[]name;
        delete[]originalName;
    }
    case 0x1D: // Add Bariere
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/bariere/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".b" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".b";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char*)&id, 4 );
            int x;
            int y;
            int breite;
            int height;
            int style;
            int verschiebungWeite;
            int autoSchaltungMaxTime;
            int team;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&style, 4 );
            k->getNachrichtEncrypted( (char *)&verschiebungWeite, 4 );
            k->getNachrichtEncrypted( (char *)&autoSchaltungMaxTime, 4 );
            k->getNachrichtEncrypted( (char *)&team, 4 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&style, 4 );
            d.schreibe( (char *)&verschiebungWeite, 4 );
            d.schreibe( (char *)&autoSchaltungMaxTime, 4 );
            d.schreibe( (char *)&team, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x1E: // Add Base
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/base/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".b" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".b";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char*)&id, 4 );
            int x;
            int y;
            int breite;
            int height;
            int maxTime;
            int team;
            bool showTimer;
            int timerX;
            int timerY;
            int timerFarbe;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
            k->getNachrichtEncrypted( (char *)&team, 4 );
            k->getNachrichtEncrypted( (char *)&showTimer, 1 );
            k->getNachrichtEncrypted( (char *)&timerX, 4 );
            k->getNachrichtEncrypted( (char *)&timerY, 4 );
            k->getNachrichtEncrypted( (char *)&timerFarbe, 4 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&maxTime, 4 );
            d.schreibe( (char *)&team, 4 );
            d.schreibe( (char *)&showTimer, 1 );
            d.schreibe( (char *)&timerX, 4 );
            d.schreibe( (char *)&timerY, 4 );
            d.schreibe( (char *)&timerFarbe, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x1F: // Add Drop
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/drop/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".d" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".d";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char *)&id, 4 );
            int minX;
            int minY;
            int maxX;
            int maxY;
            int maxTime;
            int numDrops;
            float wahrscheinlichkeit[ ITEMANZAHL ];
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&minX, 4 );
            k->getNachrichtEncrypted( (char *)&minY, 4 );
            k->getNachrichtEncrypted( (char *)&maxX, 4 );
            k->getNachrichtEncrypted( (char *)&maxY, 4 );
            k->getNachrichtEncrypted( (char *)&maxTime, 4 );
            k->getNachrichtEncrypted( (char *)&numDrops, 4 );
            for( int i = 0; i < ITEMANZAHL; i++ )
                k->getNachrichtEncrypted( (char *)&wahrscheinlichkeit[ i ], 4 );
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ len ];
            k->getNachrichtEncrypted( name, len );
            d.schreibe( (char *)&minX, 4 );
            d.schreibe( (char *)&minY, 4 );
            d.schreibe( (char *)&maxX, 4 );
            d.schreibe( (char *)&maxY, 4 );
            d.schreibe( (char *)&maxTime, 4 );
            d.schreibe( (char *)&numDrops, 4 );
            for( int i = 0; i < ITEMANZAHL; i++ )
                d.schreibe( (char *)&wahrscheinlichkeit[ i ], 4 );
            d.schreibe( (char *)&len, 1 );
            d.schreibe( name, len );
            delete[]name;
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x20: // Add Schalter
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/schalter/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".s" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".s";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char *)&id, 4 );
            int x;
            int y;
            int breite;
            int height;
            bool aktive;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&aktive, 1 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&aktive, 1 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x21: // Add Schiene
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/schiene/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".s" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".s";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char *)&id, 4 );
            int x;
            int y;
            int breite;
            int height;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x22: // Add Timer
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/timer/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".t" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char *)&id, 4 );
            int x;
            int y;
            int maxZeit;
            bool sichtbar;
            bool autoWiederhohlung;
            bool runns;
            int farbe;
            unsigned char len;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&maxZeit, 4 );
            k->getNachrichtEncrypted( (char *)&sichtbar, 1 );
            k->getNachrichtEncrypted( (char *)&autoWiederhohlung, 1 );
            k->getNachrichtEncrypted( (char *)&runns, 1 );
            k->getNachrichtEncrypted( (char *)&farbe, 4 );
            k->getNachrichtEncrypted( (char *)&len, 1 );
            char *name = new char[ len ];
            k->getNachrichtEncrypted( name, len );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&maxZeit, 4 );
            d.schreibe( (char *)&sichtbar, 1 );
            d.schreibe( (char *)&autoWiederhohlung, 1 );
            d.schreibe( (char *)&runns, 1 );
            d.schreibe( (char *)&farbe, 4 );
            d.schreibe( (char *)&len, 1 );
            d.schreibe( name, len );
            delete[]name;
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x23: // Add Tunnel
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/tunnel/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".t" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char *)&id, 4 );
            int x;
            int y;
            int breite;
            int height;
            int zielX;
            int zielY;
            bool aktiv;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&zielX, 4 );
            k->getNachrichtEncrypted( (char *)&zielY, 4 );
            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&zielX, 4 );
            d.schreibe( (char *)&zielY, 4 );
            d.schreibe( (char *)&aktiv, 1 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x24: // Add Umlenkung
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/umlenkung/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".u" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".u";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            k->sendeEncrypted( (char *)&id, 4 );
            int x;
            int y;
            int breite;
            int height;
            char richtung;
            int maxAbklingzeit;
            bool drehend;
            bool aktiv;
            k->getNachrichtEncrypted( (char *)&x, 4 );
            k->getNachrichtEncrypted( (char *)&y, 4 );
            k->getNachrichtEncrypted( (char *)&breite, 4 );
            k->getNachrichtEncrypted( (char *)&height, 4 );
            k->getNachrichtEncrypted( (char *)&richtung, 1 );
            k->getNachrichtEncrypted( (char *)&maxAbklingzeit, 4 );
            k->getNachrichtEncrypted( (char *)&drehend, 1 );
            k->getNachrichtEncrypted( (char *)&aktiv, 1 );
            d.schreibe( (char *)&x, 4 );
            d.schreibe( (char *)&y, 4 );
            d.schreibe( (char *)&breite, 4 );
            d.schreibe( (char *)&height, 4 );
            d.schreibe( (char *)&richtung, 1 );
            d.schreibe( (char *)&maxAbklingzeit, 4 );
            d.schreibe( (char *)&drehend, 1 );
            d.schreibe( (char *)&aktiv, 1 );
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x25: // Add Trigger
    {
        Text tmpPf = pfad.getText();
        tmpPf += "/trigger/";
        int id = 0;
        while( true )
        {
            if( !DateiExistiert( tmpPf + id + ".t" ) )
                break;
            id++;
        }
        tmpPf += id;
        tmpPf += ".t";
        Datei d;
        d.setDatei( tmpPf );
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            __int64 size;
            k->getNachrichtEncrypted( (char *)&size, 8 );
            char buffer[ 2048 ];
            while( size > 0 )
            {
                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
                d.schreibe( buffer, MIN( 2048, (int)size ) );
                size -= 2048;
            }
            d.close();
            k->sendeEncrypted( "\1", 1 );
            return 1;
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x26: // Add Variable
    {
        k->sendeEncrypted( "\1", 1 );
        unsigned char len;
        k->getNachrichtEncrypted( (char *)&len, 1 );
        char *name = new char[ len + 1 ];
        k->getNachrichtEncrypted( (char *)&name, len );
        Text tmpPf = pfad.getText();
        tmpPf += "/variable/";
        tmpPf += name;
        tmpPf += ".v";
        Datei d;
        if( d.existiert() )
        {
            err = "Die Variable existiert bereits";
            return 0;
        }
        d.setDatei( tmpPf );
        name[ len ] = 0;
        if( d.open( Datei::Style::schreiben ) )
        {
            k->sendeEncrypted( "\1", 1 );
            __int64 size;
            k->getNachrichtEncrypted( (char *)&size, 8 );
            char buffer[ 2048 ];
            while( size > 0 )
            {
                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
                d.schreibe( buffer, MIN( 2048, (int)size ) );
                size -= 2048;
            }
            d.close();
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim schreiben von ";
            err += tmpPf.getText();
            return 0;
        }
        delete[]name;
    }
    case 0x27: // Remove Bariere
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/bariere/";
        tmpPf += id;
        tmpPf += ".b";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x28: // Remove Base
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/base/";
        tmpPf += id;
        tmpPf += ".b";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x29: // Remove Drop
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/drop/";
        tmpPf += id;
        tmpPf += ".d";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x2A: // Remove Schalter
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/schalter/";
        tmpPf += id;
        tmpPf += ".s";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x2B: // Remove Schiene
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/schiene/";
        tmpPf += id;
        tmpPf += ".s";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x2C: // Remove Timer
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/timer/";
        tmpPf += id;
        tmpPf += ".t";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x2D: // Remove Tunnel
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/tunnel/";
        tmpPf += id;
        tmpPf += ".t";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x2E: // Remove Umlenkung
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/umlenkung/";
        tmpPf += id;
        tmpPf += ".u";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x2F: // Remove Trigger
    {
        k->sendeEncrypted( "\1", 1 );
        int id;
        k->getNachrichtEncrypted( (char *)&id, 4 );
        Text tmpPf = pfad.getText();
        tmpPf += "/trigger/";
        tmpPf += id;
        tmpPf += ".t";
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    case 0x30: // Remove Variable
    {
        k->sendeEncrypted( "\1", 1 );
        unsigned char len;
        k->getNachrichtEncrypted( (char *)&len, 1 );
        char *name = new char[ len + 1 ];
        k->getNachrichtEncrypted( name, len );
        name[ len ] = 0;
        Text tmpPf = pfad.getText();
        tmpPf += "/variable/";
        tmpPf += name;
        tmpPf += ".v";
        delete[]name;
        if( DateiRemove( tmpPf ) )
        {
            k->sendeEncrypted( "\1", 1 );
        }
        else
        {
            err = "Fehler beim löschen von ";
            err += tmpPf.getText();
            return 0;
        }
    }
    default:
        err = "Unbekannte Nachricht. Error Code: " __FILE__ ":";
        err += __LINE__;
        return 0;
    }
    return 0;
}

// constant
char *Editor::getLetzterFehler() const
{
    return err;
}

// Reference Counting 
ESEditorV *Editor::getThis()
{
    ref++;
    return this;
}

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

// privat
bool Editor::createSitzung()
{
    DateiRemove( pfad );
    Text pf = pfad.getText();
    pf.remove( pf.getLength() - 6, pf.getLength() );
    pf += "map/server/sts.ltgd";
    int spielerAnzahl;
    int teamAnzahl;
    Datei d;
    d.setDatei( pf );
    if( !d.existiert() || d.istOrdner() )
    {
        err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
        err += pf;
        err += ". Fehler Code: " __FILE__ ":";
        err += __LINE__;
        err += "\n";
        return 0;
    }
    d.open( Datei::Style::lesen );
    d.lese( (char *)&spielerAnzahl, 4 );
    d.lese( (char *)&teamAnzahl, 4 );
    d.close();
    pf = pfad.getText();
    pf.remove( pf.getLength() - 6, pf.getLength() );
    pf += "map/server/data.map";
    d.setDatei( pf.getText() );
    if( d.open( Datei::Style::lesen ) )
    {
        // map size
        pf = pfad.getText();
        pf += "/size";
        Datei s;
        s.setDatei( pf.getText() );
        if( !s.open( Datei::Style::schreiben ) )
        {
            err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
            err += pf;
            err += ". Fehler Code: " __FILE__ ":";
            err += __LINE__;
            err += "\n";
        }
        __int64 size = 0;
        d.lese( (char *)&size, 8 );
        s.schreibe( (char *)&size, 8 );
        s.close();
        // teams
        pf = pfad.getText();
        pf += "/team/";
        for( int i = 0; i < teamAnzahl; i++ )
        {
            Text tmpPf = pf.getText();
            tmpPf += i;
            tmpPf += ".t";
            int maxWbZeit;
            int punkte;
            d.lese( (char *)&maxWbZeit, 4 );
            d.lese( (char *)&punkte, 4 );
            Datei t;
            t.setDatei( tmpPf );
            t.erstellen();
            if( !t.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            t.schreibe( (char *)&maxWbZeit, 4 );
            t.schreibe( (char *)&punkte, 4 );
            t.close();
        }
        // spieler
        pf = pfad.getText();
        pf += "/player/";
        for( int i = 0; i < spielerAnzahl; i++ )
        {
            Text tmpPf = pf.getText();
            tmpPf += i;
            tmpPf += ".p";
            int spawnX;
            int spawnY;
            d.lese( (char *)&spawnX, 4 );
            d.lese( (char *)&spawnY, 4 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( (char *)&spawnX, 4 );
            s.schreibe( (char *)&spawnY, 4 );
            s.close();
        }
        // barieren
        pf = pfad.getText();
        pf += "/bariere/";
        int anz;
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".b";
            char buffer[ 32 ];
            d.lese( buffer, 32 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 32 );
            s.close();
        }
        // basen
        pf = pfad.getText();
        pf += "/base/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".b";
            char buffer[ 24 ];
            d.lese( buffer, 24 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 24 );
            s.close();
        }
        // drops
        pf = pfad.getText();
        pf += "/drop/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".d";
            char buffer[ 96 ];
            d.lese( buffer, 96 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 96 );
            unsigned char len;
            d.lese( (char *)&len, 1 );
            char *name = new char[ (int)len + 1 ];
            d.lese( name, len );
            name[ (int)len ] = 0;
            s.schreibe( (char *)&len, 1 );
            s.schreibe( (char *)&name, len );
            delete[] name;
            s.close();
        }
        // schalter
        pf = pfad.getText();
        pf += "/schalter/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".s";
            char buffer[ 17 ];
            d.lese( buffer, 17 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 17 );
            s.close();
        }
        // schiene
        pf = pfad.getText();
        pf += "/schiene/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".s";
            char buffer[ 16 ];
            d.lese( buffer, 16 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 16 );
            s.close();
        }
        // timer
        pf = pfad.getText();
        pf += "/timer/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".t";
            char buffer[ 19 ];
            d.lese( buffer, 19 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 19 );
            unsigned char len;
            d.lese( (char *)&len, 1 );
            char *name = new char[ (int)len + 1 ];
            d.lese( name, len );
            name[ (int)len ] = 0;
            s.schreibe( (char *)&len, 1 );
            s.schreibe( (char *)&name, len );
            delete[] name;
            s.close();
        }
        // tunnel
        pf = pfad.getText();
        pf += "/tunnel/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".t";
            char buffer[ 25 ];
            d.lese( buffer, 25 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 25 );
            s.close();
        }
        // umlenkung
        pf = pfad.getText();
        pf += "/umlenkung/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".u";
            char buffer[ 23 ];
            d.lese( buffer, 23 );
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            s.schreibe( buffer, 23 );
            s.close();
        }
        // trigger
        MapReader mr;
        pf = pfad.getText();
        pf += "/trigger/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int id;
            d.lese( (char *)&id, 4 );
            Text tmpPf = pf.getText();
            tmpPf += id;
            tmpPf += ".t";
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            unsigned char len;
            d.lese( (char *)&len, 1 );
            char *name = new char[ (int)len + 1 ];
            d.lese( name, len );
            name[ (int)len ] = 0;
            s.schreibe( (char *)&len, 1 );
            s.schreibe( (char *)&name, len );
            delete[] name;
            int ereignisAnzahl;
            int bedingungAnzahl;
            int aktionAnzahl;
            d.lese( (char *)&ereignisAnzahl, 4 );
            d.lese( (char *)&bedingungAnzahl, 4 );
            d.lese( (char *)&aktionAnzahl, 4 );
            s.schreibe( (char *)&ereignisAnzahl, 4 );
            s.schreibe( (char *)&bedingungAnzahl, 4 );
            s.schreibe( (char *)&aktionAnzahl, 4 );
            for( int j = 0; j < ereignisAnzahl; j++ )
            {
                int typ;
                d.lese( (char *)&typ, 4 );
                s.schreibe( (char *)&typ, 4 );
            }
            for( int j = 0; j < bedingungAnzahl; j++ )
                mr.writeAktion( mr.readAktion( d ), s );
            for( int j = 0; j < aktionAnzahl; j++ )
                mr.writeAktion( mr.readAktion( d ), s );
            s.close();
        }
        // variable
        pf = pfad.getText();
        pf += "/variable/";
        d.lese( (char *)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            char len;
            d.lese( (char *)&len, 1 );
            char *name = new char[ (int)len + 1 ];
            d.lese( name, len );
            name[ (int)len ] = 0;
            Text tmpPf = pf.getText();
            tmpPf += name;
            tmpPf += ".v";
            delete[] name;
            Datei s;
            s.setDatei( tmpPf );
            s.erstellen();
            if( !s.open( Datei::Style::schreiben ) )
            {
                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
                err += tmpPf;
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                err += "\n";
            }
            char typ;
            d.lese( &typ, 1 );
            char def;
            d.lese( &def, 1 );
            s.schreibe( &typ, 1 );
            s.schreibe( &def, 1 );
            if( def )
            {
                if( typ == BOOLEAN || typ == TASTE )
                {
                    char v;
                    d.lese( &v, 1 );
                    s.schreibe( &v, 1 );
                }
                else if( typ == STRING || typ == RICHTUNG )
                {
                    char len;
                    d.lese( (char *)&len, 1 );
                    char *str = new char[ (int)len + 1 ];
                    d.lese( str, len );
                    s.schreibe( &len, 1 );
                    s.schreibe( str, len );
                    delete[] str;
                }
                else if( typ != NICHTS )
                {
                    int v;
                    d.lese( (char *)&v, 4 );
                    s.schreibe( (char *)&v, 4 );
                }
            }
            s.close();
        }
        d.close();
    }
    else
    {
        err = "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
        err += pf;
        err += ". Fehler Code: " __FILE__ ":";
        err += __LINE__;
        pf = pfad.getText();
        pf += "/empty.file";
        DateiPfadErstellen( pf );
        DateiRemove( pf );
    }
    if( !err.getLength() )
        return 1;
    else
        return 0;
    return 0;
}

bool Editor::saveSitzung()
{
    Text pf = pfad.getText();
    pf.remove( pf.getLength() - 6, pf.getLength() );
    pf += "map/server/sts.ltgd";
    int spielerAnzahl;
    int teamAnzahl;
    Datei d;
    d.setDatei( pf );
    if( !d.existiert() || d.istOrdner() )
    {
        err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
        err += pf;
        err += ". Fehler Code: " __FILE__ ":";
        err += __LINE__;
        err += "\n";
        return 0;
    }
    d.open( Datei::Style::lesen );
    d.lese( (char *)&spielerAnzahl, 4 );
    d.lese( (char *)&teamAnzahl, 4 );
    d.close();
    pf = pfad.getText();
    pf.remove( pf.getLength() - 6, pf.getLength() );
    pf += "map/server/data_tmp.map";
    d.setDatei( pf.getText() );
    if( d.open( Datei::Style::schreiben ) )
    {
        pf = pfad.getText();
        pf += "/size";
        Datei s;
        s.setDatei( pf.getText() );
        if( !s.open( Datei::Style::schreiben ) )
        {
            err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
            err += pf;
            err += ". Fehler Code: " __FILE__ ":";
            err += __LINE__;
            err += "\n";
        }
        __int64 size = 0;
        s.lese( (char *)&size, 8 );
        d.schreibe( (char *)&size, 8 );
        s.close();
        for( int i = 0; i < teamAnzahl; i++ )
        {
            Text tmpPf = pfad + "/team/";
            tmpPf += i;
            tmpPf += ".t";
            Datei r;
            r.setDatei( tmpPf );
            if( r.open( Datei::Style::lesen ) )
            {
                int maxWbZeit;
                int punkte;
                r.lese( (char *)&maxWbZeit, 4 );
                r.lese( (char *)&punkte, 4 );
                d.schreibe( (char *)&maxWbZeit, 4 );
                d.schreibe( (char *)&punkte, 4 );
                r.close();
            }
            else
            {
                err = "Fehler beim Lesen von ";
                err += tmpPf.getText();
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                d.close();
                d.remove();
                return 0;
            }
        }
        for( int i = 0; i < spielerAnzahl; i++ )
        {
            Text tmpPf = pfad + "/player/";
            tmpPf += i;
            tmpPf += ".p";
            Datei r;
            r.setDatei( tmpPf );
            if( r.open( Datei::Style::lesen ) )
            {
                int spawnX;
                int spawnY;
                r.lese( (char *)&spawnX, 4 );
                r.lese( (char *)&spawnY, 4 );
                d.schreibe( (char *)&spawnX, 4 );
                d.schreibe( (char *)&spawnY, 4 );
                r.close();
            }
            else
            {
                err = "Fehler beim Lesen von ";
                err += tmpPf.getText();
                err += ". Fehler Code: " __FILE__ ":";
                err += __LINE__;
                d.close();
                d.remove();
                return 0;
            }
        }
        pf = pfad.getText();
        pf += "/bariere";
        Datei obj;
        obj.setDatei( pf );
        RCArray<Text> *objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 32 ];
                    r.lese( buffer, 32 );
                    d.schreibe( buffer, 32 );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/base";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 24 ];
                    r.lese( buffer, 24 );
                    d.schreibe( buffer, 24 );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/drop";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 96 ];
                    r.lese( buffer, 96 );
                    d.schreibe( buffer, 96 );
                    unsigned char len;
                    r.lese( (char *)&len, 1 );
                    char *name = new char[ (int)len + 1 ];
                    r.lese( name, len );
                    name[ (int)len ] = 0;
                    d.schreibe( (char *)&len, 1 );
                    d.schreibe( (char *)&name, len );
                    delete[] name;
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/schalter";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 17 ];
                    r.lese( buffer, 17 );
                    d.schreibe( buffer, 17 );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/schiene";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 16 ];
                    r.lese( buffer, 16 );
                    d.schreibe( buffer, 16 );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/timer";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 19 ];
                    r.lese( buffer, 19 );
                    d.schreibe( buffer, 19 );
                    unsigned char len;
                    r.lese( (char *)&len, 1 );
                    char *name = new char[ (int)len + 1 ];
                    r.lese( name, len );
                    name[ (int)len ] = 0;
                    d.schreibe( (char *)&len, 1 );
                    d.schreibe( (char *)&name, len );
                    delete[] name;
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/tunnel";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 25 ];
                    r.lese( buffer, 25 );
                    d.schreibe( buffer, 25 );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/umlenkung";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    char buffer[ 23 ];
                    r.lese( buffer, 23 );
                    d.schreibe( buffer, 23 );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/trigger";
        MapReader mr;
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    int id = (int)*objPf.val();
                    d.schreibe( (char *)&id, 4 );
                    unsigned char len;
                    r.lese( (char *)&len, 1 );
                    char *name = new char[ (int)len + 1 ];
                    r.lese( name, len );
                    name[ (int)len ] = 0;
                    d.schreibe( (char *)&len, 1 );
                    d.schreibe( (char *)&name, len );
                    delete[] name;
                    int ereignisAnzahl;
                    int bedingungAnzahl;
                    int aktionAnzahl;
                    r.lese( (char *)&ereignisAnzahl, 4 );
                    r.lese( (char *)&bedingungAnzahl, 4 );
                    r.lese( (char *)&aktionAnzahl, 4 );
                    d.schreibe( (char *)&ereignisAnzahl, 4 );
                    d.schreibe( (char *)&bedingungAnzahl, 4 );
                    d.schreibe( (char *)&aktionAnzahl, 4 );
                    for( int j = 0; j < ereignisAnzahl; j++ )
                    {
                        int typ;
                        r.lese( (char *)&typ, 4 );
                        d.schreibe( (char *)&typ, 4 );
                    }
                    for( int j = 0; j < bedingungAnzahl; j++ )
                        mr.writeAktion( mr.readAktion( r ), d );
                    for( int j = 0; j < aktionAnzahl; j++ )
                        mr.writeAktion( mr.readAktion( r ), d );
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf += "/variable";
        obj.setDatei( pf );
        objList = obj.getDateiListe();
        if( objList )
        {
            int anz = objList->getEintragAnzahl();
            d.schreibe( (char *)&anz, 4 );
            for( auto objPf = objList->getIterator(); objPf && objPf._; objPf++ )
            {
                Text tmp = pf.getText();
                tmp += "/";
                tmp += objPf->getText();
                Datei r;
                r.setDatei( tmp );
                if( r.open( Datei::Style::lesen ) )
                {
                    unsigned char len = (unsigned char)(objPf->getLength() - 2);
                    d.schreibe( (char *)&len, 1 );
                    d.schreibe( objPf->getText(), len );
                    char typ;
                    r.lese( &typ, 1 );
                    char def;
                    r.lese( &def, 1 );
                    d.schreibe( &typ, 1 );
                    d.schreibe( &def, 1 );
                    if( def )
                    {
                        if( typ == BOOLEAN || typ == TASTE )
                        {
                            char v;
                            r.lese( &v, 1 );
                            d.schreibe( &v, 1 );
                        }
                        else if( typ == STRING || typ == RICHTUNG )
                        {
                            char len;
                            r.lese( (char *)&len, 1 );
                            char *str = new char[ (int)len + 1 ];
                            r.lese( str, len );
                            d.schreibe( &len, 1 );
                            d.schreibe( str, len );
                            delete[] str;
                        }
                        else if( typ != NICHTS )
                        {
                            int v;
                            r.lese( (char *)&v, 4 );
                            d.schreibe( (char *)&v, 4 );
                        }
                    }
                    r.close();
                }
                else
                {
                    err = "Fehler beim Lesen von ";
                    err += tmp.getText();
                    err = ". Fehler Code: " __FILE__ ":";
                    err += __LINE__;
                    d.close();
                    d.remove();
                    objList->release();
                    return 0;
                }
            }
            objList->release();
        }
        else
            d.schreibe( "\0\0\0\0", 4 );
        pf = pfad.getText();
        pf.remove( pf.getLength() - 6, pf.getLength() );
        pf += "map/server/data.map";
        d.close();
        if( !DateiRemove( pf ) || !d.umbenennen( pf ) )
        {
            err = "Fehler beim Übernehmen der Änderungen. Fehler Code: " __FILE__ ":";
            err += __LINE__;
            return 0;
        }
    }
    else
    {
        err = "Fehler beim Speichern der Änderungen (Server). Fehler Code: " __FILE__ ":";
        err += __LINE__;
        return 0;
    }
    pf = pfad.getText();
    pf.remove( pf.getLength() - 6, pf.getLength() );
    pf += "map/client/map/data/data.map";
    Datei d2;
    d2.setDatei( pf.getText() );
    if( d2.open( Datei::Style::schreiben ) && d.open( Datei::Style::lesen ) )
    {
        __int64 size = d.getSize();
        char *buffer = new char[ 2048 ];
        while( size > 0 )
        {
            int len = (int)( size > 2048 ? 2048 : size );
            d.lese( buffer, len );
            d2.schreibe( buffer, len );
            size -= len;
        }
        delete[] buffer;
        d.close();
        d2.close();
    }
    else
    {
        err = "Fehler beim Speichern der Änderungen (Client). Fehler Code: " __FILE__ ":";
        err += __LINE__;
        return 0;
    }
    DateiRemove( pfad.getText() );
    return 1;
}