#include "EditorClient.h"
#include <Klient.h>
#include "Keys.h"
#include <Datei.h>
#include <Zeit.h>
#include <Bild.h>
#include <Fortschritt.h>
#include <Model2D.h>
#include <GSLDateiV.h>

using namespace KSGClient;


class DownloadSound : public GSL::GSLSoundV
{
private:
	bool istM;
	int sample;
	__int64 län;
	Network::Klient* k;
	FBalken* f;

public:
	// Konstruktor
	DownloadSound(Network::Klient* zK, FBalken* zF)
		: Thread()
	{
		k = zK;
		f = zF;
	}
	// nicht constant
	// GSL
	void playSound() override
	{}
	void setPause(bool p) override
	{}
	void stopSound() override
	{}
	void warteAufSound(int zeit) override
	{}
	// Lautstärke: 0 - 0xFFFF
	void setVolume(unsigned int links, unsigned int rechts) override
	{}
	// zum Speichern
	void open() override
	{
		char m = 0;
		k->getNachrichtEncrypted(&m, 1);
		istM = (m == 1);
		sample = 0;
		k->getNachrichtEncrypted((char*)&sample, 4);
		län = 0;
		k->getNachrichtEncrypted((char*)&län, 8);
		if (f)
			f->setAktionAnzahl(län);
	}
	int getDaten(char* buffer, int län) override
	{
		int l = län < this->län ? län : (int)this->län;
		if (!l)
			return -1;
		k->getNachricht(buffer, l);
		this->län -= l;
		if (f)
			f->aktionPlus(l);
		return l;
	}
	void close() override
	{}
	bool istMono() const override
	{
		return istM;
	}
	int getSampleRate() const override
	{
		return sample;
	}
	__int64 getDatLength() const override
	{
		return län;
	}
};

// Inhalt der KSGClient Klasse

