KSG-Client/KSGClient/Netzwerk/KSGKlient.h

#ifndef KSGKlient_H
#define KSGKlient_H

#include "KSGKlientV.h"
#include "../Strukturen/Strukturen.h"
#include <Bild.h>
#include <GSLSoundV.h>
#include "Critical.h"

using namespace Network;
using namespace Framework;

#define LOCK( cs ) EnterCriticalSection( cs )
#define UNLOCK( cs ) LeaveCriticalSection( cs )

struct AHDaten;

class LoginKlient
{
private:
	Klient *klient;
	bool verbunden;
	char *fehler;
	bool brauchKick;
	int klientId;
	int accountId;
	int ref;
	Critical cs;

public:
	// Konstruktor 
	LoginKlient();
	// Destruktor 
	~LoginKlient(); // wenn verbunden, dann trennen
	// nicht constant
	bool verbinde(); // verbindet sich mit dem Login Server
	int login( const char *name, const char *pass ); // gibt bei Erfolg 1 zurück
	bool kick( const char *geheim );
	bool logout(); // logt den Account aus
	bool keepAlive(); // Erhält die Verbindung aufrecht
	bool trenne(); // trennt sich von dem Login Server
	void setLetzterFehler( char *err ); // setzt den letzten Fehler
	// constant
	bool istVerbunden() const; // prüft, ob mit Login Server verbunden
	int getAccountId() const; // gibt die AccountId zurück
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	LoginKlient *getThis();
	LoginKlient *release();
};

class RegisterKlient
{
private:
	Klient *klient;
	bool verbunden;
	char *fehler;
	bool brauchSchlüssel;
	int klientId;
	int ref;
	Critical cs;

public:
	// Konstruktor 
	RegisterKlient();
	// Destruktor
	~RegisterKlient(); // wenn verbunden, dann trennen
	// nicht constant
	bool verbinde(); // verbindet ich mit dem Register Server
	bool accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag ); // erstellt den Account
	bool accountLöschen( const char *name, const char *pass, const char *geheim ); // löscht den Account
	int accountBestätigen( const char *name, const char *pass ); // account Bestätigung fortsetzen
	bool bestätigen( const char *schlüssel ); // bestätigt den Vorgang mit Schüssel
	void eMailErneutSenden(); // E-Mail nochmal senden
	void später(); // bestätigung später abclose
	void abbrechen(); // bricht den Vorgang ab
	bool passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass ); // ändert das Passwort
	bool eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail ); // ändert die E-Mail Addresse
	bool geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim ); // ändert das Geheimnis
	bool nameVergessen( const char *pass, const char *geheim ); // schickt den Account Namen an die Bekannte E-Mail Addresse
	bool passwortVergessen( const char *name, const char *geheim ); // schickt das Account Passwort an die Bekannte E-Mail Addresse
	bool geheimnisVergessen( const char *name, const char *pass ); // schickt das Account Geheimnis an die Bekannte E-Mail Addresse
	bool eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail ); // gibt die E-Mail Addresse des Accounts zurück
	bool keepAlive(); // Erhält die Verbindung aufrecht
	bool trenne(); // trennt sich von dem Register Server
	// constant
	bool istVerbunden() const; // prüft, ob mit Register Server verbunden
	bool vorgangBrauchBestätigung() const; // prüft, ob eine Bestätigung notwendig ist
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	RegisterKlient *getThis();
	RegisterKlient *release();
};

