KSGNetwork/KSGNetwork/ChatClient.cpp

#include "ChatClient.h"
#include "Keys.h"
#include <Klient.h>
#include <Globals.h>
#include "SpielClient.h"

using namespace KSGClient;

// Inhalt der ChatClient Klasse

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

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

// verbindet sich mit dem zugewiesenen Chat Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::verbinde()
{
	cs.lock();
	if (senden)
	{
		cs.unlock();
		return 1;
	}
	senden = new Network::Klient();
	int keyLen = 0;
	char* key = 0;
	Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::SENDEN);
	senden->setSendeKey(key, keyLen);
	delete[] key;
	Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::EMPFANGEN);
	senden->setEmpfangKey(key, keyLen);
	delete[] key;
	if (senden->verbinde(port, ip))
	{
		if (senden->sendeEncrypted("\1", 1))
		{
			senden->sendeEncrypted((char*)&cId, 4);
			char ret = 0;
			senden->getNachrichtEncrypted(&ret, 1);
			if (ret != 1)
			{
				char byte = 0;
				senden->getNachrichtEncrypted(&byte, 1);
				char* f = new char[byte + 1];
				f[byte] = 0;
				senden->getNachrichtEncrypted(f, byte);
				err = f;
				delete[]f;
				senden->sendeEncrypted("\3", 1);
				char serverReturn = 0;
				senden->getNachrichtEncrypted(&serverReturn, 1);
				senden->trenne();
				senden = (Network::Klient*)senden->release();
				cs.unlock();
				return 0;
			}
			senden->setSendeKey(this->key, this->keyLen);
			senden->setEmpfangKey(this->key, this->keyLen);
			empfangen = new Network::Klient();
			int keyLen = 0;
			char* key = 0;
			Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::SENDEN);
			empfangen->setSendeKey(key, keyLen);
			delete[] key;
			Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::EMPFANGEN);
			empfangen->setEmpfangKey(key, keyLen);
			delete[] key;
			if (empfangen->verbinde(senden->getServerPort(), senden->getServerIp()))
			{
				empfangen->sendeEncrypted("\1", 1);
				empfangen->sendeEncrypted((char*)&cId, 4);
				char res = 0;
				empfangen->getNachrichtEncrypted(&res, 1);
				if (res == 1)
				{
					empfangen->setSendeKey(this->key, this->keyLen);
					empfangen->setEmpfangKey(this->key, this->keyLen);
					cs.unlock();
					return 1;
				}
				if (res == 3)
				{
					char län = 0;
					senden->getNachrichtEncrypted(&län, 1);
					char* nachricht = new char[län + 1];
					nachricht[län] = 0;
					senden->getNachrichtEncrypted(nachricht, län);
					err = nachricht;
					delete[]nachricht;
				}
				trenne(0);
			}
			else
			{
				err = "Der dir zugewiesene Chat Server kann dir keine Nachrichten senden.";
				empfangen = (Network::Klient*)empfangen->release();
				senden->sendeEncrypted("\3", 1);
				char serverReturn = 0;
				senden->getNachrichtEncrypted(&serverReturn, 1);
				senden->trenne();
				senden = (Network::Klient*)senden->release();
				cs.unlock();
				return 0;
			}
		}
		else
		{
			err = "Der dir zugewiesene Chat Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
			senden = (Network::Klient*)senden->release();
			cs.unlock();
			return 0;
		}
	}
	else
	{
		err = "Der dir zugewiesene Chat Server antwortet nicht. Bitte versuche es Später erneut.";
		senden = (Network::Klient*)senden->release();
		cs.unlock();
		return 0;
	}
	err = "Unbekannter Fehler";
	cs.unlock();
	return 0;
}

// sendet eine Chat Nachricht zu einem Account
//  zuAccount: Id des Ziel Accounts
//  nachricht: Die Nachricht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatNachricht(int zuAccount, const char* nachricht)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(nachricht);
	if (!län)
	{
		cs.unlock();
		return 1;
	}
	senden->sendeEncrypted("\6", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&zuAccount, 4);
		senden->sendeEncrypted(&län, 1);
		senden->sendeEncrypted(nachricht, län);
	}
	else
	{
		err = "Fehler beim senden der Nachricht.";
		cs.unlock();
		return 0;
	}
	cs.unlock();
	return 1;
}