// Konstruktor
EditorClient::EditorClient(int kId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
	: ReferenceCounter()
{
	this->ip = ip;
	this->port = port;
	cId = kId;
	k = 0;
	this->key = new char[keyLen];
	memcpy(this->key, key, keyLen);
	this->keyLen = keyLen;
}

// Destruktor
EditorClient::~EditorClient()
{
	trenne(1);
	delete[] key;
}

// verbindet sich mit dem zugewiesenen Editor Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::verbinde()
{
	cs.lock();
	if (k)
	{
		cs.unlock();
		return 1;
	}
	k = new Network::Klient();
	int l = 0;
	char* key;
	Keys::getServerKey(&key, l, Keys::EDITOR, Keys::SENDEN);
	k->setSendeKey(key, l);
	delete[] key;
	Keys::getServerKey(&key, l, Keys::EDITOR, Keys::EMPFANGEN);
	k->setEmpfangKey(key, l);
	delete[] key;
	if (k->verbinde(port, ip))
	{
		if (k->sendeEncrypted("\1", 1))
		{
			k->sendeEncrypted((char*)&cId, 4);
			char serverReturn = 0;
			k->getNachrichtEncrypted(&serverReturn, 1);
			if (serverReturn == 3)
			{
				char byte = 0;
				k->getNachrichtEncrypted(&byte, 1);
				char* f = new char[byte + 1];
				f[byte] = 0;
				k->getNachrichtEncrypted(f, byte);
				err = "error while identifying client Editor Server returned: ";
				err += f;
				delete[]f;
				trenne(0);
				cs.unlock();
				return 0;
			}
			k->setSendeKey(this->key, this->keyLen);
			k->setEmpfangKey(this->key, this->keyLen);
		}
		else
		{
			err = "network error while sending to Editor Server";
			k = (Network::Klient*)k->release();
			cs.unlock();
			return 0;
		}
	}
	else
	{
		err = "network error while connecting to Editor Server";
		k = (Network::Klient*)k->release();
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Erstellt eine neue Karte
//  name: Der Name der Karte
//  spielArt: Die Id des Spiels
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::karteErstellen(const char* name, int spielArt)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xA", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		char l = (char)textLength(name);
		k->sendeEncrypted(&l, 1);
		k->sendeEncrypted(name, l);
		k->sendeEncrypted((char*)&spielArt, 4);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// lädt eine bestimmte Karte
//  id: Die Id der Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ladeKarte(int id)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x6", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&id, 4);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// gibt eine Liste mit Abbildern der geladenen Karte zurück
//  name: Enthält nach erfolgreichem Aufruf eine Liste mit Namen der Abbilder
//  datum: Enthält nach erfolgreichem Aufruf eine Liste mit dem Datum der Erstellung für jedes Abbild
//  Gibt die Anzahl der Abbilder zurück
int EditorClient::getAbbildListe(Framework::RCArray< Framework::Text >* name, Framework::RCArray< Framework::Zeit >* datum)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x5", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			int anz = 0;
			k->getNachrichtEncrypted((char*)&anz, 4);
			for (int i = 0; i < anz; i++)
			{
				char l = 0;
				k->getNachrichtEncrypted(&l, 1);
				char* n = new char[l + 1];
				n[l] = 0;
				k->getNachrichtEncrypted(n, l);
				name->set(new Text(n), i);
				delete[] n;
				Zeit* dat = new Zeit();
				int d = 0;
				k->getNachrichtEncrypted((char*)&d, 4);
				dat->setJahr(d);
				k->getNachrichtEncrypted((char*)&d, 4);
				dat->setMonat(d);
				k->getNachrichtEncrypted((char*)&d, 4);
				dat->setTag(d);
				k->getNachrichtEncrypted((char*)&d, 4);
				dat->setStunde(d);
				k->getNachrichtEncrypted((char*)&d, 4);
				dat->setMinute(d);
				k->getNachrichtEncrypted((char*)&d, 4);
				dat->setSekunde(d);
				datum->set(dat, i);
			}
			cs.unlock();
			return anz;
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Erstellt ein neues Abbild der geladenen Karte
//  name: Der Name des Abbildes
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::abbildErstellen(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x1", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			char l = (char)textLength(name);
			k->sendeEncrypted(&l, 1);
			if (l)
				k->sendeEncrypted(name, l);
			k->getNachrichtEncrypted(&ret, 1);
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Löscht ein altes Abbild der geladenen Karte
//  name: Der Name des Abbildes
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::abbildLöschen(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x2", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			char l = (char)textLength(name);
			k->sendeEncrypted(&l, 1);
			if (l)
				k->sendeEncrypted(name, l);
			k->getNachrichtEncrypted(&ret, 1);
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Stellt ein altes Abbild der geladenen Karte wieder her
//  name: Der Name des Abbildes
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::abbildHerstellen(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x3", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			char l = (char)textLength(name);
			k->sendeEncrypted(&l, 1);
			if (l)
				k->sendeEncrypted(name, l);
			k->getNachrichtEncrypted(&ret, 1);
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// Verüffentlich eine neue Version der geladenen Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::veröffentlichen()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x4", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
			k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Veröffentlich eine neue Version der Shop Seite der geladenen Karte
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::shopSeiteVeröffentlichen()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x6", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
			k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Läht die Vorschau der Shop Seite der geladenen Karte herrunter und speichert sie unter data/tmp/ke/ssv
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ladeShopSeiteVorschau()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x8", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			int anz = 0;
			k->getNachrichtEncrypted((char*)&anz, 4);
			Text pf = "data/tmp/ke/ssv";
			for (int i = 0; i < anz; i++)
			{
				char l = 0;
				k->getNachrichtEncrypted(&l, 1);
				char* pfad = new char[l + 1];
				pfad[l] = 0;
				k->getNachrichtEncrypted(pfad, l);
				Text p = pf.getText();
				p += pfad;
				delete[] pfad;
				Datei d;
				d.setDatei(p);
				d.erstellen();
				d.open(Datei::Style::schreiben);
				__int64 größe = 0;
				k->getNachrichtEncrypted((char*)&größe, 8);
				char* buffer = new char[2048];
				while (größe > 0)
				{
					int l = größe > 2048 ? 2048 : (int)größe;
					k->getNachricht(buffer, l);
					d.schreibe(buffer, l);
					größe -= l;
				}
				delete[] buffer;
				d.close();
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Erstellt eine neue Shop Seiten Datei
//  name: Der Name der Datei
//  typ: 0=Ordner, 1=Bild, 2=Text
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ssDateiErstellen(const char* name, int typ)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x1", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char t = typ;
				k->sendeEncrypted(&t, 1);
				char l = (char)textLength(name);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(name, l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Öffnet einen Ordner der Shop Seite
//  name: Der Name des Ordners
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ssOrdnerÖffnen(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x2", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(name);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(name, l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt das ein Bild der Shop Seite und gibt es zurück
//  datei: Der Name der Bilddatei
//  bild: Der Name des Bildes
//  Gibt bei misserfolg 0 zurück
Framework::Bild* EditorClient::ssBildLaden(const char* datei, const char* bild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x3", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(datei);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(datei, l);
				l = (char)textLength(bild);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(bild, l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					Bild* ret = new Bild();
					int br = 0;
					int hö = 0;
					k->getNachrichtEncrypted((char*)&br, 4);
					k->getNachrichtEncrypted((char*)&hö, 4);
					ret->neuBild(br, hö, 0);
					char* buffer = (char*)ret->getBuffer();
					__int64 län = br * hö * 4;
					for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
					{
						k->getNachricht(&(buffer[i]), l);
						i += l;
						län -= l;
					}
					cs.unlock();
					return ret;
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Löscht eine Datei der Shop Seite
//  name: Der Name der Datei
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ssDateiLöschen(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x4", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(name);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(name, l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Läd eine KSGS Datei der Shop Seite und gibt den Quellcode zurück
//  datei: Der Name der Datei
//  Gibt bei misserfolg 0 zurück
Framework::Text* EditorClient::ssTextLaden(const char* datei)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xA", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(datei);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(datei, l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int län = 0;
					k->getNachrichtEncrypted((char*)&län, 4);
					char* txt = new char[län + 1];
					txt[län] = 0;
					for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
						k->getNachricht(&(txt[i]), l);
					k->getNachrichtEncrypted(&ret, 1);
					if (ret == 1)
					{
						Text* t = new Text(txt);
						delete[] txt;
						cs.unlock();
						return t;
					}
					delete[] txt;
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Spechert eine KSGS Datei der Shop Seite
//  datei: Der Name der Datei
//  zText: Ein Zeiger auf den neuen Quellcode (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ssTextSpeichern(const char* datei, Framework::Text* zText)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x5", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(datei);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(datei, l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int län = zText->getLength();
					k->sendeEncrypted((char*)&län, 4);
					for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
						k->sende(&(zText->getText()[i]), l);
					k->getNachrichtEncrypted(&ret, 1);
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Löscht ein Bild der Shop Seite
//  datei: Der Name der Bilddatei
//  bild: Der Name des Bildes
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ssBildLöschen(const char* datei, const char* bild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x6", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(datei);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(datei, l);
				l = (char)textLength(bild);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(bild, l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Speichert ein Bild einer ShopSeite
//  datei: Der name der Bilddatei
//  name: Der Name des Bildes
//  zBild: Ein Zeiger auf das Bild (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ssBildSpeichern(const char* datei, const char* name, Framework::Bild* zBild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x7", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(datei);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(datei, l);
				l = (char)textLength(name);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(name, l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int br = zBild->getBreite();
					int hö = zBild->getHeight();
					k->sendeEncrypted((char*)&br, 4);
					k->sendeEncrypted((char*)&hö, 4);
					__int64 län = br * hö * 4;
					char* buffer = (char*)zBild->getBuffer();
					for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
						k->sende(&(buffer[i]), l);
					k->getNachrichtEncrypted(&ret, 1);
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt eine Liste mit Dateien von der Shop Seite
//  zList: Enthält nach erfolgreichem Aufruf die Liste mit Dateinamen
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
int EditorClient::ssGetDateiListe(Framework::RCArray< Framework::Text >* zList)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x8", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int anz = 0;
				k->getNachrichtEncrypted((char*)&anz, 4);
				for (int i = 0; i < anz; i++)
				{
					char l = 0;
					k->getNachrichtEncrypted(&l, 1);
					char* n = new char[l + 1];
					n[l] = 0;
					k->getNachrichtEncrypted(n, l);
					zList->add(new Text(n));
					delete[] n;
				}
				cs.unlock();
				return anz;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return -1;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Lädt die Bild Liste einer Bild Datei der Shop Seite
//  name: Der Name der Bilddatei
//  zList: Enthält nach erfolgreichem Aufruf eine Liste mit Bildnamen
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
int EditorClient::ssGetBildListe(const char* name, Framework::RCArray< Framework::Text >* zList)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x7", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x9", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)textLength(name);
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(name, l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int anz = 0;
					k->getNachrichtEncrypted((char*)&anz, 4);
					for (int i = 0; i < anz; i++)
					{
						l = 0;
						k->getNachrichtEncrypted(&l, 1);
						char* n = new char[l + 1];
						n[l] = 0;
						k->getNachrichtEncrypted(n, l);
						zList->add(new Text(n));
						delete[] n;
					}
					cs.unlock();
					return anz;
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return -1;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Lädt die Shop Daten
//  es: Enthält nach erfolgreichem aufruf den Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
//  tp: Enthält nach erfolgreichem Aufruf den Preis der Testversion in Kupfer
//  vp: Enthält nach erfolgreichem Aufruf den Preis der Vollversion in Kupfer
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::getShopDaten(int& es, int& tp, int& vp)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x9", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->getNachrichtEncrypted((char*)&es, 4);
			k->getNachrichtEncrypted((char*)&tp, 4);
			k->getNachrichtEncrypted((char*)&vp, 4);
			cs.unlock();
			return 1;
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Setzt die Shop Daten
//  es: der Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
//  tp: der Preis der Testversion in Kupfer
//  vp: der Preis der Vollversion in Kupfer
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::setShopDaten(int es, int tp, int vp)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xA", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted((char*)&es, 4);
			k->sendeEncrypted((char*)&tp, 4);
			k->sendeEncrypted((char*)&vp, 4);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				cs.unlock();
				return 1;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt die Kartenbeschreibung als KSGScript Quellcode zurück
//  Gibt bei misserfolg 0 zurück
Framework::Text* EditorClient::beschreibungLaden()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x1", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int län = 0;
				k->getNachrichtEncrypted((char*)&län, 4);
				char* txt = new char[län + 1];
				txt[län] = 0;
				for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
					k->getNachricht(&(txt[i]), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					Text* t = new Text(txt);
					delete[] txt;
					cs.unlock();
					return t;
				}
				delete[] txt;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt das Titelbild der Karte zurück
//  Gibt bei misserfolg 0 zurück
Framework::Bild* EditorClient::titelbildLaden()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x2", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				Bild* ret = new Bild();
				int br = 0;
				int hö = 0;
				k->getNachrichtEncrypted((char*)&br, 4);
				k->getNachrichtEncrypted((char*)&hö, 4);
				ret->neuBild(br, hö, 0);
				char* buffer = (char*)ret->getBuffer();
				__int64 län = br * hö * 4;
				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
				{
					k->getNachricht(&(buffer[i]), l);
					i += l;
					län -= l;
				}
				cs.unlock();
				return ret;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt das Minimap Bild der Karte zurück
//  Gibt bei misserfolg 0 zurück
Framework::Bild* EditorClient::minimapLaden()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x3", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				Bild* ret = new Bild();
				int br = 0;
				int hö = 0;
				k->getNachrichtEncrypted((char*)&br, 4);
				k->getNachrichtEncrypted((char*)&hö, 4);
				ret->neuBild(br, hö, 0);
				char* buffer = (char*)ret->getBuffer();
				__int64 län = br * hö * 4;
				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
				{
					k->getNachricht(&(buffer[i]), l);
					i += l;
					län -= l;
				}
				cs.unlock();
				return ret;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt das Ladebild der Karte zurück
//  Gibt bei misserfolg 0 zurück
Framework::Bild* EditorClient::ladebildLaden()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x4", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				Bild* ret = new Bild();
				int br = 0;
				int hö = 0;
				k->getNachrichtEncrypted((char*)&br, 4);
				k->getNachrichtEncrypted((char*)&hö, 4);
				ret->neuBild(br, hö, 0);
				char* buffer = (char*)ret->getBuffer();
				__int64 län = br * hö * 4;
				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
				{
					k->getNachricht(&(buffer[i]), l);
					i += l;
					län -= l;
				}
				cs.unlock();
				return ret;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// speichert den KSGScript Quellcode der Kartenbeschreibung
//  zText: Der KSGScript Quellcode (ohne erhöhten reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::beschreibungSpeichern(Framework::Text* zText)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x5", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int län = zText->getLength();
				k->sendeEncrypted((char*)&län, 4);
				for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
					k->sende(&(zText->getText()[i]), l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// speichert das Titelbild der Karte
//  zBild: das neue Titelbild
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::titelbildSpeichern(Framework::Bild* zBild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x6", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int br = zBild->getBreite();
				int hö = zBild->getHeight();
				k->sendeEncrypted((char*)&br, 4);
				k->sendeEncrypted((char*)&hö, 4);
				__int64 län = br * hö * 4;
				char* buffer = (char*)zBild->getBuffer();
				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
					k->sende(&(buffer[i]), l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// speichert das Minimapbild der Karte
//  zBild: das neue Minimapbild
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::minimapSpeichern(Framework::Bild* zBild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x7", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int br = zBild->getBreite();
				int hö = zBild->getHeight();
				k->sendeEncrypted((char*)&br, 4);
				k->sendeEncrypted((char*)&hö, 4);
				__int64 län = br * hö * 4;
				char* buffer = (char*)zBild->getBuffer();
				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
					k->sende(&(buffer[i]), l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// speichert das Ladebild der Karte
//  zBild: das neue Ladebild
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ladebildSpeichern(Framework::Bild* zBild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xB", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x8", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int br = zBild->getBreite();
				int hö = zBild->getHeight();
				k->sendeEncrypted((char*)&br, 4);
				k->sendeEncrypted((char*)&hö, 4);
				__int64 län = br * hö * 4;
				char* buffer = (char*)zBild->getBuffer();
				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
					k->sende(&(buffer[i]), l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// lädt die Spieler Team Daten der Karte
//  sts: Enthält nach erfolgreichem Aufruf die Spieler Team Daten
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::ladeTeamDaten(SpielerTeamStrukturV* sts)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xC", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x1", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				k->getNachrichtEncrypted((char*)&sts->spielerAnzahl, 4);
				k->getNachrichtEncrypted((char*)&sts->teamAnzahl, 4);
				for (int i = 0; i < sts->spielerAnzahl; i++)
				{
					int f = 0;
					k->getNachrichtEncrypted((char*)&f, 4);
					sts->spielerFarbe->set(f, i);
				}
				for (int i = 0; i < sts->teamAnzahl; i++)
				{
					int f = 0;
					k->getNachrichtEncrypted((char*)&f, 4);
					sts->teamFarbe->set(f, i);
				}
				for (int i = 0; i < sts->teamAnzahl; i++)
				{
					char l = 0;
					k->getNachrichtEncrypted(&l, 1);
					char* n = new char[l + 1];
					n[l] = 0;
					k->getNachrichtEncrypted(n, l);
					sts->teamName->set(new Text(n), i);
					delete[] n;
				}
				for (int i = 0; i < sts->teamAnzahl; i++)
				{
					int g = 0;
					k->getNachrichtEncrypted((char*)&g, 4);
					sts->teamSize->set(g, i);
				}
				cs.unlock();
				return 1;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// speichert die Team Daten
//  sts: die neuen Spieler Team Daten
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::speicherTeamDaten(SpielerTeamStrukturV* sts)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xC", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x2", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				k->sendeEncrypted((char*)&sts->spielerAnzahl, 4);
				k->sendeEncrypted((char*)&sts->teamAnzahl, 4);
				for (int i = 0; i < sts->spielerAnzahl; i++)
				{
					int f = sts->spielerFarbe->get(i);
					k->sendeEncrypted((char*)&f, 4);
				}
				for (int i = 0; i < sts->teamAnzahl; i++)
				{
					int f = sts->teamFarbe->get(i);
					k->sendeEncrypted((char*)&f, 4);
				}
				for (int i = 0; i < sts->teamAnzahl; i++)
				{
					char l = (char)sts->teamName->z(i)->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(sts->teamName->z(i)->getText(), l);
				}
				for (int i = 0; i < sts->teamAnzahl; i++)
				{
					int g = sts->teamSize->get(i);
					k->sendeEncrypted((char*)&g, 4);
				}
				cs.unlock();
				return 1;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Erstellt neue Datei im Datei Editor
//  typ: 0=ordner 1=bild 2=modell2d 3=sound
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deNeueDatei(char typ, Framework::Text* zName)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x1", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				k->sendeEncrypted(&typ, 1);
				char l = (char)zName->getLength();
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(zName->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Öffnet Ordner im Datei Editor
//  zName: Der Name des Ordners
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deOrdnerÖffnen(Framework::Text* zName)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x2", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char län = (char)zName->getLength();
				k->sendeEncrypted(&län, 1);
				if (län)
					k->sendeEncrypted(zName->getText(), län);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Gibt ein Bild aus dem Datei Editor zurück
//  zDatei: Der Name der Datei (ohne erhöhten Reference Counter)
//  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
//  Gibt bei misserfolg 0 zurück
Framework::Bild* EditorClient::deBildLaden(Framework::Text* zDatei, Framework::Text* zBild, Framework::FBalken* zF)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	Bild* retB = 0;
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x3", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char län = (char)zDatei->getLength();
				k->sendeEncrypted(&län, 1);
				if (län)
					k->sendeEncrypted(zDatei->getText(), län);
				län = (char)zBild->getLength();
				k->sendeEncrypted(&län, 1);
				if (län)
					k->sendeEncrypted(zBild->getText(), län);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int br = 0;
					int hö = 0;
					k->getNachrichtEncrypted((char*)&br, 4);
					k->getNachrichtEncrypted((char*)&hö, 4);
					retB = new Bild();
					retB->neuBild(br, hö, 0);
					char* buffer = (char*)retB->getBuffer();
					__int64 län = br * hö * 4;
					if (zF)
						zF->setAktionAnzahl(län);
					for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
					{
						k->getNachricht(&(buffer[i]), l);
						i += l;
						län -= l;
						if (zF)
							zF->aktionPlus(l);
					}
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	cs.unlock();
	if (!ret && retB)
		retB = (Bild*)retB->release();
	if (!retB)
		err = "Unbekannter Fehler";
	return retB;
}

// Löscht eine Datei aus dem Datei Editor
//  zName: Der Name der Datei
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deDateiLöschen(Framework::Text* zName)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x4", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char län = (char)zName->getLength();
				k->sendeEncrypted(&län, 1);
				if (län)
					k->sendeEncrypted(zName->getText(), län);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Löscht Bild aus Datei im Datei Editor
//  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
//  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deBildLöschen(Framework::Text* zDatei, Framework::Text* zBild)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x5", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(zDatei->getText(), l);
				l = (char)zBild->getLength();
				k->sendeEncrypted(&l, 1);
				if (l)
					k->sendeEncrypted(zBild->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Speichert Bild in Datei im Datei Editor
//  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
//  zName: Der Name des Bildes (ohne erhöhten Reference Counter)
//  zBild: Das neue Bild (ohne erhöhten Reference Counter)
//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deBildSpeichern(Framework::Text* zDatei, Framework::Text* zName, Framework::Bild* zBild, Framework::FBalken* zF)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x6", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char län = (char)zDatei->getLength();
				k->sendeEncrypted(&län, 1);
				if (län)
					k->sendeEncrypted(zDatei->getText(), län);
				län = (char)zName->getLength();
				k->sendeEncrypted(&län, 1);
				if (län)
					k->sendeEncrypted(zName->getText(), län);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int br = zBild->getBreite();
					int hö = zBild->getHeight();
					k->sendeEncrypted((char*)&br, 4);
					k->sendeEncrypted((char*)&hö, 4);
					char* buffer = (char*)zBild->getBuffer();
					__int64 gr = br * hö * 4;
					if (zF)
						zF->setAktionAnzahl(gr);
					for (int i = 0, l = gr > 2048 ? 2048 : (int)gr; gr > 0; i += l, gr -= l, l = gr > 2048 ? 2048 : (int)gr)
					{
						k->sende(&(buffer[i]), l);
						if (zF)
							zF->aktionPlus(l);
					}
					k->getNachrichtEncrypted(&ret, 1);
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt eine Liste mit Dateien im aktuellen Ordner des Datei Editors
//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit Dateinamen (ohne erhöhten Reference Counter)
//  Gibt die Anzahl der Dateien zurück
int EditorClient::deGetDateiListe(Framework::RCArray< Framework::Text >* zNamen)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x7", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				int anz = 0;
				k->getNachrichtEncrypted((char*)&anz, 4);
				for (int i = 0; i < anz; i++)
				{
					char l = 0;
					k->getNachrichtEncrypted(&l, 1);
					char* n = new char[l + 1];
					n[l] = 0;
					if (l)
						k->getNachrichtEncrypted(n, l);
					zNamen->add(new Text(n));
					delete[] n;
				}
				cs.unlock();
				return anz;
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return -1;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt eine Liste mit Bildern aus einer Bilddatei des Datei Editors
//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Bildnamen (ohne erhöhten Reference Counter)
//  Gibt die Anzahl der Bilder zurück
int EditorClient::deGetBildListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x8", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int anz = 0;
					k->getNachrichtEncrypted((char*)&anz, 4);
					for (int i = 0; i < anz; i++)
					{
						k->getNachrichtEncrypted(&l, 1);
						char* n = new char[l + 1];
						n[l] = 0;
						if (l)
							k->getNachrichtEncrypted(n, l);
						zNamen->add(new Text(n));
						delete[] n;
					}
					cs.unlock();
					return anz;
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt eine Liste mit 2D Modellen aus einer Modeldatei im Datei Editor
//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Modelnamen (ohne erhöhten Reference Counter)
//  Gibt die Anzahl der Modelle zurück
int EditorClient::deGetModelListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x9", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int anz = 0;
					k->getNachrichtEncrypted((char*)&anz, 4);
					for (int i = 0; i < anz; i++)
					{
						k->getNachrichtEncrypted(&l, 1);
						char* n = new char[l + 1];
						n[l] = 0;
						if (l)
							k->getNachrichtEncrypted(n, l);
						zNamen->add(new Text(n));
						delete[] n;
					}
					cs.unlock();
					return anz;
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt eine Liste mit Sounds aus einer Sounddatei im Datei Editor
//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Soundnamen (ohne erhöhten Reference Counter)
//  Gibt die Anzahl der Sounds zurück
int EditorClient::deGetSoundListe(Framework::Text* zDatei, Framework::RCArray<  Framework::Text >* zNamen)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xA", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					int anz = 0;
					k->getNachrichtEncrypted((char*)&anz, 4);
					for (int i = 0; i < anz; i++)
					{
						k->getNachrichtEncrypted(&l, 1);
						char* n = new char[l + 1];
						n[l] = 0;
						if (l)
							k->getNachrichtEncrypted(n, l);
						zNamen->add(new Text(n));
						delete[] n;
					}
					cs.unlock();
					return anz;
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Löscht ein Model aus einer Modeldatei des Datei Editors
//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
//  zModel: Der Name des Models (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deModelLöschen(Framework::Text* zDatei, Framework::Text* zModel)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xB", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					l = (char)zModel->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(zModel->getText(), l);
					k->getNachrichtEncrypted(&ret, 1);
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Löscht einen Sound aus einer Sounddatei des Datei Editors
//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deSoundLöschen(Framework::Text* zDatei, Framework::Text* zSound)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xC", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					l = (char)zSound->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(zSound->getText(), l);
					k->getNachrichtEncrypted(&ret, 1);
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Setzt das arbeitsverzeichnis auf den obersten ordner
bool EditorClient::deResetPath()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x11", 1);
			k->getNachrichtEncrypted(&ret, 1);
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt ein Model aus einer Modeldatei des Datei Editors
//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
//  zModel: Enthält nach erfolgreichem Aufruf das Model (ohne erhöhten Reference Counter)
//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
Framework::Model2DData* EditorClient::deModelLaden(Framework::Text* zDatei, Framework::Text* zModel, Framework::FBalken* zF)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xD", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					l = (char)zModel->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(zModel->getText(), l);
					k->getNachrichtEncrypted(&ret, 1);
					if (ret == 1)
					{
						int anz = 0;
						k->getNachrichtEncrypted((char*)&anz, 4);
						if (zF)
							zF->setAktionAnzahl(anz);
						Array< Polygon2D >* pol = new Array< Polygon2D >();
						for (int i = 0; i < anz; i++)
						{
							Polygon2D p;
							p.schwerpunkt = new Vertex(0, 0);
							p.vertex = new Array< Vertex >();
							p.tKordinaten = new Array< Vertex >();
							k->getNachrichtEncrypted((char*)&p.transparent, 1);
							char nLän = 0;
							k->getNachrichtEncrypted(&nLän, 1);
							char* txt = new char[nLän + 1];
							if (nLän)
								k->getNachrichtEncrypted(txt, nLän);
							txt[nLän] = 0;
							p.name = new Text(txt);
							delete[] txt;
							int anz2 = 0;
							k->getNachrichtEncrypted((char*)&anz2, 4);
							for (int j = 0; j < anz2; j++)
							{
								Vertex v;
								k->getNachrichtEncrypted((char*)&v.x, 4);
								k->getNachrichtEncrypted((char*)&v.y, 4);
								*p.schwerpunkt += v * (float)(1.0 / anz2);
								Vertex t;
								k->getNachrichtEncrypted((char*)&t.x, 4);
								k->getNachrichtEncrypted((char*)&t.y, 4);
								p.vertex->add(v);
								p.tKordinaten->add(t);
							}
							pol->add(p);
							if (zF)
								zF->aktionPlus();
						}
						Model2DData* data = new Model2DData();
						data->erstelleModell(pol);
						cs.unlock();
						return data;
					}
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Lädt einen Sound herunter und gibt ihn zurück
//  file: Ein Zeiger auf die GSLDatei, in der der Sound gespeichert werden soll
//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
//  Gibt bei misserfolg 0 zurück
GSL::GSLSoundV* EditorClient::deSoundLaden(GSL::GSLDateiV* file, Framework::Text* zDatei, Framework::Text* zSound, Framework::FBalken* zF)
{
	file->setDatei((char*)"data/tmp/editor/dateien/sounds/tmp.gsl");
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		file->release();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xE", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					l = (char)zSound->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(zSound->getText(), l);
					k->getNachrichtEncrypted(&ret, 1);
					if (ret == 1)
					{
						DownloadSound dws(k, zF);
						file->speicherSound(&dws, zSound->getText());
						GSL::GSLSoundV* s = file->getSound(zSound->getText());
						file->release();
						cs.unlock();
						return s;
					}
				}
			}
		}
	}
	file->release();
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Speichert ein Model in eine Modeldatei des Datei Editors
//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
//  zModel: Der Name des Models (ohne erhöhten Reference Counter)
//  zData: Die Daten des Models (ohne erhöhten Reference Counter)
//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deModelSpeichern(Framework::Text* zDatei, Framework::Text* zModel, Framework::Model2DData* zData, Framework::FBalken* zF)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\xF", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					l = (char)zModel->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(zModel->getText(), l);
					k->getNachrichtEncrypted(&ret, 1);
					if (ret == 1)
					{
						int anz = zData->polygons ? zData->polygons->getEintragAnzahl() : 0;
						if (zF)
							zF->setAktionAnzahl(anz);
						k->sendeEncrypted((char*)&anz, 4);
						for (int i = 0; i < anz; i++)
						{
							Polygon2D pol = zData->polygons->get(i);
							k->sendeEncrypted((char*)&pol.transparent, 1);
							char nLän = pol.name->getLength();
							k->sendeEncrypted(&nLän, 1);
							if (nLän)
								k->sendeEncrypted(pol.name->getText(), nLän);
							int anz2 = pol.vertex->getEintragAnzahl();
							k->sendeEncrypted((char*)&anz2, 4);
							for (int j = 0; j < anz2; j++)
							{
								Vertex v = pol.vertex->get(j);
								Vertex p;
								if (pol.tKordinaten)
									p = pol.tKordinaten->hat(j) ? pol.tKordinaten->get(j) : Vertex(0, 0);
								k->sendeEncrypted((char*)&v.x, 4);
								k->sendeEncrypted((char*)&v.y, 4);
								k->sendeEncrypted((char*)&p.x, 4);
								k->sendeEncrypted((char*)&p.y, 4);
							}
							if (zF)
								zF->aktionPlus();
						}
						k->getNachrichtEncrypted(&ret, 1);
					}
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Speichert einen Sound in einer Sounddatei des Datei Editors
//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
//  zData: Die Daten des Sounts (ohne erhöhten Reference Counter)
//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::deSoundSpeichern(Framework::Text* zDatei, Framework::Text* zSound, GSL::GSLSoundV* zData, Framework::FBalken* zF)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xD", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->sendeEncrypted("\x10", 1);
			k->getNachrichtEncrypted(&ret, 1);
			if (ret == 1)
			{
				char l = (char)zDatei->getLength();
				k->sendeEncrypted(&l, 1);
				k->sendeEncrypted(zDatei->getText(), l);
				k->getNachrichtEncrypted(&ret, 1);
				if (ret == 1)
				{
					l = (char)zSound->getLength();
					k->sendeEncrypted(&l, 1);
					k->sendeEncrypted(zSound->getText(), l);
					k->getNachrichtEncrypted(&ret, 1);
					if (ret == 1)
					{
						char channels = zData->istMono() ? 1 : 2;
						k->sendeEncrypted(&channels, 1);
						int sample = zData->getSampleRate();
						k->sendeEncrypted((char*)&sample, 4);
						__int64 slän = zData->getDatLength();
						k->sendeEncrypted((char*)&slän, 8);
						if (zF)
							zF->setAktionAnzahl(slän);
						zData->open();
						char* buffer = new char[2048];
						while (slän > 0)
						{
							int l = slän > 2048 ? 2048 : (int)slän;
							zData->getDaten(buffer, l);
							k->sende(buffer, l);
							slän -= l;
							if (zF)
								zF->aktionPlus(l);
						}
						delete[] buffer;
						zData->close();
					}
				}
			}
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Lädt die Kauf Statistik der geladenen Karte
//  verkauft: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Käufe der Karte der letzten 30 Tage
//  einkommen: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der verdinten Kupfer in den letzten 30 Tagen
//  gespielt: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Spielen der letzten 30 Tage
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
int EditorClient::getVerkaufStatistik(Framework::Array< int >* verkauft, Framework::Array< int >* einkommen, Framework::Array< int >* gespielt)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\x10", 1);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			int kaufAnz = 0;
			k->getNachrichtEncrypted((char*)&kaufAnz, 4);
			char anz = 0;
			k->getNachrichtEncrypted(&anz, 1);
			for (int i = 0; i < anz; i++)
			{
				int kupfer = 0;
				int kauf = 0;
				int games = 0;
				k->getNachrichtEncrypted((char*)&kupfer, 4);
				k->getNachrichtEncrypted((char*)&kauf, 4);
				k->getNachrichtEncrypted((char*)&games, 4);
				einkommen->add(kupfer);
				verkauft->add(kauf);
				gespielt->add(games);
			}
			cs.unlock();
			return kaufAnz;
		}
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool EditorClient::initEditor()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x7", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted("\xE", 1);
		k->getNachrichtEncrypted(&ret, 1);
	}
	if (ret == 3)
	{
		char byte = 0;
		k->getNachrichtEncrypted(&byte, 1);
		char* f = new char[byte + 1];
		f[byte] = 0;
		k->getNachrichtEncrypted(f, byte);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	if (ret != 1)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret == 1;
}

// Erhält die Verbindung aufrecht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
bool EditorClient::keepAlive()
{
	if (!cs.tryLock())
		return 1;
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char res = 0;
	bool ok = k->sendeEncrypted("\x5", 1);
	ok &= k->getNachrichtEncrypted(&res, 1);
	cs.unlock();
	if (res != 1 || !ok)
		trenne(0);
	if (res != 1)
		err = "Unbekannter Fehler";
	return res == 1;
}

// Trennt die Verbindung zum Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
bool EditorClient::trenne(bool abmelden)
{
	cs.lock();
	verbinde();
	if (!k)
	{
		cs.unlock();
		return 1;
	}
	if (abmelden)
	{
		k->sendeEncrypted("\4", 1);
		char ret = 0;
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 3)
		{ // error
			k->getNachrichtEncrypted(&ret, 1);
			char* msg = new char[ret + 1];
			msg[ret] = 0;
			if (ret)
				k->getNachrichtEncrypted(msg, ret);
			err = "error while unregister Client Editor Server returned: ";
			err += msg;
			delete[] msg;
		}
	}
	k->sendeEncrypted("\3", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 3)
	{ // error
		k->getNachrichtEncrypted(&ret, 1);
		char* msg = new char[ret + 1];
		msg[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(msg, ret);
		err = "error while trenne Editor Server returned: ";
		err += msg;
		delete[] msg;
	}
	k->trenne();
	k = (Network::Klient*)k->release();
	cs.unlock();
	return 1;
}

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

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

// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
bool EditorClient::istVerbunden() const
{
	return k != 0;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
const char* EditorClient::getLetzterFehler() const
{
	return err;
}