class InformationKlient : public InformationKlientV
{
private:
	Klient *klient;
	bool verbunden;
	Text *fehler;
	int klientId;
	int ref;
	Critical cs;

public:
	// Konstruktor
	InformationKlient();
	// Destruktor
	~InformationKlient(); // wenn verbunden, dann trennen
	// nicht constant
	virtual bool verbinde() override; // verbindet ich mit dem Informaion Server
    virtual bool getInformationText( Text *txt, int *typ ) override; // fragt nach Informationstext
	virtual bool istSpielErlaubt( int spielId ) override; // fragt, ob das entsprechende Spiel vom Server gesperrt wurde
	virtual bool istKarteErlaubt( int karteId ) override; // fragt, ob die entsprechende Karte vom Server gesperrt wurde
	virtual int getKarteId( char *name ) override; // fragt nach der Id einer Karte
	virtual int getSpielId( char *name ) override; // fragt nach der id eines Spiels
	virtual Text *getSpielerName( int accountId ); // fragt nach dem Namen eines Accounts
    virtual bool getSpielStatistik( int accountId, int spielId, Array< int > *werte ) override; // fragt nach der Spiel Statistik eines Accounts
	virtual Text *getKarteName( int karteId ) override; // fragt nach dem Namen einer Karte
	virtual Text *getSpielName( int spielId ) override; // fragt nach dem Namen einer Spielart
    virtual Text *getChatroomName( int chatroomId ) override; // fragt nach dem Namen eines Chatrooms
    virtual int getSpielId( int karteId ) override; // fragt zu welcher Spielart die Karte gehört
    virtual int getAccountId( char *name ) override; // gibt die Id des Accounts zurück
    virtual int getChatroomId( char *name ) override; // gibt die Id des Chatrooms zurück
    virtual int getGruppenKarteId( int gruppenId ) override; // gibt die karten Id der gruppe zurück
    virtual bool getGruppeSpielerHinzufügen( int gruppeId ) override; // gibt die Spieler hinzufügen Funktion der Gruppe zurück
    virtual int getGruppeAdminId( int gruppeId ) override; // gibt den Gruppen Administrator zurück
    virtual int getSpielerPunkte( int accountId, int spielId ) override; // gibt die Punkte eines Spielers zurück
    virtual Array< int > *getAccountSpielArtListe() override; // gibt eine Liste mit gekauften Spielen zurück
    virtual int getSpielVersion( int spielId ) override; // gibt die neuste Version eines Spiels zurück
    virtual int getKupfer() override; // gibt das Kupfer des Accounts zurück
    virtual int getDateiGruppeIdVonSpiel( int spielId ) override; // Gibt die Dateigruppe eines Spieles zurück
    virtual Text *getDateiGruppePfad( int dgId ) override; // Gibt den Dateigruppen Pfad zurück
    virtual Array< int > *getAccountKarteListe( int spielId ) override; // gibt eine Liste mit gekauften Karten zurück
    virtual int getDateiGruppeIdVonPfad( char *pfad ) override; // Gibt die Dateigruppe eines Pfades zurück
    virtual int getDateiGruppeVersion( int dg ) override; // gibt die neuste Version einer Dateigruppe zurück
	virtual int getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, 
								 Array< int > *accounts, RCArray< Text > *name, RCArray< Text > *zuletztOnline,
                                 RCArray< Text > *letztesSpiel, RCArray< Text > *letzteKarte, RCArray< Text > *punkte ) override; // sucht nach Spielern
	virtual bool getSpielerAktivität( int accId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt, 
                                      Array< int > *anzSpiele, Array< int > *anzGewonnen ) override; // ermittelt die aktivität eines Spielers
    virtual int getAccountKarteSpiele( int account, int karte ) override; // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
    virtual int getAccountKarteSpieleGewonnen( int account, int karte ) override; // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
	virtual bool hatAccountKarte( int account, int karte ) override; // Gibt zurück, ob ein Spieler die Karte im Besitz hat
	virtual bool hatAccountSpiel( int account, int spiel ) override; // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
    virtual Array< int > *getAccountKarteGespieltListe( int account, int spielId ) override; // gibt eine Liste mit Karten zurück, die von einem Spieler bereits gespielt wurden
    virtual Array< int > *getAccountSpielGespieltListe( int account ) override; // gibt eine Liste mit Spielen zurück, die von einem Spieler bereits gespielt wurden
    virtual bool getSpielPartnerListe( int account, Array< int > *spieler, Array< int > *karten, Array< int > *anzahl ) override; // Gibt eine Liste von Spiel Partnern eines Spielers zurück
	virtual bool getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts, 
                                    RCArray< Array< int > > *werte, RCArray< Text > *namen ) override; // Gibt eine Liste mit Spiel Statistiken zurück
    virtual AHDaten *getSpielHistorieDaten( int account ) override; // Gibt eine Liste mit den letzten 20 Spielen zurück
    virtual bool getHistorieServer( int spielId, int *port, Text *ip ) override; // sucht nach dem Historie Server von einem Spiel
    virtual bool keepAlive() override; // Erhält die Verbindung aufrecht
    virtual bool hatRecht( int recht ) override; // Prüft ob Berechtigung vorhanden
	virtual int getKartenListe( char *filter, char sortSpalte, char absteigend, Array< int > *kId, RCArray< Text > *kName, RCArray< Text > *sName,
                                Array< int > *kupfer, Array< int > *verkauft, Array< int > *maxSpieler ) override; // Gibt eine Liste mit Karten zurück
	virtual bool getEditorServer( int karteId, int *port, Text *ip ) override; // sucht nach dem Editor Server von einer Karte
    virtual bool getKartenServer( int karteId, int *port, Text *ip ) override; // sucht nach dem Karten Server von einer Karte
    virtual bool trenne() override; // trennt sich von dem Informaion Server
	// constant
    virtual bool istVerbunden() const override; // prüft, ob mit Informaion Server verbunden
    virtual char *getLetzterFehler() const override; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	virtual InformationKlientV *getThis() override;
	virtual InformationKlientV *release() override;
};

