KSGNetwork/Include/KSGNetwork.h

#pragma once

#include <Array.h>
#include <Thread.h>
#include "../../Include/StrukturenV.h"

namespace Framework
{
	class Text;
	class Datei;
	class KSGTDatei;
	class FBalken;
	class Zeit;
	class Bild;
	class Model2DData;
}

namespace GSL
{
	class GSLSoundV;
	class GSLDateiV;
}

namespace Network
{
	class Klient;
}

#define KSGNETWORK_CREATE_MAIN "createMainServerClient"
#define KSGNETWORK_CREATE_REGISTERD_MAIN "createRegisterdMainServerClient"

namespace KSGClient
{
	class MainServerClient;

	// Entry Point Functions
	typedef MainServerClient* (*KSGNetworkCreateMain)();
	typedef MainServerClient* (*KSGNetworkCreateRegisterdMain)(const char* ip, unsigned short port, int clientId, const char* key, unsigned char keyLen);

	// Enthält die Daten eines Spielers zu einem vergangenen Spiel
	struct SpielHistorieSpielerDaten
	{
		Framework::Text name; // Der Sichtabe Name des Spielers
		int punkte; // Die Punkte, die der Spieler in dem Spiel gewonnen / verloren hat
		Framework::Text status; // Der Status des Spielers in dem Spiel (verloren, gewonnen, nicht anwesend, beobachter, unentschieden)
		int farbe; // Die Farbe des Spielers
	};

	// Enthält die Datein eines Teams zu einem vergangenen Spiel
	struct SpielHistorieTeamDaten
	{
		Framework::Text name; // Der Sichtabe Name des Teams
		int sAnzahl; // Die Anzahl der Spieler im Team
		Framework::Text status; // Der Status des Teams (verloren, gewonnen, beobachter, unentschieden)
		int farbe; // Die Farbe des Teams
		Framework::Array< SpielHistorieSpielerDaten > spieler; // Eine Liste mit den Spielerdaten zu den Spielern aus dem Team
	};

	// Enthält Daten zu einem vergangenen Spiel
	struct SpielHistorieDaten
	{
		int id; // Die Id des vergangenen Spiels
		int karteId; // Die Id der Karte, welche gespielt wurde
		Framework::Text spiel; // Der Name des Spiels, welches gespielt wurde
		Framework::Text karte; // Der Name der Karte, welche gespielt wurde
		Framework::Text datum; // Der Zeitpunkt, an dem das Spiel Statfand
		Framework::Text status; // Der Status des Spielers, über welchen die Statistik angefragt wurde
		Framework::Text dauer; // Die Dater des Spiels
		Framework::Text spielStatus; // Der Status des Spiels (beginnt, läuft, abgebrochen, fehlerhaft, beendet, unbewertet)
		Framework::Text gewinner; // Der Name des Gewinners
		int sAnzahl; // Die Anzahl der Spieler
		Framework::Array< SpielHistorieTeamDaten > teams; // Die Daten der Teams des Spiels
	};

	// Enthält Informationen zu einem Account
	struct AccountInfo
	{
		int id; // Die Id des Accounts
		Framework::Text name; // Der angezeigte Name des Accounts
		Framework::Text zuletztOnline; // Der Zeitpunkt, zu dem der Account zuletzt online war
		Framework::Text letztesSpiel; // Der Name des zuletzt gespielten online Spiels
		Framework::Text letzteKarte; // Der Name der zuletzt gespielten Karte
		Framework::Text punkte; // Die Punkte des Spielers in dem Spiel
	};

	// Enthält Informationen zur Aktivität eines Accounts an einem bestimmten Tag
	struct AccountActivityInfo
	{
		Framework::Text datum; // Das Datum für das die Werte gillt
		double stOnline; // Die Anzahl der Stunden, die der Account Online war
		double stGespielt; // Die Anzahl der Stunden, die der Account in online Spielen verbracht hat
		int anzSpiele; // Die Anzahl der gespielten online Spiele
		int anzGewonnen; // Die Anzahl der gewonnenen online Spiele
	};

	class SpielServerClient;

	// Enthält eine Nachricht, die von Chat Server gesendet wurde
	struct ChatServerNachricht
	{
		char type; // Typ der Nachricht
		Framework::Text message; // Text der Nachricht
		int account; // Beteiligter Account
		int gruppe; // Beteiligte Gruppe
		int chatroom; // Beteiligter Chatraum
		Framework::Array< int > ids; // Liste mit Account Ids
		SpielServerClient* client; // ein Client zum zugewiesenen Spiel Server
	};

