KSGNetwork/KSGNetwork/InformationClient.cpp

#include "InformationClient.h"
#include "Keys.h"
#include <Klient.h>
#include "EditorClient.h"
#include "KartenClient.h"
#include "HistorieClient.h"

using namespace KSGClient;

// Inhalt der InformationClient Klasse

// Konstruktor
InformationClient::InformationClient(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
InformationClient::~InformationClient()
{
	trenne(1);
	delete[] key;
}

// verbindet ich mit dem zugewiesenen Informaion Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool InformationClient::verbinde()
{
	cs.lock();
	if (k)
	{
		cs.unlock();
		return 1;
	}
	k = new Network::Klient();
	int l = 0;
	char* key;
	Keys::getServerKey(&key, l, Keys::INFORMATION, Keys::SENDEN);
	k->setSendeKey(key, l);
	delete[] key;
	Keys::getServerKey(&key, l, Keys::INFORMATION, 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 Information 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 Information Server";
			k = (Network::Klient*)k->release();
			cs.unlock();
			return 0;
		}
	}
	else
	{
		err = "network error while connecting to Information Server";
		k = (Network::Klient*)k->release();
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// fragt nach dem Informationstext
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
//  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
bool InformationClient::getInformationText(Framework::Text* txt, int* typ)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	bool ret = 1;
	ret = ret & k->sendeEncrypted("\5", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	short län = 0;
	ret = ret & k->getNachrichtEncrypted((char*)&län, 2);
	char* text = new char[län + 1];
	text[län] = 0;
	if (län)
		ret = ret & k->getNachrichtEncrypted(text, län);
	txt->setText(text);
	delete[]text;
	char type = 0;
	ret = ret & k->getNachrichtEncrypted(&type, 1);
	*typ = type;
	if (!ret)
		err = "Verbindungsfehler";
	cs.unlock();
	return ret;
}

// fragt, ob das entsprechende Spiel vom Server gesperrt wurde
//  spielId: Die Id des Spiels
//  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
bool InformationClient::istSpielErlaubt(int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\6", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&spielId, 4);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (!ret)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret != 0;
}

// fragt, ob die entsprechende Karte vom Server gesperrt wurde
//  karteId: Die Id der Karte
//  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
bool InformationClient::istKarteErlaubt(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\7", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&karteId, 4);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (!ret)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret != 0;
}

// Ermittelt die Id einer Karte
//  name: Der Name der Karte
//  Gibt bei misserfolg 0 zurück
int InformationClient::getKarteId(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x9", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	char län = textLength(name);
	k->sendeEncrypted(&län, 1);
	k->sendeEncrypted(name, län);
	int id = 0;
	k->getNachrichtEncrypted((char*)&id, 4);
	cs.unlock();
	return id;
}

// Fragt nach der Id eines Spiels
//  name: Der Name des Spiels
//  Gibt bei misserfolg 0 zurück
int InformationClient::getSpielId(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x8", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	char län = textLength(name);
	k->sendeEncrypted(&län, 1);
	k->sendeEncrypted(name, län);
	int id = 0;
	k->getNachrichtEncrypted((char*)&id, 4);
	cs.unlock();
	return id;
}

// fragt nach dem Namen eines Accounts
//  accountId: Die Id des Accounts
//  Gibt bei misserfolg 0 zurück
Framework::Text* InformationClient::getSpielerName(int accountId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xA", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&accountId, 4);
	char län = 0;
	k->getNachrichtEncrypted(&län, 1);
	char* name = new char[län + 1];
	name[län] = 0;
	if (län)
		k->getNachrichtEncrypted(name, län);
	Text* ret = new Text(name);
	delete[]name;
	cs.unlock();
	return ret;
}

// fragt nach der Spiel Statistik eines Accounts
//  accountId: Die Id des Accounts
//  spielId: Die Id des Spiels
//  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
bool InformationClient::getSpielStatistik(int accountId, int spielId, Framework::Array< int >* werte)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	bool ret = 1;
	ret = ret & k->sendeEncrypted("\xB", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	ret = ret & k->sendeEncrypted((char*)&accountId, 4);
	ret = ret & k->sendeEncrypted((char*)&spielId, 4);
	for (int i = 0; i < 10; i++)
	{
		int tmp = 0;
		ret = ret & k->getNachrichtEncrypted((char*)&tmp, 4);
		werte->add(tmp, i);
	}
	if (!ret)
		err = "Verbindungsfehler";
	cs.unlock();
	return ret;
}

// fragt nach dem Namen einer Karte
//  karteId: Die id der Karte
//  Gibt bei misserfolg 0 zurück
Framework::Text* InformationClient::getKarteName(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xE", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&karteId, 4);
	char län = 0;
	k->getNachrichtEncrypted(&län, 1);
	char* name = new char[län + 1];
	name[län] = 0;
	if (län)
		k->getNachrichtEncrypted(name, län);
	Text* ret = new Text(name);
	delete[]name;
	cs.unlock();
	return ret;
}

// fragt nach dem Namen eines Spiels
//  spielId: Die id des Spiels
//  Gibt bei misserfolg 0 zurück
Framework::Text* InformationClient::getSpielName(int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xF", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&spielId, 4);
	char län = 0;
	k->getNachrichtEncrypted(&län, 1);
	char* name = new char[län + 1];
	name[län] = 0;
	if (län)
		k->getNachrichtEncrypted(name, län);
	Text* ret = new Text(name);
	delete[]name;
	cs.unlock();
	return ret;
}

// fragt nach dem Namen eines Chatrooms
//  chatroomId: Die id des Chatrooms
//  Gibt bei misserfolg 0 zurück
Framework::Text* InformationClient::getChatroomName(int chatroomId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x10", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&chatroomId, 4);
	char län = 0;
	k->getNachrichtEncrypted(&län, 1);
	char* name = new char[län + 1];
	name[län] = 0;
	if (län)
		k->getNachrichtEncrypted(name, län);
	Text* ret = new Text(name);
	delete[]name;
	cs.unlock();
	return ret;
}

// fragt zu welcher Spielart die Karte gehört
//  karteId: Die id der Karte
//  Gibt bei misserfolg 0 zurück
int InformationClient::getSpielId(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x11", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&karteId, 4);
	int ret = 0;
	k->getNachrichtEncrypted((char*)&ret, 4);
	if (!ret)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret;
}

// gibt die Id eines Accounts zurück
//  name: Der Angezeigte Name des Accounts
//  Gibt bei misserfolg 0 zurück
int InformationClient::getAccountId(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(name);
	if (!län)
	{
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x12", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted(&län, 1);
	k->sendeEncrypted(name, län);
	int ret = 0;
	k->getNachrichtEncrypted((char*)&ret, 4);
	if (!ret)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret;
}

// gibt die Id des Chatrooms zurück
//  name: Der name des Chatrooms
//  Gibt bei misserfolg 0 zurück
int InformationClient::getChatroomId(const char* name)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(name);
	if (!län)
	{
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x13", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted(&län, 1);
	k->sendeEncrypted(name, län);
	int ret = 0;
	k->getNachrichtEncrypted((char*)&ret, 4);
	if (!ret)
		err = "Unbekannter Fehler";
	cs.unlock();
	return ret;
}

// gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
//  gruppenId: Die id der Gruppe
//  Gibt bei misserfolg 0 zurück
int InformationClient::getGruppenKarteId(int gruppenId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\xD", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&gruppenId, 4);
	int id = 0;
	k->getNachrichtEncrypted((char*)&id, 4);
	if (!id)
		err = "Unbekannter Fehler";
	cs.unlock();
	return id;
}

// gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
//  gruppeId: Die id der Gruppe
bool InformationClient::getGruppeSpielerHinzufügen(int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x1E", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&gruppeId, 4);
	char sh = 0;
	k->getNachrichtEncrypted((char*)&sh, 1);
	cs.unlock();
	return sh == 1;
}

// gibt die Account Id des Gruppen Administrators zurück
//  gruppeId: Die Id der Gruppe
//  Gibt bei misserfolg 0 zurück
int InformationClient::getGruppeAdminId(int gruppeId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x15", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&gruppeId, 4);
	int id = 0;
	k->getNachrichtEncrypted((char*)&id, 4);
	if (!id)
		err = "Unbekannter Fehler";
	cs.unlock();
	return id;
}

// gibt die Punkte eines Spielers zurück
//  accountId: Die Accont Id des Spielers
//  spielId: Die Id des Spiels
//  Gibt bei misserfolg 0 zurück
int InformationClient::getSpielerPunkte(int accountId, int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x14", 1);
	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 = f;
		delete[]f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&spielId, 4);
	k->sendeEncrypted((char*)&accountId, 4);
	int punkte = 0;
	k->getNachrichtEncrypted((char*)&punkte, 4);
	cs.unlock();
	return punkte;
}

// gibt eine Liste mit Ids von gekauften Spielen zurück
//  Gibt bei misserfolg 0 zurück
Framework::Array< int >* InformationClient::getAccountSpielArtListe()
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x16", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		Array< int >* list = new Array< int >();
		for (int i = 0; i < anz; i++)
		{
			int id = 0;
			k->getNachrichtEncrypted((char*)&id, 4);
			list->add(id);
		}
		cs.unlock();
		return list;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* f = new char[ret + 1];
		f[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(f, ret);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// gibt die neuste Version eines Spiels zurück
//  spielId: Die Id des Spiels
//  Gibt bei misserfolg 0 zurück
int InformationClient::getSpielVersion(int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x17", 1);
	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 = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&spielId, 4);
	int version = 0;
	k->getNachrichtEncrypted((char*)&version, 4);
	cs.unlock();
	return version;
}

// gibt das Kupfer des Accounts zurück
//  Gibt bei misserfolg 0 zurück
int InformationClient::getKupfer()
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x18", 1);
	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 = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	int kupfer = 0;
	k->getNachrichtEncrypted((char*)&kupfer, 4);
	cs.unlock();
	return kupfer;
}

// Gibt die Dateigruppem Id eines Spieles zurück
//  spielId: Die Id des Spiels
//  Gibt bei misserfolg 0 zurück
int InformationClient::getDateiGruppeIdVonSpiel(int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x19", 1);
	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 = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&spielId, 4);
	int dgId = 0;
	k->getNachrichtEncrypted((char*)&dgId, 4);
	cs.unlock();
	return dgId;
}