class ChatKlient : private Thread
{
private:
	Klient *senden;
	Klient *empfangen;
	bool verbunden;
	Text *fehler;
	int klientId;
	int ref;
	Critical cs;

public:
	// Konstruktor
	ChatKlient();
	// Destruktor 
	~ChatKlient();
	// nicht constant
	bool verbinde(); // verbindet ich mit dem Chat Server
	bool chatNachricht( int zuAccount, const char *nachricht ); // sendet eine Nachricht zu einem Account
	bool accountNameÄndern( const char *name ); // ändert den Account Namen
	bool freundschaftBeenden( int accountId ); // beendet die Freundschaft mit einem Account
	bool freundesAnfrage( int accountId ); // sendet eine Freundesanfragezu einem Account
	bool freundesAnfrageBeantworten( int accountId, bool ja ); // beantwortet eine Freundesanfrage
	int chatroomErstellen( const char *name ); // erstellt ein chatroom
	bool chatroomEinladung( int accountId, int chatroomId ); // verschickt eine Einladung zu einem Chatroom
	bool chatroomEinladungAblehnen( int accountId, int chatroomId ); // Einladung zum Chatroom wird abgelehnt
	bool chatroomBetreten( int chatroomId ); // betritt ein chatroom
	bool chatroomNachricht( int chatroomId, const char *nachricht ); // chatroom Nachricht senden
	bool chatroomVerlassen( int chatroomId ); // verlässt chatroom
	bool chatroomKick( int chatroomId, int accountId ); // kickt Spieler aus Chatroom( nur wenn admin )
	bool freundesListeAnfragen(); // fragt nach allen freunden
	bool chatNachrichtAnfrage(); // fragt nach chat nachrichten in abwesenheit
	bool keepAlive(); // Erhält die Verbindung aufrecht
	bool trenne(); // trennt sich von dem Chat Server
	virtual void thread(); // empfangen von Nachrichten
	// constant
	bool istVerbunden() const; // prüft, ob mit Chat Server verbunden
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	ChatKlient *getThis();
	ChatKlient *release();
};

class AnmeldungKlient
{
private:
	Klient *klient;
	bool verbunden;
	Text *fehler;
	int klientId;
	bool spielHistorie;
	int ref;
	Critical cs;

public:
	// Konstruktor
	AnmeldungKlient();
	// Destruktor
	~AnmeldungKlient();
	// nicht constant
	bool verbinde(); // verbindet ich mit dem Chat Server
	int gruppeErstellen( int karteId ); // erstellt eine gruppe
	bool gruppeBetreten( int gruppeId, Array< int > *mitglieder, int *anzahl ); // betritt Gruppe
	bool gruppeVerlassen( int gruppeId ); // Verlässt die gruppe
	bool gruppeAnmelden( int gruppeId ); // meldet gruppe an
	bool gruppeAbmelden( int gruppeId ); // meldet gruppe ab
	bool gruppeSpielerEinladen( int accountId, int gruppeId ); // läht Spieler ein die Gruppe zu betreten
	bool gruppeEinladungAbbrechen( int accountId, int gruppeId ); // bricht einladung ab
	bool gruppeEinladungAblehnen( int gruppeId ); // Einladung zur Gruppe ablehnen
	bool kickSpielerAusGruppe( int accountId, int gruppeId ); // wirft Spieler aus Gruppe
	bool gruppeSpielStarten( int gruppeId, bool spielStarten ); // startet das Spiel der Gruppe
	bool gruppeNachricht( int gruppeId, char *nachricht ); // nachricht an gruppe senden
	bool anmelden( int karteId ); // betritt warteschlange
	bool abmelden(); // verlässt warteschlange
	bool keepAlive(); // Erhält die Verbindung aufrecht
	bool trenne(); // trennt sich von dem Chat Server
	// constant
	bool istVerbunden() const; // prüft, ob mit Chat Server verbunden
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	AnmeldungKlient *getThis();
	AnmeldungKlient *release();
};