// ändert den angezeigten Account Namen
//  name: der neue Name
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::accountNameÄndern(const char* name)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(name);
	if (!län)
	{
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\x8", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted(&län, 1);
		senden->sendeEncrypted(name, län);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim ändern des Namens.";
	cs.unlock();
	return 0;
}

// beendet die Freundschaft mit einem Account
//  accountId: Die Id des Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundschaftBeenden(int accountId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\x9", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&accountId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim beenden der Freundschaft.";
	cs.unlock();
	return 0;
}

// sendet eine Freundesanfragezu einem Account
//  accountId: Die Id des Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundesAnfrage(int accountId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\xA", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&accountId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim senden der Freundschaftsanfrage.";
	cs.unlock();
	return 0;
}

// beantwortet eine Freundesanfrage
//  accountId: Die Id des Accounts
//  ja: 1:=annehmen,0:=ablehnen
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundesAnfrageBeantworten(int accountId, bool ja)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\xB", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&accountId, 4);
		char ok = (char)ja;
		senden->sendeEncrypted(&ok, 1);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim beantworten der Freundschaftsanfrage.";
	cs.unlock();
	return 0;
}

// erstellt ein chatroom
//  name: Der Name des Chatrooms
//  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
int ChatClient::chatroomErstellen(const char* name)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(name);
	if (!län)
	{
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\xC", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted(&län, 1);
		senden->sendeEncrypted(name, län);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			int ret = 0;
			senden->getNachrichtEncrypted((char*)&ret, 4);
			cs.unlock();
			return ret;
		}
	}
	err = "Fehler beim erstellen des Chatrooms.";
	cs.unlock();
	return 0;
}

// Sendet eine Einladung zum Chatroom
//  accountId: Die Id des Accounts der eingeladen werden soll
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomEinladung(int accountId, int chatroomId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\xD", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&accountId, 4);
		senden->sendeEncrypted((char*)&chatroomId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim senden der Chatroomeinladung.";
	cs.unlock();
	return 0;
}

// Einladung zum Chatroom wird abgelehnt
//  accountId: Die Id des Accounts
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomEinladungAblehnen(int accountId, int chatroomId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\xE", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&accountId, 4);
		senden->sendeEncrypted((char*)&chatroomId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim beantworten der Chatroomeinladung.";
	cs.unlock();
	return 0;
}

// betritt ein chatroom
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomBetreten(int chatroomId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\xF", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&chatroomId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim betreten des Chatrooms.";
	cs.unlock();
	return 0;
}

// chatroom Nachricht senden
//  chatroomId: Die Id des Chatrooms
//  nachricht: Die Nachricht die gesendet werden soll
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomNachricht(int chatroomId, const char* nachricht)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char län = textLength(nachricht);
	if (!län)
	{
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\x10", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&chatroomId, 4);
		senden->sendeEncrypted(&län, 1);
		senden->sendeEncrypted(nachricht, län);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim senden der Nachricht.";
	cs.unlock();
	return 0;
}

// verlässt chatroom
//  chatroomId: Die Id des Chatrooms
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomVerlassen(int chatroomId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\x11", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&chatroomId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim verlassen des Chatrooms.";
	cs.unlock();
	return 0;
}

// kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
//  chatroomId: Die Id des Chatrooms
//  accountId: Die Id des Accounts
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatroomKick(int chatroomId, int accountId)
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	senden->sendeEncrypted("\x12", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn)
	{
		senden->sendeEncrypted((char*)&chatroomId, 4);
		senden->sendeEncrypted((char*)&accountId, 4);
		senden->getNachrichtEncrypted(&serverReturn, 1);
		if (serverReturn == 1)
		{
			cs.unlock();
			return 1;
		}
	}
	err = "Fehler beim kicken eines Spielers aus dem Chatroom.";
	cs.unlock();
	return 0;
}

// fragt nach allen freunden
//  Die Liste der Freunde kann über getNextMessage empfangen werden
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::freundesListeAnfragen()
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char serverReturn = 0;
	senden->sendeEncrypted("\x13", 1);
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		cs.unlock();
		return 1;
	}
	err = "Fehler beim Anfragen der Freundesliste.";
	cs.unlock();
	return 0;
}

// fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
//  Die einzelnen Nachrichten können über getNextMessage empfangen werden
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool ChatClient::chatNachrichtAnfrage()
{
	cs.lock();
	if (!senden)
	{
		err = "Der Client ist nicht verbunden.";
		cs.unlock();
		return 0;
	}
	char serverReturn = 0;
	senden->sendeEncrypted("\x14", 1);
	senden->getNachrichtEncrypted(&serverReturn, 1);
	if (serverReturn == 1)
	{
		cs.unlock();
		return 1;
	}
	err = "Fehler beim Anfragen der Chatnachrichten.";
	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 ChatClient::keepAlive()
{
	if (!senden)
		return 0;
	char res = 0;
	if (!cs.tryLock())
		return 1;
	Framework::logLine((char*)"Verbindungstest zum Chat Server...");
	bool ok = senden->sendeEncrypted("\x15", 1);
	ok &= senden->getNachrichtEncrypted(&res, 1);
	cs.unlock();
	if (res != 1 || !ok)
	{
		Framework::logLine((char*)"Verbindungsabbruch.");
		trenne(0);
	}
	else
		Framework::logLine((char*)"Verbindung besteht.");
	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 ChatClient::trenne(bool abmelden)
{
	if (!senden)
		return 1;
	cs.lock();
	senden->sendeEncrypted("\3", 1);
	char serverReturn = 0;
	senden->getNachrichtEncrypted(&serverReturn, 1);
	senden->trenne();
	senden = (Network::Klient*)senden->release();
	if (empfangen)
	{
		empfangen->trenne();
		empfangen = (Network::Klient*)empfangen->release();
	}
	cs.unlock();
	return 1;
}

// Wartet auf eine Nachricht vom Chatserver.
//  Gibt bei Erfolg 1 zurück, 0 sonnst
//  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
bool ChatClient::getNextMessage(ChatServerNachricht& nachricht)
{
	if (!empfangen)
	{
		err = "Der Client ist nicht verbunden.";
		return 0;
	}
	do
	{
		if (!empfangen->getNachrichtEncrypted(&nachricht.type, 1))
		{
			err = "Fehler beim Empfangen der Nachricht.";
			return 0;
		}
		switch (nachricht.type)
		{
		case 3: // Fehler
			if (1)
			{
				char länge = 0;
				empfangen->getNachrichtEncrypted(&länge, 1);
				char* txt = new char[länge + 1];
				txt[länge] = 0;
				empfangen->getNachrichtEncrypted(txt, länge);
				nachricht.message = txt;
				delete[] txt;
			}
			break;
		case 4: // Chat Nachricht
			if (1)
			{
				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
				char länge = 0;
				empfangen->getNachrichtEncrypted(&länge, 1);
				char* txt = new char[länge + 1];
				txt[länge] = 0;
				empfangen->getNachrichtEncrypted(txt, länge);
				nachricht.message = txt;
				delete[] txt;
			}
			break;
		case 5: // Spiel Einladung
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			break;
		case 6: // Account Status ändert sich
			if (1)
			{
				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
				char län = 0;
				empfangen->getNachrichtEncrypted(&län, 1);
				char* status = new char[län + 1];
				status[län] = 0;
				empfangen->getNachrichtEncrypted(status, län);
				nachricht.message = status;
				delete[] status;
			}
			break;
		case 7: // Account Name ändert sich
			if (1)
			{
				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
				char län = 0;
				empfangen->getNachrichtEncrypted(&län, 1);
				char* name = new char[län + 1];
				name[län] = 0;
				empfangen->getNachrichtEncrypted(name, län);
				nachricht.message = name;
				delete[] name;
			}
			break;
		case 8: // kein Freund mehr
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 9: // Freundesanfrage
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0xA: // Neuer Freund
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0xB: // Freundesanfrage abgelehnt
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0xC: // Einladung zum Chatroom
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
			break;
		case 0xD: // Einladung zum Chatroom abgelehnt
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
			break;
		case 0xE: // Spieler betritt Chatroom
			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0xF: // Chatroom Nachricht
			if (1)
			{
				empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
				char län = 0;
				empfangen->getNachrichtEncrypted(&län, 1);
				char* txt = new char[län + 1];
				txt[län] = 0;
				if (län)
				{
					empfangen->getNachrichtEncrypted(txt, län);
					nachricht.message = txt;
				}
				delete[] txt;
			}
			break;
		case 0x10: // Spieler verlässt Chatroom
			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x11: // Freunde
			if (1)
			{
				char freundeAnzahl;
				empfangen->getNachrichtEncrypted(&freundeAnzahl, 1);
				for (int i = 0; i < freundeAnzahl; i++)
				{
					int accountId = 0;
					empfangen->getNachrichtEncrypted((char*)&accountId, 4);
					nachricht.ids.add(accountId);
				}
			}
			break;
		case 0x12: // Spieler im Chatroom
			if (1)
			{
				empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
				char anzahl = 0;
				empfangen->getNachrichtEncrypted(&anzahl, 1);
				for (char i = 0; i < anzahl; i++)
				{
					int accountId = 0;
					empfangen->getNachrichtEncrypted((char*)&accountId, 4);
					nachricht.ids.add(accountId);
				}
			}
			break;
		case 0x13: // Freund online
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x14: // Freund offline
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x15: // Chatroom Admin
			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
			break;
		case 0x16: // Chatroom Kick
			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
			break;
		case 0x17: // Spieler betritt Gruppe
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			break;
		case 0x18: // Spieler verlässt Gruppe
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			break;
		case 0x19: // gruppe Nachricht
			if (1)
			{
				char län = 0;
				empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
				empfangen->getNachrichtEncrypted(&län, 1);
				if (län)
				{
					char* txt = new char[län + 1];
					txt[län] = 0;
					empfangen->getNachrichtEncrypted(txt, län);
					nachricht.message = txt;
					delete[] txt;
				}
			}
			break;
		case 0x1A: // gruppe Angemeldet
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			break;
		case 0x1B: // gruppe Abgemeldet
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			break;
		case 0x1C: // gruppe Spiel starten
			if (1)
			{
				char starten = 0;
				empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
				empfangen->getNachrichtEncrypted(&starten, 1);
				nachricht.account = starten;
			}
			break;
		case 0x1D: // kick aus Gruppe
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			break;
		case 0x1E: // gruppe Admin
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x1F: // gruppe Einladung abgelehnt
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x20: // SpielServer Verbindungs Anfrage
			if (1)
			{
				unsigned short port;
				unsigned char* ip = new unsigned char[4];
				empfangen->getNachrichtEncrypted((char*)&port, 2);
				empfangen->getNachrichtEncrypted((char*)ip, 4);
				Text* ipT = new Text("");
				ipT->append((int)ip[0]);
				ipT->append(".");
				ipT->append((int)ip[1]);
				ipT->append(".");
				ipT->append((int)ip[2]);
				ipT->append(".");
				ipT->append((int)ip[3]);
				delete[] ip;
				nachricht.client = new SpielClient(cId, port, ipT->getText(), this->key, this->keyLen);
				ipT->release();
			}
			break;
		case 0x21: // Gruppe Einladung abgebrochen
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x22: // Gruppe Einladung hinzufügen
			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
			break;
		case 0x23: // ping
			empfangen->sendeEncrypted("\1", 1);
			break;
		}
	} while (nachricht.type == 0x23);
	return 1;
}

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

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