// Gibt den Dateigruppen Pfad zurück
//  dgId: Die Id der Dateigruppe
//  Gibt bei misserfolg 0 zurück
Framework::Text* InformationClient::getDateiGruppePfad(int dgId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x1A", 1);
	char serverReturn = 0;
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&dgId, 4);
		k->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			char län = 0;
			k->getNachrichtEncrypted(&län, 1);
			char* pf = new char[län + 1];
			pf[län] = 0;
			if (län)
				k->getNachrichtEncrypted(pf, län);
			Text* pfad = new Text(pf);
			delete[] pf;
			cs.unlock();
			return pfad;
		}
	}
	if (serverReturn == 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 eine Liste mit gekauften Karten zurück
//  spielId: Die Spiel Id zu der die Karten gehören sollen
//  Gibt bei misserfolg 0 zurück
Framework::Array< int >* InformationClient::getAccountKarteListe(int spielId)
{
	char ret = 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x1B", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&spielId, 4);
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		Array< int >* list = new Array< int >();
		for (int i = 0; i < anz; i++)
		{
			int id = 0;
			k->getNachrichtEncrypted((char*)&id, 4);
			list->add(id);
		}
		cs.unlock();
		return list;
	}
	if (ret == 3)
	{
		k->getNachrichtEncrypted(&ret, 1);
		char* f = new char[ret + 1];
		f[ret] = 0;
		if (ret)
			k->getNachrichtEncrypted(f, ret);
		err = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// Gibt die Dateigruppen Id eines Pfades zurück
//  pfad: Der Pfad der Dateigruppe
//  Gibt bei misserfolg 0 zurück
int InformationClient::getDateiGruppeIdVonPfad(const char* pfad)
{
	char län = textLength(pfad);
	if (!län)
		return 0;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x2A", 1);
	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 = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&län, 1);
	k->sendeEncrypted((char*)pfad, län);
	int dgId = 0;
	k->getNachrichtEncrypted((char*)&dgId, 4);
	cs.unlock();
	return dgId;
}

// gibt die neuste Version einer Dateigruppe zurück
//  dg: Die Dateigruppen Id
//  Gibt bei misserfolg 0 zurück
int InformationClient::getDateiGruppeVersion(int dg)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x2B", 1);
	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 = f;
		delete[] f;
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted((char*)&dg, 4);
	int version = 0;
	k->getNachrichtEncrypted((char*)&version, 4);
	cs.unlock();
	return version;
}

// Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
//  suche: Der Text, der in den Namen enthalten sein soll
//  seite: Die gewünschte Seite der Tabelle (enthält nach einem Erfolgreichen Aufruf die korrekte Seite)
//  maxSeite: Enthält nach erfolgreichem Aufruf die Maximale Seite
//  sortSpalte: Die Spalte, nach der Sortiert werden soll
//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
//  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
//  Gibt die Anzahl der gefundenen Accounts zurück
//  Gibt die Anzahl der Spieler zurück, -1 bei fehler
int InformationClient::getSpielerListe(const char* suche, int* seite, int* maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo >* accounts)
{
	char län = textLength(suche);
	if (!län)
		return -1;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char serverReturn = 0;
	k->sendeEncrypted("\xC", 1);
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted(&län, 1);
		k->sendeEncrypted(suche, län);
		k->sendeEncrypted((char*)seite, 4);
		k->sendeEncrypted(&sortSpalte, 1);
		k->sendeEncrypted(&rückwärts, 1);
		k->getNachrichtEncrypted((char*)seite, 4);
		k->getNachrichtEncrypted((char*)maxSeite, 4);
		int ret = 0;
		k->getNachrichtEncrypted((char*)&ret, 4);
		for (int i = 0; i < ret; i++)
		{
			AccountInfo info;
			k->getNachrichtEncrypted((char*)&info.id, 4);
			k->getNachrichtEncrypted(&län, 1);
			char* txt = new char[län + 1];
			txt[län] = 0;
			k->getNachrichtEncrypted(txt, län);
			info.name = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			k->getNachrichtEncrypted(txt, län);
			info.zuletztOnline = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			k->getNachrichtEncrypted(txt, län);
			info.letztesSpiel = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			k->getNachrichtEncrypted(txt, län);
			info.letzteKarte = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			k->getNachrichtEncrypted(txt, län);
			info.punkte = txt;
			delete[] txt;
			accounts->add(info);
		}
		cs.unlock();
		return ret;
	}
	if (serverReturn == 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 -1;
}