class SpielKlient : public SpielKlientV
{
private:
	Klient *senden;
	Klient *empfangen;
	bool verbunden;
	Text *fehler;
	int klientId;
	int ref;
	Critical cs;

public:
	// Konstruktor
	SpielKlient();
	// Destruktor
	~SpielKlient();
	// nicht constant
	virtual bool verbinde( unsigned short port, char *ip ); // verbindet ich mit dem Chat Server
	virtual bool spielErstelltAnnehmen(); // klient ist bereit dem erstellten Spiel beizutreten
	virtual bool spielErstelltAblehnen(); // klient ist nicht bereit dem erstellten Spiel beizutreten
	virtual bool spielErstelltTeamWechseln( int team ); // wechselt das Team
	virtual bool spielErstelltTeamFertig(); // bestetigt die Team Auswahl
	virtual bool spielErstelltChatNachricht( char *nachricht ); // sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
	virtual bool bereitZumLaden(); // Klient ist bereit zum Laden
	virtual bool setLadenProzent( int prozent ); // Setzt den Fortschritt des Klients
	virtual bool bereitZumSpiel(); // Klient ist bereit zum Spiel
	virtual bool spielNachricht( short län, char *bytes ); // Nachricht während des Spiels
	virtual bool statistikNachricht( short län, char *bytes ); // Nachricht während der Statistik
	virtual bool keepAlive(); // Erhält die Verbindung aufrecht
	virtual bool trenne(); // trennt sich von dem Chat Server
	virtual void thread(); // empfangen von Nachrichten
	// constant
	virtual bool istVerbunden() const; // prüft, ob mit Chat Server verbunden
	virtual char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	virtual SpielKlientV *getThis();
	virtual SpielKlientV *release();
};

class ShopKlient
{
private:
	Klient *klient;
	bool verbunden;
	Text *fehler;
	int klientId;
	int ref;
    Critical cs;

    bool verbinde( int port, char *ip ); // verbindet sich mit vorgegebenem Server 

public:
	// Konstruktor
	ShopKlient();
	// Destruktor
	~ShopKlient();
	// nicht constant
	bool verbinde(); // verbindet sich mit dem Shop Server
	Array< int > *suchSpiele( const char *suche ); // sucht nach Spielen
	bool ladeSpielTitel( int id ); // läd Titelbild des Spieles herunter
	bool ladeSpielSeite( int id ); // läd Seite des Spieles herunter
	int getSpielBesitzStatus( int id ); // 0 = nicht im Besitz, 1 = Testversion, 2 = gekauft
	int getSpielTestversion( int id ); // gibt die Anzahl der verbleibenden Spiele zurück
	int istSpielErwerbbar( int id ); // 0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides
	int getSpielPreis( int id, bool testVersion ); // gibt den Preis eines Spieles zurück
	bool spielErwerben( int spielId, bool testVersion ); // Spiel kaufen
	Array< int > *suchKarten( const char *suche, int spielId ); // sucht nach Karten
	bool ladeKarteTitel( int id ); // läd Titelbild der Karte herunter
	bool ladeKarteSeite( int id ); // läd Seite der Karte herunter
	int getKarteBesitzStatus( int id ); // 0 = nicht im Besitz, 1 = Testversion, 2 = gekauft
	int getKarteTestversion( int id ); // gibt die Anzahl der verbleibenden Spiele zurück
	int istKarteErwerbbar( int id ); // prüft, ob die Karte erworben werden kann
	int getKartePreis( int id, bool testVersion ); // gibt den Preis einer Karte zurück
	bool karteErwerben( int karteId, bool testVersion ); // Karte kaufen
	bool keepAlive(); // Erhält die Verbindung aufrecht
	bool trenne(); // trennt sich von dem Shop Server
	// constant
	bool istVerbunden() const; // prüft, ob mit Shop Server verbunden
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	ShopKlient *getThis();
	ShopKlient *release();
};

