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 )( char *ip, unsigned short port, int clientId, 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
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual ErhaltungServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual ErhaltungServerClient *release() = 0;
    };

    // Wird benutzt, um aktualisierte Spieldateien herunterzuladen
    class PatchServerClient
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual PatchServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual PatchServerClient *release() = 0;
    };

    // Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten)
    class NewsServerClient
    {
    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( 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual NewsServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual NewsServerClient *release() = 0;
    };

    // Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
    class RegisterServerClient
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual RegisterServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual RegisterServerClient *release() = 0;
    };

    // Wird verwendet um sich einzuloggen oder auszuloggen
    class LoginServerClient
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual LoginServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual LoginServerClient *release() = 0;
    };

    class EditorServerClient;
    class KartenServerClient;
    class HistorieServerClient;

    // Wird verwendet um informationen über Accounts abzufragen
    //  Kann nur von eingeloggten Clients verwendet werden
    class InformationServerClient
    {
    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( char *name ) = 0;
        // Fragt nach der Id eines Spiels
        //  name: Der Name des Spiels
        //  Gibt bei misserfolg 0 zurück
        virtual int getSpielId( 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( char *name ) = 0;
        // gibt die Id des Chatrooms zurück
        //  name: Der name des Chatrooms
        //  Gibt bei misserfolg 0 zurück
        virtual int getChatroomId( 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( 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( 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( 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual InformationServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual InformationServerClient *release() = 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:
        // 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual ChatServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual ChatServerClient *release() = 0;
    };

    // Wird verwendet um Spiele oder Karten zu kaufen
    //  Kann nur von eingeloggten Clients verwendet werden
    class ShopServerClient
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual ShopServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual ShopServerClient *release() = 0;
    };

    // Wird verwendet um sich für Spiele anzumelden
    //  Kann nur von eingeloggten Clients verwendet werden
    class AnmeldungServerClient
    {
    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, 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual AnmeldungServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual AnmeldungServerClient *release() = 0;
    };

    // Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
    //  Kann nur von eingeloggten Clients verwendet werden
    class KartenServerClient
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual KartenServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual KartenServerClient *release() = 0;
    };

    // Wird zum Online Spielen verwendet
    //  Kann nur von eingeloggten Clients verwendet werden
    class SpielServerClient
    {
    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( 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, 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, 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual SpielServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual SpielServerClient *release() = 0;
    };

    // Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen
    //  Kann nur von eingeloggten Clients verwendet werden
    class HistorieServerClient
    {
    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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual HistorieServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual HistorieServerClient *release() = 0;
    };

    // Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
    //  Kann nur von eingeloggten Clients verwendet werden
    class MinigameServerClient
    {
    public:
        // verbindet sich mit dem zugewiesenen Minigame Server
        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
        virtual bool verbinde() = 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( 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( 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( char *mName, 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( char *mName, 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( char *mName, 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual MinigameServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual MinigameServerClient *release() = 0;
    };

    // Wird verwendet um Karten für Spiele zu erstellen
    //  Kann nur von eingeloggten Clients verwendet werden
    class EditorServerClient
    {
    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( 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( 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( 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( 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( 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( 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( char *datei, 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( 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( 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( 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( char *datei, 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( char *datei, 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( 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;
        // 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;
        // 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual EditorServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual EditorServerClient *release() = 0;
    };

    // Wird verwendet um Eine Verbindung mit dem Serversystem herzustellen
    class MainServerClient
    {
    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( 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 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 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 char *getLetzterFehler() const = 0;
        // Erhöht den Reference Counter um 1 un gibt this zurück
        virtual MainServerClient *getThis() = 0;
        // Verringert den Reference Counter um 1 und gibt 0 zurück.
        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
        virtual MainServerClient *release() = 0;
    };
}