	// Enthält eine Nachricht von dem Spiel Server
	struct SpielServerNachricht
	{
		char type; // Typ der Nachricht
		char sekunden; // Mit der Nachricht zusammenhängende Sekunden
		char minuten; // Mit der Nachricht zusammenhängende Minuten
		char stunden; // Mit der Nachricht zusammenhängende Stunden
		Framework::Text message; // Text der Nachricht
		SpielerTeamStrukturV* sts; // Die Spieler Team Struktur eines Spiels
		int accountId; // Id des Accounts
		int spielerNummer; // Die Spielernummer des Accounts
		int karteId; // Die Id der Karte
		int prozent; // Der Prozentuale Ladefortschritt
		int ping; // Der Ping des Accounts (1000 = 1 Sekunde)
		short län; // Länge der gesendeten Daten
		char* data; // Die gesendeten Daten
	};

	// Wird benutzt, um die Verbindung mit den Servern aufrecht zu erhalten. Bei einem Verbindungsabbruch wird der Client automatisch abgemeldet
	class ErhaltungServerClient : protected virtual Framework::Thread, public virtual Framework::ReferenceCounter
	{
	protected:
		// DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
		virtual void thread() = 0;
	public:
		// verbindet ich mit dem Erhaltung Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Meldet sich beim Server ab und trennt die Verbindung
		virtual void abmelden() = 0;
		// 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
		virtual bool trenne() = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird benutzt, um aktualisierte Spieldateien herunterzuladen
	class PatchServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet ich mit dem Patch Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Gibt eine Tabelle von Dateigruppen zurück.
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::KSGTDatei* getDateiGruppenListe() = 0;
		// Gibt eine Tabelle von Dateien zurück.
		//  gruppe: Die Id der Dateigruppe, zu der die Dateien gehöhren sollen
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::KSGTDatei* getDateiListe(int gruppe) = 0;
		// Gibt die Größe einer Datei in bytes zurück
		//  gruppe: Die Id der Dateigruppe der Datei
		//  pfad: Der Pfad der Datei
		virtual __int64 getDateiGröße(int gruppe, const char* pfad) = 0;
		// Lädt eine Datei herunter
		//  gruppe: Die Dateigruppe der Datei
		//  start: Der Index des bytes, bei dem der download begonnen werden soll (Enthält im Falle eines Abbruchs die Position, von welcher aus als nächstes heruntergeladen werden muss)
		//  pfad: Der Pfad der Datei
		//  zielPfad: Der Pfad, an den die Datei gespeichert werden soll
		//  zFb: Ein Fortschrittsbalken, der automatisch aktualisiert wird
		//  abbruch: Wenn diese Variable während des Vorgangs auf 1 gesetzt wird, so wird das Herunterladen abgebrochen.
		//  maxbps: Die Anzahl der bytes pro Sekunde, die maximal übertragen werden sollen
		virtual bool downloadDatei(int gruppe, __int64* start, const char* pfad, const char* zielPfad, Framework::FBalken* zFb, bool* abbruch, int maxbps) = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
		virtual int getDownload() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten)
	class NewsServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet ich mit dem News Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Lädt eine KSG-Script Seite herunter uns speichert sie unter data/tmp/news/{name}
		//  name: Der Name der Seite
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladeSeite(const char* name) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
	class RegisterServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet ich mit dem Register Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		//  eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll
		//  jahr: Das Jahr des Geburtsdatums
		//  monat: Der Monat des Geburtstages
		//  tag: Der Tag des Geburtstages
		virtual bool accountErstellen(const char* name, const char* pass, const char* geheim, const char* eMail, unsigned short jahr, char monat, char tag) = 0;
		// Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		virtual bool accountLöschen(const char* name, const char* pass, const char* geheim) = 0;
		// Ändert das Passwort eines Accounts
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		//  nPass: Das neue Passwort des Accounts
		virtual bool passwortÄndern(const char* name, const char* pass, const char* geheim, const char* nPass) = 0;
		// Ändert die EMail Adresse eines Accounts
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		//  nEMail: Die neue EMail Adresse
		virtual bool eMailÄndern(const char* name, const char* pass, const char* geheim, const char* nEMail) = 0;
		// Ändert das Geheimnis eines Accounts
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		//  nGeheim: Das neue Geheimnis
		virtual bool geheimnisÄndern(const char* name, const char* pass, const char* geheim, const char* nGeheim) = 0;
		// Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		virtual bool nameVergessen(const char* pass, const char* geheim) = 0;
		// Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  geheim: Das Geheimnis des Accounts
		virtual bool passwortVergessen(const char* name, const char* geheim) = 0;
		// Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		virtual bool geheimnisVergessen(const char* name, const char* pass) = 0;
		// Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  name: Der Login Name des Accounts
		//  pass: Das Login Passwort des Accounts
		//  geheim: Das Geheimnis des Accounts
		//  eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden
		virtual bool eMailVergessen(const char* name, const char* pass, const char* geheim, char** eMail) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um sich einzuloggen oder auszuloggen
	class LoginServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Login Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Der Client wird beim Serversystem in einen Account eingeloggt
		//  Gibt bei Erfolg 1 zurück, 2 falls en anderer Client in dem Account eingeloggt ist, 0 sonnst
		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
		virtual int login(const char* name, const char* pass) = 0;
		// Diese Funktion wird in der Zukunft mal implementiert werden. Mit dem Geheimnis des Accounts können so andere Clients, welche bereits in dem Account eingeloggt werden rausgeschmissen werden.
		virtual bool kick(const char* name, const char* pass, const char* geheim) = 0;
		// logt den Account aus
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
		virtual bool logout() = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// Gibt die Id des Accounts zurück, in den sich der Client eingeloggt hat.
		//  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
		virtual int getAccountId() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	class EditorServerClient;
	class KartenServerClient;
	class HistorieServerClient;