class HistorieKlient
{
private:
	Klient *klient;
	Text *fehler;
	int klientId;
	int ref;
	Critical cs;
	// privat
	bool verbinde( char *ip, int port ); // verbindet ich mit dem Historie Server
	bool trenne(); // trennt sich von dem Historie Server

public:
	// Konstruktor
	HistorieKlient();
	// Destruktor
	~HistorieKlient();
	// nicht constant
	bool downloadSpielHistorie( int spielId ); // läd Spiel Historie herunter
	// constant
	bool istVerbunden() const; // prüft, ob mit Historie Server verbunden
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	HistorieKlient *getThis();
	HistorieKlient *release();
};

class NewsKlient
{
private:
	Klient *klient;
	bool verbunden;
	Text *fehler;
	int klientId;
	int ref;
	Critical cs;

public:
	// Konstruktor
	NewsKlient();
	// Destruktor
	~NewsKlient();
	// nicht constant
	bool verbinde(); // verbindet ich mit dem News Server
	bool ladeSeite( char *name );
	bool keepAlive(); // Erhält die Verbindung aufrecht
	bool trenne(); // trennt sich von dem News Server
	// constant
	bool istVerbunden() const; // prüft, ob mit News Server verbunden
	char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	NewsKlient *getThis();
	NewsKlient *release();
};