// ermittelt die aktivität eines Spielers
//  accId: Die Id des Accounts
//  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
bool InformationClient::getSpielerAktivität(int accId, Framework::Array< AccountActivityInfo >* info)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char ret = 0;
	k->sendeEncrypted("\x1F", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&accId, 4);
		k->getNachrichtEncrypted(&ret, 1);
		if (ret == 1)
		{
			k->getNachrichtEncrypted(&ret, 1);
			for (int i = 0; ret; i++)
			{
				AccountActivityInfo inf;
				char* txt = new char[ret + 1];
				txt[ret] = 0;
				k->getNachrichtEncrypted(txt, ret);
				inf.datum = txt;
				delete[] txt;
				k->getNachrichtEncrypted((char*)&inf.stOnline, 8);
				k->getNachrichtEncrypted((char*)&inf.stGespielt, 8);
				k->getNachrichtEncrypted((char*)&inf.anzSpiele, 4);
				k->getNachrichtEncrypted((char*)&inf.anzGewonnen, 4);
				k->getNachrichtEncrypted(&ret, 1);
				info->add(inf);
			}
		}
	}
	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 zurück, wie oft ein Spieler eine Karte schon gespielt hat
//  account: Die Id des Accounts
//  karte: Die Id der Karte
int InformationClient::getAccountKarteSpiele(int account, int karte)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char ret = 0;
	k->sendeEncrypted("\x20", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		k->sendeEncrypted((char*)&karte, 4);
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		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;
}

// Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
//  account: Die Id des Accounts
//  karte: Die Id der Karte
int InformationClient::getAccountKarteSpieleGewonnen(int account, int karte)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char ret = 0;
	k->sendeEncrypted("\x21", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		k->sendeEncrypted((char*)&karte, 4);
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		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;
}