	// Wird verwendet um informationen über Accounts abzufragen
	//  Kann nur von eingeloggten Clients verwendet werden
	class InformationServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet ich mit dem zugewiesenen Informaion Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// 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
		virtual bool getInformationText(Framework::Text* txt, int* typ) = 0;
		// 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
		virtual bool istSpielErlaubt(int spielId) = 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
		virtual bool istKarteErlaubt(int karteId) = 0;
		// Ermittelt die Id einer Karte
		//  name: Der Name der Karte
		//  Gibt bei misserfolg 0 zurück
		virtual int getKarteId(const char* name) = 0;
		// Fragt nach der Id eines Spiels
		//  name: Der Name des Spiels
		//  Gibt bei misserfolg 0 zurück
		virtual int getSpielId(const char* name) = 0;
		// fragt nach dem Namen eines Accounts
		//  accountId: Die Id des Accounts
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Text* getSpielerName(int accountId) = 0;
		// 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)
		virtual bool getSpielStatistik(int accountId, int spielId, Framework::Array< int >* werte) = 0;
		// fragt nach dem Namen einer Karte
		//  karteId: Die id der Karte
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Text* getKarteName(int karteId) = 0;
		// fragt nach dem Namen eines Spiels
		//  spielId: Die id des Spiels
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Text* getSpielName(int spielId) = 0;
		// fragt nach dem Namen eines Chatrooms
		//  chatroomId: Die id des Chatrooms
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Text* getChatroomName(int chatroomId) = 0;
		// fragt zu welcher Spielart die Karte gehört
		//  karteId: Die id der Karte
		//  Gibt bei misserfolg 0 zurück
		virtual int getSpielId(int karteId) = 0;
		// gibt die Id eines Accounts zurück
		//  name: Der Angezeigte Name des Accounts
		//  Gibt bei misserfolg 0 zurück
		virtual int getAccountId(const char* name) = 0;
		// gibt die Id des Chatrooms zurück
		//  name: Der name des Chatrooms
		//  Gibt bei misserfolg 0 zurück
		virtual int getChatroomId(const char* name) = 0;
		// gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
		//  gruppenId: Die id der Gruppe
		//  Gibt bei misserfolg 0 zurück
		virtual int getGruppenKarteId(int gruppenId) = 0;
		// gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
		//  gruppeId: Die id der Gruppe
		virtual bool getGruppeSpielerHinzufügen(int gruppeId) = 0;
		// gibt die Account Id des Gruppen Administrators zurück
		//  gruppeId: Die Id der Gruppe
		//  Gibt bei misserfolg 0 zurück
		virtual int getGruppeAdminId(int gruppeId) = 0;
		// gibt die Punkte eines Spielers zurück
		//  accountId: Die Accont Id des Spielers
		//  spielId: Die Id des Spiels
		//  Gibt bei misserfolg 0 zurück
		virtual int getSpielerPunkte(int accountId, int spielId) = 0;
		// gibt eine Liste mit Ids von gekauften Spielen zurück
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Array< int >* getAccountSpielArtListe() = 0;
		// gibt die neuste Version eines Spiels zurück
		//  spielId: Die Id des Spiels
		//  Gibt bei misserfolg 0 zurück
		virtual int getSpielVersion(int spielId) = 0;
		// gibt das Kupfer des Accounts zurück
		//  Gibt bei misserfolg 0 zurück
		virtual int getKupfer() = 0;
		// Gibt die Dateigruppem Id eines Spieles zurück
		//  spielId: Die Id des Spiels
		//  Gibt bei misserfolg 0 zurück
		virtual int getDateiGruppeIdVonSpiel(int spielId) = 0;
		// Gibt den Dateigruppen Pfad zurück
		//  dgId: Die Id der Dateigruppe
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Text* getDateiGruppePfad(int dgId) = 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
		virtual Framework::Array< int >* getAccountKarteListe(int spielId) = 0;
		// Gibt die Dateigruppen Id eines Pfades zurück
		//  pfad: Der Pfad der Dateigruppe
		//  Gibt bei misserfolg 0 zurück
		virtual int getDateiGruppeIdVonPfad(const char* pfad) = 0;
		// gibt die neuste Version einer Dateigruppe zurück
		//  dg: Die Dateigruppen Id
		//  Gibt bei misserfolg 0 zurück
		virtual int getDateiGruppeVersion(int dg) = 0;
		// 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
		virtual int getSpielerListe(const char* suche, int* seite, int* maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo >* accounts) = 0;
		// ermittelt die aktivität eines Spielers
		//  accId: Die Id des Accounts
		//  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
		virtual bool getSpielerAktivität(int accId, Framework::Array< AccountActivityInfo >* info) = 0;
		// Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
		//  account: Die Id des Accounts
		//  karte: Die Id der Karte
		virtual int getAccountKarteSpiele(int account, int karte) = 0;
		// Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
		//  account: Die Id des Accounts
		//  karte: Die Id der Karte
		virtual int getAccountKarteSpieleGewonnen(int account, int karte) = 0;
		// Gibt zurück, ob ein Spieler die Karte im Besitz hat
		//  account: Die Id des Accounts
		//  karte: Die Id der Karte
		virtual bool hatAccountKarte(int account, int karte) = 0;
		// Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
		//  account: Die Id des Accounts
		//  spiel: Die Id des Spiels
		virtual bool hatAccountSpiel(int account, int spiel) = 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
		virtual Framework::Array< int >* getAccountKarteGespieltListe(int account, int spielId) = 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
		virtual Framework::Array< int >* getAccountSpielGespieltListe(int account) = 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
		virtual bool getSpielPartnerListe(int account, Framework::Array< int >* spieler, Framework::Array< int >* karten, Framework::Array< int >* anzahl) = 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
		virtual bool getStatistikListe(int account, int* seite, int* maxSeite, char sortSpalte, char rückwärts,
			Framework::RCArray< Framework::Array< int > >* werte, Framework::RCArray< Framework::Text >* namen) = 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
		virtual Array< SpielHistorieDaten >* getSpielHistorieDaten(int account) = 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
		virtual HistorieServerClient* createHistorieServerClient(int spielId) = 0; // sucht nach dem Historie Server von einem Spiel
		// Prüft, ob der Account bestimmte Berechtigungen besitzt
		//  recht: Die Id der Berechtigungen
		virtual bool hatRecht(int recht) = 0; // 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
		virtual int 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) = 0;
		// 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
		virtual EditorServerClient* createEditorServerClient(int karteId) = 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
		virtual KartenServerClient* createKartenServerClient(int karteId) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um Chat nachrichten zu senden oder zu empfangen. Das Serversystem sendet außerdem einiege Mitteilungen über den Chat (z.B. Gefundene Spiele, Gruppeneinladungen ...)
	//  Kann nur von eingeloggten Clients verwendet werden
	class ChatServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Chat Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 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
		virtual bool chatNachricht(int zuAccount, const char* nachricht) = 0;
		// ändert den angezeigten Account Namen
		//  name: der neue Name
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool accountNameÄndern(const char* name) = 0;
		// beendet die Freundschaft mit einem Account
		//  accountId: Die Id des Accounts
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool freundschaftBeenden(int accountId) = 0;
		// sendet eine Freundesanfragezu einem Account
		//  accountId: Die Id des Accounts
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool freundesAnfrage(int accountId) = 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
		virtual bool freundesAnfrageBeantworten(int accountId, bool ja) = 0;
		// erstellt ein chatroom
		//  name: Der Name des Chatrooms
		//  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
		virtual int chatroomErstellen(const char* name) = 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
		virtual bool chatroomEinladung(int accountId, int chatroomId) = 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
		virtual bool chatroomEinladungAblehnen(int accountId, int chatroomId) = 0;
		// betritt ein chatroom
		//  chatroomId: Die Id des Chatrooms
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool chatroomBetreten(int chatroomId) = 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
		virtual bool chatroomNachricht(int chatroomId, const char* nachricht) = 0;
		// verlässt chatroom
		//  chatroomId: Die Id des Chatrooms
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool chatroomVerlassen(int chatroomId) = 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
		virtual bool chatroomKick(int chatroomId, int accountId) = 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
		virtual bool freundesListeAnfragen() = 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
		virtual bool chatNachrichtAnfrage() = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// 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
		virtual bool getNextMessage(ChatServerNachricht& nachricht) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um Spiele oder Karten zu kaufen
	//  Kann nur von eingeloggten Clients verwendet werden
	class ShopServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Shop Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Gibt eine Liste mit Spiel Ids zurück, mit Spielen, die einen Bestimten Text im Namen haben
		//  suche: Der Text, der im Namen der Spiele vorkommen soll
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Array< int >* suchSpiele(const char* suche) = 0;
		// läd Titelbild des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/titelbg.ltdb
		//  id: Die Id des Spiels
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladeSpielTitel(int id) = 0;
		// läd Shop Seite des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/seite.ksgs
		//  id: Die Id des Spiels
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladeSpielSeite(int id) = 0;
		// Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
		//  id: Die Id des Spiels
		virtual int getSpielBesitzStatus(int id) = 0;
		// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
		//  id: Die Id des Spiels
		virtual int getSpielTestversion(int id) = 0;
		// Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
		//  id: Die Id des Spiels
		virtual int istSpielErwerbbar(int id) = 0;
		// Gibt den Preis eines Spiels in Kupfer zurück
		//  id: Die Id des Spiels
		//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
		virtual int getSpielPreis(int id, bool testVersion) = 0;
		// Kauft ein Spiel
		//  id: Die Id des Spiels
		//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
		virtual bool spielErwerben(int spielId, bool testVersion) = 0;
		// sucht nach Karten mit zu einem bestimmten Spiel
		//  suche: Ein Text, der im Namen der Karte vorkommen soll
		//  spielId: Die Id des Spiels
		//  Gibt eine Liste Mit den Ids der gefundenen Karten zurück
		virtual Framework::Array< int >* suchKarten(const char* suche, int spielId) = 0;
		// lädt das Titelbild der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/titelbg.ltdb
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladeKarteTitel(int id) = 0;
		// lädt die Shop Seite der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/seite.ksgs
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladeKarteSeite(int id) = 0;
		// Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
		//  id: Die Id der Karte
		virtual int getKarteBesitzStatus(int id) = 0;
		// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
		//  id: Die Id der Karte
		virtual int getKarteTestversion(int id) = 0;
		// Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
		//  id: Die Id der Karte
		virtual int istKarteErwerbbar(int id) = 0;
		// Gibt den Preis einer Karte in Kupfer zurück
		//  id: Die Id der Karte
		//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
		virtual int getKartePreis(int id, bool testVersion) = 0;
		// Kauft eine Karte
		//  id: Die Id der Karte
		//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
		virtual bool karteErwerben(int karteId, bool testVersion) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um sich für Spiele anzumelden
	//  Kann nur von eingeloggten Clients verwendet werden
	class AnmeldungServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Anmeldung Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// erstellt eine gruppe
		//  karteId: Die Id der Karte für die die Gruppe erstellt werden soll
		//  Gibt bei Erfolg die Id der Gruppe zurück. Bei misserfolg wird 0 zurückgegeben
		virtual int gruppeErstellen(int karteId) = 0;
		// Betritt eine Gruppe
		//  gruppeId: Die Id der Gruppe
		//  mitglieder: Nach erfolgreichem Aufruf enthält diese Liste die Lister der Account Ids der Gruppenmitglieder
		//  anzahl: Nach erfolgreichem Aufruf wird hier die Anzahl der Gruppenmitglieder gespeichert
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeBetreten(int gruppeId, Framework::Array< int >* mitglieder, int* anzahl) = 0;
		// Verlässt eine Gruppe
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeVerlassen(int gruppeId) = 0;
		// Trägt die Gruppe in die Warteschlange für die Karte ein (nur für den Gruppen Administrator)
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeAnmelden(int gruppeId) = 0;
		// Trägt die Gruppe aus der Warteschlange für die Karte aus (nur für den Gruppen Administrator)
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeAbmelden(int gruppeId) = 0;
		// läht Spieler ein die Gruppe zu betreten (nur für den Gruppen Administrator)
		//  accountId: Die Id des Accounts
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeSpielerEinladen(int accountId, int gruppeId) = 0;
		// Zieht die Einladung eine Gruppe zu betreten zurück (nur für den Gruppen Administrator)
		//  accountId: Die Id des Accounts
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeEinladungAbbrechen(int accountId, int gruppeId) = 0;
		// Einladung zur Gruppe ablehnen
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeEinladungAblehnen(int gruppeId) = 0;
		// wirft Spieler aus Gruppe (nur für den Gruppen Administrator)
		//  accountId: Die Id des Accounts
		//  gruppeId: Die Id der Gruppe
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool kickSpielerAusGruppe(int accountId, int gruppeId) = 0;
		// Legt fest, ob die Spieler in der Gruppe alleine spielen wollen, oder ob weitere Spieler aus der Warteschlange hinzugefügt werden sollen bis die Karte voll ist
		//  gruppeId: Die Id der Gruppe
		//  spielStarte: 1:=alleine spielen, 0:=auf volles Spiel warten
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeSpielStarten(int gruppeId, bool spielStarten) = 0;
		// Sendet eine Nachricht an den Gruppen Chat
		//  gruppeId: Die Id der Gruppe
		//  nachricht: Die Nachricht, die gesendet werden soll
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool gruppeNachricht(int gruppeId, const char* nachricht) = 0;
		// Meldet den eingeloggten Account in der Warteschlange für eine Karte an
		//  karteId: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool anmelden(int karteId) = 0;
		// Meldet den eingeloggten Account aus der Warteschlange ab
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool abmelden() = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
	//  Kann nur von eingeloggten Clients verwendet werden
	class KartenServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Karten Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// lädt eine Karte herunter und speichert sie unter data/tmp/Karten/{id}/spiel
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool downloadKarte(int id) = 0;
		// lädt das Titelbild Karte herunter und speichert es unter data/tmp/Karten/{id}/titel.ltdb
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool downloadKarteTitel(int id) = 0;
		// lädt die Beschreibung Karte herunter und speichert sie unter data/tmp/Karten/{id}/beschreibung.ksgs
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool downloadKarteBeschreibung(int id) = 0;
		// lädt die Minimap Karte herunter und speichert es unter data/tmp/Karten/{id}/minimap.ltdb
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool downloadKarteMinimap(int id) = 0;
		// lädt das Ladebild Karte herunter und speichert es unter data/tmp/Karten/{id}/ladebild.ltdb
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool downloadKarteLadebild(int id) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird zum Online Spielen verwendet
	//  Kann nur von eingeloggten Clients verwendet werden
	class SpielServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Karten Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Betritt das Vorgeschlagene Spiel
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool spielErstelltAnnehmen() = 0;
		// Lehnt das Vorgeschlagene Spiel ab
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool spielErstelltAblehnen() = 0;
		// Wechselt zu einem bestimmten Team
		//  team: Die Id des teams
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool spielErstelltTeamWechseln(int team) = 0;
		// Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool spielErstelltTeamFertig() = 0;
		// sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
		//  nachricht: Die Nachricht
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool spielErstelltChatNachricht(const char* nachricht) = 0;
		// Teilt dem Server mit, dass der Client bereit ist das Spiel zu laden
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool bereitZumLaden() = 0;
		// Teilt dem Server mit, zu wie viel Prozent der Client das Spiel geladen hat
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool setLadenProzent(int prozent) = 0;
		// Teilt dem Server mit, dass das Spiel fertig geladen wurde
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool bereitZumSpiel() = 0;
		// Sendet während des Spiels eine Nachricht an den Server
		//  län: Die Länge der Nachricht
		//  bytes: Ein Zeiger auf die Nachricht
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool spielNachricht(short län, const  char* bytes) = 0;
		// Sendet während der Statistik eine Nachricht an den Server
		//  län: Die Länge der Nachricht
		//  bytes: Ein Zeiger auf die Nachricht
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool statistikNachricht(short län, const char* bytes) = 0;
		// Wartet auf eine Nachricht vom Spiel Server.
		//  Gibt bei Erfolg 1 zurück, 0 sonnst
		//  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
		virtual bool getNextMessage(SpielServerNachricht& nachricht) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne() = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen
	//  Kann nur von eingeloggten Clients verwendet werden
	class HistorieServerClient : public virtual Framework::ReferenceCounter
	{
	protected:
		// verbindet sich mit dem zugewiesenen Historie Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;

	public:
		// Lädt die Spiel Aufzeichnung eines Spiels herunter und speichert sie unter data/tmp/historie/{spielId}
		//  Die Spielid wurde dem Objekt zum Zeitpunkt der Erstellung vom Information Server mitgegeben
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		//  Diese Funktion verbindet sich selbstständig mit dem Server und trennt die Verbindung nach Beendigung des Vorgangs
		virtual bool downloadSpielHistorie() = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
	//  Kann nur von eingeloggten Clients verwendet werden
	class MinigameServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Minigame Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// Gibt die Id des aktuell spielenden Accounts zurück
		virtual int getAccountId() = 0;
		// Gibt den Anzeigenamen eines bestimmten Accounts zurück
		//  id: Die id des Accounts
		virtual Text* getAccountName(int id) = 0;
		// Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
		virtual Text* getSecret() = 0;
		// Ermittelt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
		//  mName: Der Name des Minigames
		//  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen
		//  Gibt die Anzahl der Optionen zurück
		virtual int getMinigameOptionList(const char* mName, Framework::RCArray< Framework::Text >* zOptionList) = 0;
		// Ermittelt eine Liste mit den Weltbesten Scores zurück
		//  mName: Der Name des Minigames
		//  zScore: Enthält nach erfolgreichem Aufruf eine Liste mit Scores
		//  zPlayerList: Enthält nach erfolgreichem Aufruf eine Liste mit angezeigten Account Namen, die die Scores erreicht haben.
		//  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen, die beim erreichen der Scores aktiv waren.
		//  Gibt die Anzahl der Bestscores zurück
		virtual int getMinigameBestscoreList(const char* mName, Framework::Array< int >* zScore, Framework::RCArray< Framework::Text >* zPlayerList, Framework::RCArray< Framework::Text >* zOptionList) = 0;
		// Gibt den Welt bestscore zu einem Bestimmten Minigame mit bestimmten Optionen zurück.
		//  mName: Der Name des Minigames
		//  oName: Die Optionen
		//  zPlayer: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
		virtual int getMinigameOptionBestscore(const char* mName, const char* oName, Framework::Text* zPlayer) = 0;
		// Meldet die Beendigung eines Minigames
		//  mName: Der Name des Minigames
		//  oName: Die Optionen mit denen gespielt wurde
		//  score: Der Erreichte Score
		//  zCapture: Ein Zeiger auf eine Datei mit der Spielaufzeichnung
		//  Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war
		virtual bool reportEndOfGame(const char* mName, const char* oName, int score, Framework::Datei* zCapture) = 0;
		// Lädt ein Game Capture herunter und speichert sie unter data/tmp/minigames/wb.mgc
		//  mName: Der Name des Minigames
		//  oName: Die Optionen
		//  Gibt die Datei mit dem Capture zurück
		virtual Framework::Datei* downloadGameCapture(const char* mName, const char* oName) = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um Karten für Spiele zu erstellen
	//  Kann nur von eingeloggten Clients verwendet werden
	class EditorServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// verbindet sich mit dem zugewiesenen Editor Server
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool verbinde() = 0;
		// 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
		virtual bool karteErstellen(const char* name, int spielArt) = 0;
		// lädt eine bestimmte Karte
		//  id: Die Id der Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladeKarte(int id) = 0;
		// 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
		virtual int getAbbildListe(Framework::RCArray< Framework::Text >* name, Framework::RCArray< Framework::Zeit >* datum) = 0;
		// Erstellt ein neues Abbild der geladenen Karte
		//  name: Der Name des Abbildes
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool abbildErstellen(const char* name) = 0;
		// Löscht ein altes Abbild der geladenen Karte
		//  name: Der Name des Abbildes
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool abbildLöschen(const char* name) = 0;
		// 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
		virtual bool abbildHerstellen(const char* name) = 0;
		// Verüffentlich eine neue Version der geladenen Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool veröffentlichen() = 0;
		// Veröffentlich eine neue Version der Shop Seite der geladenen Karte
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool shopSeiteVeröffentlichen() = 0;
		// 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
		virtual bool ladeShopSeiteVorschau() = 0;
		// 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
		virtual bool ssDateiErstellen(const char* name, int typ) = 0;
		// Öffnet einen Ordner der Shop Seite
		//  name: Der Name des Ordners
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ssOrdnerÖffnen(const char* name) = 0;
		// 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
		virtual Framework::Bild* ssBildLaden(const char* datei, const char* bild) = 0;
		// Löscht eine Datei der Shop Seite
		//  name: Der Name der Datei
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ssDateiLöschen(const char* name) = 0;
		// 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
		virtual Framework::Text* ssTextLaden(const char* datei) = 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
		virtual bool ssTextSpeichern(const char* datei, Framework::Text* zText) = 0;
		// 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
		virtual bool ssBildLöschen(const char* datei, const char* bild) = 0;
		// 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
		virtual bool ssBildSpeichern(const char* datei, const char* name, Framework::Bild* zBild) = 0;
		// 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
		virtual int ssGetDateiListe(Framework::RCArray< Framework::Text >* zList) = 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
		virtual int ssGetBildListe(const char* name, Framework::RCArray< Framework::Text >* zList) = 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
		virtual bool getShopDaten(int& es, int& tp, int& vp) = 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
		virtual bool setShopDaten(int es, int tp, int vp) = 0;
		// gibt die Kartenbeschreibung als KSGScript Quellcode zurück
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Text* beschreibungLaden() = 0;
		// gibt das Titelbild der Karte zurück
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Bild* titelbildLaden() = 0;
		// gibt das Minimap Bild der Karte zurück
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Bild* minimapLaden() = 0;
		// gibt das Ladebild der Karte zurück
		//  Gibt bei misserfolg 0 zurück
		virtual Framework::Bild* ladebildLaden() = 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
		virtual bool beschreibungSpeichern(Framework::Text* zText) = 0;
		// speichert das Titelbild der Karte
		//  zBild: das neue Titelbild
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool titelbildSpeichern(Framework::Bild* zBild) = 0;
		// speichert das Minimapbild der Karte
		//  zBild: das neue Minimapbild
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool minimapSpeichern(Framework::Bild* zBild) = 0;
		// speichert das Ladebild der Karte
		//  zBild: das neue Ladebild
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool ladebildSpeichern(Framework::Bild* zBild) = 0;
		// 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
		virtual bool ladeTeamDaten(SpielerTeamStrukturV* sts) = 0;
		// speichert die Team Daten
		//  sts: die neuen Spieler Team Daten
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool speicherTeamDaten(SpielerTeamStrukturV* sts) = 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
		virtual bool deNeueDatei(char typ, Framework::Text* zName) = 0;
		// Öffnet Ordner im Datei Editor
		//  zName: Der Name des Ordners
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool deOrdnerÖffnen(Framework::Text* zName) = 0;
		// 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
		virtual Framework::Bild* deBildLaden(Framework::Text* zDatei, Framework::Text* zBild, Framework::FBalken* zF) = 0;
		// Löscht eine Datei aus dem Datei Editor
		//  zName: Der Name der Datei
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool deDateiLöschen(Framework::Text* zName) = 0;
		// 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
		virtual bool deBildLöschen(Framework::Text* zDatei, Framework::Text* zBild) = 0;
		// 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
		virtual bool deBildSpeichern(Framework::Text* zDatei, Framework::Text* zName, Framework::Bild* zBild, Framework::FBalken* zF) = 0;
		// 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
		virtual int deGetDateiListe(Framework::RCArray< Framework::Text >* zNamen) = 0;
		// 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
		virtual int deGetBildListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen) = 0;
		// 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
		virtual int deGetModelListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen) = 0;
		// 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
		virtual int deGetSoundListe(Framework::Text* zDatei, Framework::RCArray<  Framework::Text >* zNamen) = 0;
		// 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
		virtual bool deModelLöschen(Framework::Text* zDatei, Framework::Text* zModel) = 0;
		// 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
		virtual bool deSoundLöschen(Framework::Text* zDatei, Framework::Text* zSound) = 0;
		// 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
		virtual Framework::Model2DData* deModelLaden(Framework::Text* zDatei, Framework::Text* zModel, Framework::FBalken* zF) = 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
		virtual GSL::GSLSoundV* deSoundLaden(GSL::GSLDateiV* file, Framework::Text* zDatei, Framework::Text* zSound, Framework::FBalken* zF) = 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
		virtual bool deModelSpeichern(Framework::Text* zDatei, Framework::Text* zModel, Framework::Model2DData* zData, Framework::FBalken* zF) = 0;
		// 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
		virtual bool deSoundSpeichern(Framework::Text* zDatei, Framework::Text* zSound, GSL::GSLSoundV* zData, Framework::FBalken* zF) = 0;
		// Setzt das arbeitsverzeichnis auf den obersten ordner
		virtual bool deResetPath() = 0;
		// 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
		virtual int getVerkaufStatistik(Framework::Array< int >* verkauft, Framework::Array< int >* einkommen, Framework::Array< int >* gespielt) = 0;
		// Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
		virtual bool initEditor() = 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
		virtual bool keepAlive() = 0;
		// 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
		virtual bool trenne(bool abmelden) = 0;
		// Beginnt eine individuelle Editor Nachricht
		//  Gibt den Klient zurück, über den mit dem Server kommuniziert werden kann. Im Fehlerfall wird 0 zurückgegeben
		virtual Network::Klient* beginEditorMessage() = 0;
		// Beendet eine Editor Nachricht
		//  sollte nur nach dem erfolgreichem Aufrufen von beginEditorMessage aufgerufen werden
		//  Der Thread, der diese Methode aufgerufen hat, sollte nach dem Erfolgreichen Aufruf am Ende der Kommunikation mit dem Server endEditorMessage aufrufen
		virtual void endEditorMessage() = 0;
		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
		virtual bool istVerbunden() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist (vom selben Thread)
		virtual const char* getLetzterFehler() const = 0;
	};

	// Wird verwendet um Eine Verbindung mit dem Serversystem herzustellen
	class MainServerClient : public virtual Framework::ReferenceCounter
	{
	public:
		// Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
		virtual bool registerSSL(const char* ip, unsigned short port) = 0;
		// Verbindet den Client mit dem Server
		//  Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt.
		virtual bool connect() = 0;
		// Erzeugt einen Erhaltungs Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual ErhaltungServerClient* createErhaltungServerClient() = 0;
		// Erzeugt einen Patch Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual PatchServerClient* createPatchServerClient() = 0;
		// Erzeugt einen News Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual NewsServerClient* createNewsServerClient() = 0;
		// Erzeugt einen Register Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual RegisterServerClient* createRegisterServerClient() = 0;
		// Erzeugt einen Login Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual LoginServerClient* createLoginServerClient() = 0;
		// Erzeugt einen Information Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual InformationServerClient* createInformationServerClient() = 0;
		// Erzeugt einen Chat Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual ChatServerClient* createChatServerClient() = 0;
		// Erzeugt einen Shop Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual ShopServerClient* createShopServerClient() = 0;
		// Erzeugt einen Anmeldung Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual AnmeldungServerClient* createAnmeldungServerClient() = 0;
		// Erzeugt einen Minigame Server Client
		//  Gibt bei misserfolg 0 zurück
		virtual MinigameServerClient* createMinigameServerClient() = 0;
		// Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
		virtual bool disconnect() = 0;
		// Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
		virtual bool unregister() = 0;
		// Gibt die dem Client zugewiesene Id zurück.
		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
		virtual int getClientId() const = 0;
		// Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
		virtual const char* getServerIp() const = 0;
		// Gibt den Port des dem Client zugewiesenen Main Servers zurück.
		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
		virtual unsigned short getServerPort() const = 0;
		// Gibt den Zeiger auf den Schlüssel zurück
		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
		virtual const char* zKey() const = 0;
		// Gibt die Länge des Schlüssels zurück
		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
		virtual unsigned char getKeyLen() const = 0;
		// gibt den Letzten Fehlertext zuück
		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
		virtual const char* getLetzterFehler() const = 0;
	};
}