class EditorKlient : public EditorKlientV
{
private:
	Klient *klient;
	bool verbunden;
	Text *fehler;
	int klientId;
	int ref;
	Critical cs;

public:
	// Konstruktor
	EditorKlient();
	// Destruktor
	~EditorKlient();
	// nicht constant
	bool verbinde( unsigned short port, char *ip ) override; // verbindet ich mit dem Editor Server
    bool karteErstellen( Text *zName, int spielArt ) override; // Erstellt eine neue Karte
	bool ladeKarte( int id ) override; // lädt eine bestimmte Karte
    int getAbbildListe( RCArray< Text > *name, RCArray< Zeit > *datum ) override; // gibt eine Liste mit Abbildern der geladenen Karte zurück
    bool abbildErstellen( char *name ) override; // Erstellt ein neues Abbild der Karte
    bool abbildLöschen( char *name ) override; // Löscht ein altes Abbild der Karte
    bool abbildHerstellen( char *name ) override; // Stellt ein altes Abbild der Karte wieder her
    bool veröffentlichen() override; // Veröffentlicht die Karte
    bool shopSeiteVeröffentlichen() override; // Veröffentlicht die Shop Seite
    bool ladeShopSeiteVorschau() override; // Läht die Vorschau der Shop Seite herrunter
    bool ssDateiErstellen( char *name, int typ ) override; // Erstellt eine neue Shop Seiten Datei (typ:0=Ordner,1=Bild,2=Text)
    bool ssOrdnerÖffnen( char *name ) override; // Öffnet einen Ordner der Shop Seite
    Bild *ssBildLaden( char *datei, char *bild ) override; // Läht das ein Bild der Shop Seite
    bool ssDateiLöschen( char *name ) override; // Löscht eine Datei der Shop Seite
    Text *ssTextLaden( char *datei ) override; // Läd eine KSGS Datei der Shop Seite
    bool ssTextSpeichern( char *datei, Text *zText ) override; // Spechert eine KSGS Datei der Shop Seite
    bool ssBildLöschen( char *datei, char *bild ) override; // Löscht ein Bild der Shop Seite
    bool ssBildSpeichern( char *datei, char *name, Bild *zBild ) override; // Speichert ein Bild einer ShopSeite
    int ssGetDateiListe( RCArray< Text > *zList ) override; // Läd die Datei Liste der Shop Seite
    int ssGetBildListe( char *name, RCArray< Text > *zList ) override; // Läd die Bild Liste einer Bild Datei der Shop Seite
    bool getShopDaten( int &es, int &tp, int &vp ) override; // Läht die Shop Daten
    bool setShopDaten( int es, int tp, int vp ) override; // Setzt die Shop Daten
    Text *beschreibungLaden() override; // läht die Kartenbeschreibung
    Bild *titelbildLaden() override; // läht das Titelbild
    Bild *minimapLaden() override; // läht das Minimapbild
    Bild *ladebildLaden() override; // läht das Ladebild
    bool beschreibungSpeichern( Text *zText ) override; // speichert die Kartenbeschreibung
    bool titelbildSpeichern( Bild *zBild ) override; // speichert das Titelbild
    bool minimapSpeichern( Bild *zBild ) override; // speichert das Minimapbild
    bool ladebildSpeichern( Bild *zBild ) override; // speichert das Ladebild
    bool ladeTeamDaten( SpielerTeamStruktur *sts ) override; // läht die Team Daten
    bool speicherTeamDaten( SpielerTeamStruktur *sts ) override; // speichert die Team Daten
    bool deNeueDatei( char typ, Text *zName ) override; // DateienEditor: Erstellt neue Datei (typ: 0=ordner 1=bild 2=modell2d 3=sound
    bool deOrdnerÖffnen( Text *zName ) override; // DateienEditor: Öffnet Ordner
    Bild *deBildLaden( Text *zDatei, Text *zBild, FBalken *zF ) override; // DateienEditor: Bild laden
    bool deDateiLöschen( Text *zName ) override; // DateienEditor: Löscht Datei
    bool deBildLöschen( Text *zDatei, Text *zBild ) override; // DateienEditor: Löscht Bild aus Datei
    bool deBildSpeichern( Text *zDatei, Text *zName, Bild *zBild, FBalken *zF ) override; // DateienEditor: Speichert Bild
    int deGetDateiListe( RCArray< Text > *zNamen ) override; // DateienEditor: Datei Liste herunterladen
    int deGetBildListe( Text *zDatei, RCArray< Text > *zNamen ) override; // DateienEditor: Liste mit in der Datei gespeicherten Bildern
    int deGetModelListe( Text *zDatei, RCArray< Text > *zNamen ) override; // DateienEditor Liste mit in der Datei gespeicherten Modellen
    int deGetSoundListe( Text *zDatei, RCArray< Text > *zNamen ) override; // DateienEditor: Liste mit in der Datei gespeicherten Tönen
    bool deModelLöschen( Text *zDatei, Text *zModel ) override; // DateienEditor: Löscht Modell
    bool deSoundLöschen( Text *zDatei, Text *zSound ) override; // DateienEditor: Löscht Ton
    Model2DData *deModelLaden( Text *zDatei, Text *zModel, FBalken *zF ) override; // DateienEditor: läd ein Model herunter
    GSL::GSLSoundV *deSoundLaden( Text *zDatei, Text *zSound, FBalken *zF ) override; // DateienEditor: läd Sound herunter
    bool deModelSpeichern( Text *zDatei, Text *zModel, Model2DData *zData, FBalken *zF ) override; // DateienEditor: Speichert Modell
    bool deSoundSpeichern( Text *zDatei, Text *zSound, GSL::GSLSoundV *zData, FBalken *zF ) override; // DateienEditor: Speichert Sound
    int getVerkaufStatistik( Array< int > *verkauft, Array< int > *einkommen, Array< int > *gespielt ) override; // Gibt eine Verkaufsstatistik der letzten 30 Tage zurück
    bool initEditor() override; // Initialisiert den Editor auf Serverseite
	bool keepAlive() override; // Erhält die Verbindung aufrecht
	bool trenne() override; // trennt sich von dem Editor Server
    void lock() override;
    void unlock() override;
    Klient *zKlient() override; // gibt den Klient zurück
	// constant
	bool istVerbunden() const override; // prüft, ob mit Editor Server verbunden
	char *getLetzterFehler() const override; // gibt den Letzten Fehlertext zuück
	// Reference Counting
	EditorKlientV *getThis() override;
	EditorKlientV *release() override;
};