// Gibt zurück, ob ein Spieler die Karte im Besitz hat
//  account: Die Id des Accounts
//  karte: Die Id der Karte
bool InformationClient::hatAccountKarte(int account, int karte)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char ret = 0;
	k->sendeEncrypted("\x22", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		k->sendeEncrypted((char*)&karte, 4);
		char status = 0;
		k->getNachrichtEncrypted(&status, 1);
		cs.unlock();
		return status != 0;
	}
	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 zurück, ob ein Spieler ein Spiel im Besitz hat
//  account: Die Id des Accounts
//  spiel: Die Id des Spiels
bool InformationClient::hatAccountSpiel(int account, int spiel)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char ret = 0;
	k->sendeEncrypted("\x23", 1);
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		k->sendeEncrypted((char*)&spiel, 4);
		char status = 0;
		k->getNachrichtEncrypted(&status, 1);
		cs.unlock();
		return status != 0;
	}
	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 eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
//  account: Die Id des Accounts
//  spiel: Die Id des Spiels 
//  Gibt bei misserfolg 0 zurück
Framework::Array< int >* InformationClient::getAccountKarteGespieltListe(int account, int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x24", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		k->sendeEncrypted((char*)&spielId, 4);
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		Array< int >* ret = new Array< int >();
		for (int i = 0; i < anz; i++)
		{
			int val = 0;
			k->getNachrichtEncrypted((char*)&val, 4);
			ret->set(val, i);
		}
		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 eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
//  account: Die Id des Accounts
//  Gibt bei misserfolg 0 zurück
Framework::Array< int >* InformationClient::getAccountSpielGespieltListe(int account)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x25", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		Array< int >* ret = new Array< int >();
		for (int i = 0; i < anz; i++)
		{
			int val = 0;
			k->getNachrichtEncrypted((char*)&val, 4);
			ret->set(val, i);
		}
		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 eine Liste von Spiel Partnern eines Spielers zurück
//  account: Die Id des Accounts
//  spieler: Enthält nach erfolgreichem Aufruf eine Liste mit Account Ids der Spiel Partner
//  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
//  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool InformationClient::getSpielPartnerListe(int account, Framework::Array< int >* spieler, Framework::Array< int >* karten, Framework::Array< int >* anzahl)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x26", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		int anz = 0;
		k->getNachrichtEncrypted((char*)&anz, 4);
		for (int i = 0; i < anz; i++)
		{
			int val = 0;
			k->getNachrichtEncrypted((char*)&val, 4);
			spieler->set(val, i);
			k->getNachrichtEncrypted((char*)&val, 4);
			karten->set(val, i);
			k->getNachrichtEncrypted((char*)&val, 4);
			anzahl->set(val, 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;
}

// Gibt eine Liste mit Spiel Statistiken zurück
//  account: Die Id des Accounts zu dem die Statistik ermittelt werden soll
//  seite: Die gewünschte Seite. Enthält nach efolgreichem Aufruf die korrekte Seite
//  maxSeite: Enthält nach erfolgreichem Aufruf die Macimale Seite
//  sortSpalte: Die Spalte, nach der Sortiert werden soll
//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
//  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
//  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool InformationClient::getStatistikListe(int account, int* seite, int* maxSeite, char sortSpalte, char rückwärts,
	Framework::RCArray< Framework::Array< int > >* werte, Framework::RCArray< Framework::Text >* namen)
{
	if (!*seite)
		*seite = 1;
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char serverReturn = 0;
	k->sendeEncrypted("\x27", 1);
	k->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		k->sendeEncrypted((char*)&account, 4);
		k->sendeEncrypted((char*)seite, 4);
		k->sendeEncrypted(&sortSpalte, 1);
		k->sendeEncrypted(&rückwärts, 1);
		k->getNachrichtEncrypted((char*)seite, 4);
		k->getNachrichtEncrypted((char*)maxSeite, 4);
		int zAnz = 0;
		int sAnz = 0;
		k->getNachrichtEncrypted((char*)&zAnz, 4);
		k->getNachrichtEncrypted((char*)&sAnz, 4);
		for (int i = 0; i < zAnz; i++)
		{
			Array< int >* tmp = new Array< int >();
			for (int j = 0; j < sAnz; j++)
			{
				if (j != 1)
				{
					int val = 0;
					k->getNachrichtEncrypted((char*)&val, 4);
					tmp->set(val, j);
				}
				else
				{
					char län = 0;
					k->getNachrichtEncrypted(&län, 1);
					char* n = new char[län + 1];
					n[län] = 0;
					if (län)
						k->getNachrichtEncrypted(n, län);
					namen->set(new Text(n), i);
					delete[] n;
				}
			}
			werte->set(tmp, i);
		}
		cs.unlock();
		return 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 = f;
		delete[] f;
	}
	cs.unlock();
	return 0;
}

// Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
//  account: Die Id des Accounts
//  Gibt bei misserfolg 0 zurück
Array< SpielHistorieDaten >* InformationClient::getSpielHistorieDaten(int account)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x28", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		Array< SpielHistorieDaten >* daten = new Array< SpielHistorieDaten >();
		k->sendeEncrypted((char*)&account, 4);
		char anz = 0;
		k->getNachrichtEncrypted(&anz, 1);
		for (char i = 0; i < anz; i++)
		{
			SpielHistorieDaten spiel;
			k->getNachrichtEncrypted((char*)&spiel.id, 4);
			k->getNachrichtEncrypted((char*)&spiel.karteId, 4);
			char län = 0;
			k->getNachrichtEncrypted(&län, 1);
			char* txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.spiel = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.karte = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.datum = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.status = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.dauer = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.spielStatus = txt;
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			spiel.gewinner = txt;
			delete[] txt;
			k->getNachrichtEncrypted((char*)&spiel.sAnzahl, 4);
			char tAnz = 0;
			k->getNachrichtEncrypted(&tAnz, 1);
			for (char j = 0; j < tAnz; j++)
			{
				SpielHistorieTeamDaten team;
				char län = 0;
				k->getNachrichtEncrypted(&län, 1);
				char* txt = new char[län + 1];
				txt[län] = 0;
				if (län)
					k->getNachrichtEncrypted(txt, län);
				team.name = txt;
				delete[] txt;
				k->getNachrichtEncrypted((char*)&team.sAnzahl, 4);
				k->getNachrichtEncrypted(&län, 1);
				txt = new char[län + 1];
				txt[län] = 0;
				if (län)
					k->getNachrichtEncrypted(txt, län);
				team.status = txt;
				delete[] txt;
				k->getNachrichtEncrypted((char*)&team.farbe, 4);
				char sAnz = 0;
				k->getNachrichtEncrypted(&sAnz, 1);
				for (char ki = 0; ki < sAnz; ki++)
				{
					SpielHistorieSpielerDaten spieler;
					char län = 0;
					k->getNachrichtEncrypted(&län, 1);
					char* txt = new char[län + 1];
					txt[län] = 0;
					if (län)
						k->getNachrichtEncrypted(txt, län);
					spieler.name = txt;
					delete[] txt;
					k->getNachrichtEncrypted((char*)&spieler.punkte, 4);
					k->getNachrichtEncrypted(&län, 1);
					txt = new char[län + 1];
					txt[län] = 0;
					if (län)
						k->getNachrichtEncrypted(txt, län);
					spieler.status = txt;
					delete[] txt;
					k->getNachrichtEncrypted((char*)&spieler.farbe, 4);
					team.spieler.add(spieler);
				}
				spiel.teams.add(team);
			}
			daten->add(spiel);
		}
		cs.unlock();
		return daten;
	}
	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;
}

// Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
//  spielId: Die id des Spiels
//  Gibt bei misserfolg 0 zurück
HistorieServerClient* InformationClient::createHistorieServerClient(int spielId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x29", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&spielId, 4);
		k->getNachrichtEncrypted((char*)&ret, 1);
		if (ret == 1)
		{
			k->getNachrichtEncrypted((char*)&port, 4);
			char län = 0;
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			ip[län] = 0;
			k->getNachrichtEncrypted(ip, län);
			HistorieClient* ret = new HistorieClient(cId, port, ip, key, keyLen, spielId);
			delete[] ip;
			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;
}

// sucht nach dem Historie Server von einem Spiel
// Prüft, ob der Account bestimmte Berechtigungen besitzt
//  recht: Die Id der Berechtigungen
bool InformationClient::hatRecht(int recht)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x2D", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&recht, 4);
		k->getNachrichtEncrypted((char*)&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 ret == 1;
}

// Prüft ob Berechtigung vorhanden
// Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist
//  filter: Die Zeichenkette, die im Namen Auftreten soll
//  sortSpalte: Der Index der Spalte, nach der sortiert werden soll
//  absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung
//  kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält
//  kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält
//  sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält
//  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
//  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
//  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
int InformationClient::getKartenListe(const char* filter, char sortSpalte, char absteigend, Framework::Array< int >* kId, Framework::RCArray< Framework::Text >* kName, Framework::RCArray< Framework::Text >* sName,
	Framework::Array< int >* kupfer, Framework::Array< int >* verkauft, Framework::Array< int >* maxSpieler)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x2E", 1);
	char res = 0;
	k->getNachrichtEncrypted(&res, 1);
	int ret = 0;
	if (res == 1)
	{
		char län = textLength(filter);
		k->sendeEncrypted(&län, 1);
		k->sendeEncrypted(filter, län);
		k->sendeEncrypted(&sortSpalte, 1);
		k->sendeEncrypted(&absteigend, 1);
		k->getNachrichtEncrypted((char*)&ret, 4);
		for (int i = 0; i < ret; i++)
		{
			int val = 0;
			k->getNachrichtEncrypted((char*)&val, 4);
			kId->set(val, i);
			k->getNachrichtEncrypted(&län, 1);
			char* txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			kName->set(new Text(txt), i);
			delete[] txt;
			k->getNachrichtEncrypted(&län, 1);
			txt = new char[län + 1];
			txt[län] = 0;
			if (län)
				k->getNachrichtEncrypted(txt, län);
			sName->set(new Text(txt), i);
			delete[] txt;
			k->getNachrichtEncrypted((char*)&val, 4);
			kupfer->set(val, i);
			k->getNachrichtEncrypted((char*)&val, 4);
			verkauft->set(val, i);
			k->getNachrichtEncrypted((char*)&val, 4);
			maxSpieler->set(val, i);
		}
	}
	if (res == 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 ret;
}

// Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
//  karteId: Die Id der Karte
//  Gibt bei misserfolg 0 zurück
EditorServerClient* InformationClient::createEditorServerClient(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x2F", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&karteId, 4);
		k->getNachrichtEncrypted((char*)&ret, 1);
		if (ret == 1)
		{
			int port = 0;
			k->getNachrichtEncrypted((char*)&port, 4);
			char län = 0;
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			ip[län] = 0;
			k->getNachrichtEncrypted(ip, län);
			EditorClient* ret = new EditorClient(cId, (unsigned short)port, ip, this->key, this->keyLen);
			delete[] ip;
			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;
}

// Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
//  karteId: Die Id der Karte
//  Gibt bei misserfolg 0 zurück
KartenServerClient* InformationClient::createKartenServerClient(int karteId)
{
	cs.lock();
	if (!k)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	k->sendeEncrypted("\x30", 1);
	char ret = 0;
	k->getNachrichtEncrypted(&ret, 1);
	if (ret == 1)
	{
		k->sendeEncrypted((char*)&karteId, 4);
		k->getNachrichtEncrypted((char*)&ret, 1);
		if (ret == 1)
		{
			int port = 0;
			k->getNachrichtEncrypted((char*)&port, 4);
			char län = 0;
			k->getNachrichtEncrypted(&län, 1);
			char* ip = new char[län + 1];
			ip[län] = 0;
			k->getNachrichtEncrypted(ip, län);
			KartenClient* ret = new KartenClient(cId, (unsigned short)port, ip, this->key, this->keyLen);
			delete[] ip;
			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;
}

// 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 InformationClient::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("\x2C", 1);
	ok &= k->getNachrichtEncrypted(&res, 1);
	cs.unlock();
	if (res != 1 || !ok)
		trenne(0);
	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 InformationClient::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 Information 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 Information Server returned: ";
		err += msg;
		delete[] msg;
	}
	k->trenne();
	k = (Network::Klient*)k->release();
	cs.unlock();
	return 1;
}

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

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