class KartenKlient
{
private:
    Klient *klient;
    bool verbunden;
    Text *fehler;
    int klientId;
    int ref;
    Critical cs;

public:
    // Konstruktor
    KartenKlient();
    // Destruktor
    ~KartenKlient();
    // nicht constant
    bool verbinde( unsigned short port, char *ip ); // verbindet ich mit dem Karten Server
    bool downloadKarte( int id ); // läd die Karte herunter
    bool downloadKarteTitel( int id ); // läd das Titelbild einer Karte herunter
    bool downloadKarteBeschreibung( int id ); // läd die Beschreibung einer Karte herunter
    bool downloadKarteMinimap( int id ); // läd die Minimap einer Karte herunter
    bool downloadKarteLadebild( int id ); // läd das Ladebild einer Karte herunter
    bool keepAlive(); // Erhält die Verbindung aufrecht
    bool trenne(); // trennt sich von dem Editor Server
    // constant
    bool istVerbunden() const; // prüft, ob mit Editor Server verbunden
    char *getLetzterFehler() const; // gibt den Letzten Fehlertext zuück
    // Reference Counting
    KartenKlient *getThis();
    KartenKlient *release();
};

class MinigameClient : public MinigameKlientV
{
private:
    Klient *klient;
    bool verbunden;
    char *fehler;
    int klientId;
    int ref;
    bool needCapture;
    Critical cs;

public:
    // Konstruktor
    MinigameClient();
    // Destruktor
    ~MinigameClient();
    // verbindet ich mit dem Minigame Server
    bool verbinde() override; 
    // Gibt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
    //  mName: Der Name des Minigames
    //  zOptionList: Ein Zeiger auf ein Array von Texten, in denen die Optionen gespeichert werden
    //  return: Anzahl der Optionen
    int getMinigameOptionList( char *mName, RCArray< Text > *zOptionList ) override;
    // Gibt eine Liste mit den Weltbesten Scores zurück
    //  mName: Der Name des Minigames
    //  zScore: (rückgabe) Ein Array von Scores
    //  zPlayerList: (rückgabe) Ein Array von Spielernamen, die die Scores erreicht haben.
    //  zOptionList: (rückgabe) Ein Array von Optionen, die beim erreichen der Scores aktiv waren.
    //  return: Anzahl der Scores
    int getMinigameBestscoreList( char *mName, Array< int > *zScore, RCArray< Text > *zPlayerList, RCArray< Text > *zOptionList ) override;
    // Gibt den Welt bestscore zu einem Bestimmten Minigame mit bestimmten Optionen zurück.
    //  mName: Der Name des Minigames
    //  oName: Die Optionen
    //  zPlayer: (rückgabe) Der Spielername, der den Score erreicht hat
    //  return: Der Score der erreicht wurde
    int getMinigameOptionBestscore( char *mName, char *oName, Text *zPlayer ) override;
    // Meldet die Beendigung eines Minigames
    //  mName: Der Name des Minigames
    //  oName: Die Optionen mit denen gespielt wurde
    //  score: Der Erreichte Score
    //  return: 0: Im Falle eines Fehlers, 1: Im Falle eines Erfolgs, 2: Falls ein Game Capture hochgeladen werden muss
    int reportEndOfGame( char *mName, char *oName, int score ) override;
    // Lädt ein Game Capture hoch
    //  zCapture: Ein Zeiger auf die Capture Datei
    //  return: 1, falls erfolgreich
    bool uploadGameCapture( Datei *zCapture ) override;
    // Lädt ein Game Capture herunter
    //  mName: Der Name des Minigames
    //  oName: Die Optionen
    //  return: Ein Zeiger auf die Datei mit dem Capture
    Datei *downloadGameCapture( char *mName, char *oName ) override;
    bool keepAlive() override; // Erhält die Verbindung aufrecht
    bool trenne() override; // trennt sich von dem Minigame Server
    bool istVerbunden() const override; // prüft, ob mit Editor Server verbunden
    char *getLetzterFehler() const override; // gibt den Letzten Fehlertext zuück
    // Reference Counting
    MinigameKlientV *getThis();
    MinigameKlientV *release();
};

#endif