framework changes

Include/KSGNetwork.h

@@ -6,24 +6,24 @@
 
 namespace Framework
 {
-    class Text;
-    class Datei;
-    class KSGTDatei;
-    class FBalken;
-    class Zeit;
-    class Bild;
-    class Model2DData;
+	class Text;
+	class Datei;
+	class KSGTDatei;
+	class FBalken;
+	class Zeit;
+	class Bild;
+	class Model2DData;
 }
 
 namespace GSL
 {
-    class GSLSoundV;
-    class GSLDateiV;
+	class GSLSoundV;
+	class GSLDateiV;
 }
 
 namespace Network
 {
-    class Klient;
+	class Klient;
 }
 
 #define KSGNETWORK_CREATE_MAIN "createMainServerClient"
@@ -31,1275 +31,1275 @@ namespace Network
 
 namespace KSGClient
 {
-    class MainServerClient;
+	class MainServerClient;
 
-    // Entry Point Functions
-    typedef MainServerClient *( *KSGNetworkCreateMain )( );
-    typedef MainServerClient *( *KSGNetworkCreateRegisterdMain )( char *ip, unsigned short port, int clientId, char *key, unsigned char keyLen );
+	// Entry Point Functions
+	typedef MainServerClient* (*KSGNetworkCreateMain)();
+	typedef MainServerClient* (*KSGNetworkCreateRegisterdMain)(const char* ip, unsigned short port, int clientId, const char* key, unsigned char keyLen);
 
-    // Enthält die Daten eines Spielers zu einem vergangenen Spiel
-    struct SpielHistorieSpielerDaten
-    {
-        Framework::Text name; // Der Sichtabe Name des Spielers
-        int punkte; // Die Punkte, die der Spieler in dem Spiel gewonnen / verloren hat
-        Framework::Text status; // Der Status des Spielers in dem Spiel (verloren, gewonnen, nicht anwesend, beobachter, unentschieden)
-        int farbe; // Die Farbe des Spielers
-    };
+	// Enthält die 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 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 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 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
-    };
+	// 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;
+	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, 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
-    };
+	// Enthält eine Nachricht von dem Spiel Server
+	struct SpielServerNachricht
+	{
+		char type; // Typ der Nachricht
+		char sekunden; // Mit der Nachricht zusammenhängende Sekunden
+		char minuten; // Mit der Nachricht zusammenhängende Minuten
+		char stunden; // Mit der Nachricht zusammenhängende Stunden
+		Framework::Text message; // Text der Nachricht
+		SpielerTeamStrukturV* sts; // Die Spieler Team Struktur eines Spiels
+		int accountId; // Id des Accounts
+		int spielerNummer; // Die Spielernummer des Accounts
+		int karteId; // Die Id der Karte
+		int prozent; // Der Prozentuale Ladefortschritt
+		int ping; // Der Ping des Accounts (1000 = 1 Sekunde)
+		short län; // Länge der gesendeten Daten
+		char* data; // Die gesendeten Daten
+	};
 
-    // Wird benutzt, um die Verbindung mit den Servern aufrecht zu erhalten. Bei einem Verbindungsabbruch wird der Client automatisch abgemeldet
-    class ErhaltungServerClient : protected virtual Framework::Thread, public virtual Framework::ReferenceCounter
-    {
-    protected:
-        // DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
-        virtual void thread() = 0;
-    public:
-        // verbindet ich mit dem Erhaltung Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Meldet sich beim Server ab und trennt die Verbindung
-        virtual void abmelden() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne() = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird benutzt, um die Verbindung mit den Servern aufrecht zu erhalten. Bei einem Verbindungsabbruch wird der Client automatisch abgemeldet
+	class ErhaltungServerClient : protected virtual Framework::Thread, public virtual Framework::ReferenceCounter
+	{
+	protected:
+		// DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
+		virtual void thread() = 0;
+	public:
+		// verbindet ich mit dem Erhaltung Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Meldet sich beim Server ab und trennt die Verbindung
+		virtual void abmelden() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne() = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird benutzt, um aktualisierte Spieldateien herunterzuladen
-    class PatchServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet ich mit dem Patch Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Gibt eine Tabelle von Dateigruppen zurück.
-        //  Gibt bei misserfolg 0 zurück
-        virtual Framework::KSGTDatei *getDateiGruppenListe() = 0;
-        // Gibt eine Tabelle von Dateien zurück.
-        //  gruppe: Die Id der Dateigruppe, zu der die Dateien gehöhren sollen
-        //  Gibt bei misserfolg 0 zurück
-        virtual Framework::KSGTDatei *getDateiListe( int gruppe ) = 0;
-        // Gibt die Größe einer Datei in bytes zurück
-        //  gruppe: Die Id der Dateigruppe der Datei
-        //  pfad: Der Pfad der Datei
-        virtual __int64 getDateiGröße( int gruppe, const char *pfad ) = 0;
-        // Lädt eine Datei herunter
-        //  gruppe: Die Dateigruppe der Datei
-        //  start: Der Index des bytes, bei dem der download begonnen werden soll (Enthält im Falle eines Abbruchs die Position, von welcher aus als nächstes heruntergeladen werden muss)
-        //  pfad: Der Pfad der Datei
-        //  zielPfad: Der Pfad, an den die Datei gespeichert werden soll
-        //  zFb: Ein Fortschrittsbalken, der automatisch aktualisiert wird
-        //  abbruch: Wenn diese Variable während des Vorgangs auf 1 gesetzt wird, so wird das Herunterladen abgebrochen.
-        //  maxbps: Die Anzahl der bytes pro Sekunde, die maximal übertragen werden sollen
-        virtual bool downloadDatei( int gruppe, __int64 *start, const char *pfad, const char *zielPfad, Framework::FBalken *zFb, bool *abbruch, int maxbps ) = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
-        virtual int getDownload() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird benutzt, um aktualisierte Spieldateien herunterzuladen
+	class PatchServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet ich mit dem Patch Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Gibt eine Tabelle von Dateigruppen zurück.
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::KSGTDatei* getDateiGruppenListe() = 0;
+		// Gibt eine Tabelle von Dateien zurück.
+		//  gruppe: Die Id der Dateigruppe, zu der die Dateien gehöhren sollen
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::KSGTDatei* getDateiListe(int gruppe) = 0;
+		// Gibt die Größe einer Datei in bytes zurück
+		//  gruppe: Die Id der Dateigruppe der Datei
+		//  pfad: Der Pfad der Datei
+		virtual __int64 getDateiGröße(int gruppe, const char* pfad) = 0;
+		// Lädt eine Datei herunter
+		//  gruppe: Die Dateigruppe der Datei
+		//  start: Der Index des bytes, bei dem der download begonnen werden soll (Enthält im Falle eines Abbruchs die Position, von welcher aus als nächstes heruntergeladen werden muss)
+		//  pfad: Der Pfad der Datei
+		//  zielPfad: Der Pfad, an den die Datei gespeichert werden soll
+		//  zFb: Ein Fortschrittsbalken, der automatisch aktualisiert wird
+		//  abbruch: Wenn diese Variable während des Vorgangs auf 1 gesetzt wird, so wird das Herunterladen abgebrochen.
+		//  maxbps: Die Anzahl der bytes pro Sekunde, die maximal übertragen werden sollen
+		virtual bool downloadDatei(int gruppe, __int64* start, const char* pfad, const char* zielPfad, Framework::FBalken* zFb, bool* abbruch, int maxbps) = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
+		virtual int getDownload() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten)
-    class NewsServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet ich mit dem News Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Lädt eine KSG-Script Seite herunter uns speichert sie unter data/tmp/news/{name}
-        //  name: Der Name der Seite
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool ladeSeite( 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;
-    };
+	// Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten)
+	class NewsServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet ich mit dem News Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Lädt eine KSG-Script Seite herunter uns speichert sie unter data/tmp/news/{name}
+		//  name: Der Name der Seite
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeSeite(const char* name) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
-    class RegisterServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet ich mit dem Register Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        //  eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll
-        //  jahr: Das Jahr des Geburtsdatums
-        //  monat: Der Monat des Geburtstages
-        //  tag: Der Tag des Geburtstages
-        virtual bool accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag ) = 0;
-        // Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        virtual bool accountLöschen( const char *name, const char *pass, const char *geheim ) = 0;
-        // Ändert das Passwort eines Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        //  nPass: Das neue Passwort des Accounts
-        virtual bool passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass ) = 0;
-        // Ändert die EMail Adresse eines Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        //  nEMail: Die neue EMail Adresse
-        virtual bool eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail ) = 0;
-        // Ändert das Geheimnis eines Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        //  nGeheim: Das neue Geheimnis
-        virtual bool geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim ) = 0;
-        // Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        virtual bool nameVergessen( const char *pass, const char *geheim ) = 0;
-        // Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        virtual bool passwortVergessen( const char *name, const char *geheim ) = 0;
-        // Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        virtual bool geheimnisVergessen( const char *name, const char *pass ) = 0;
-        // Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  name: Der Login Name des Accounts
-        //  pass: Das Login Passwort des Accounts
-        //  geheim: Das Geheimnis des Accounts
-        //  eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden
-        virtual bool eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail ) = 0;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        virtual bool keepAlive() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
+	class RegisterServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet ich mit dem Register Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		//  eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll
+		//  jahr: Das Jahr des Geburtsdatums
+		//  monat: Der Monat des Geburtstages
+		//  tag: Der Tag des Geburtstages
+		virtual bool accountErstellen(const char* name, const char* pass, const char* geheim, const char* eMail, unsigned short jahr, char monat, char tag) = 0;
+		// Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		virtual bool accountLöschen(const char* name, const char* pass, const char* geheim) = 0;
+		// Ändert das Passwort eines Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		//  nPass: Das neue Passwort des Accounts
+		virtual bool passwortÄndern(const char* name, const char* pass, const char* geheim, const char* nPass) = 0;
+		// Ändert die EMail Adresse eines Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		//  nEMail: Die neue EMail Adresse
+		virtual bool eMailÄndern(const char* name, const char* pass, const char* geheim, const char* nEMail) = 0;
+		// Ändert das Geheimnis eines Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		//  nGeheim: Das neue Geheimnis
+		virtual bool geheimnisÄndern(const char* name, const char* pass, const char* geheim, const char* nGeheim) = 0;
+		// Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		virtual bool nameVergessen(const char* pass, const char* geheim) = 0;
+		// Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		virtual bool passwortVergessen(const char* name, const char* geheim) = 0;
+		// Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		virtual bool geheimnisVergessen(const char* name, const char* pass) = 0;
+		// Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  name: Der Login Name des Accounts
+		//  pass: Das Login Passwort des Accounts
+		//  geheim: Das Geheimnis des Accounts
+		//  eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden
+		virtual bool eMailVergessen(const char* name, const char* pass, const char* geheim, char** eMail) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um sich einzuloggen oder auszuloggen
-    class LoginServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Login Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Der Client wird beim Serversystem in einen Account eingeloggt
-        //  Gibt bei Erfolg 1 zurück, 2 falls en anderer Client in dem Account eingeloggt ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual int login( const char *name, const char *pass ) = 0;
-        // Diese Funktion wird in der Zukunft mal implementiert werden. Mit dem Geheimnis des Accounts können so andere Clients, welche bereits in dem Account eingeloggt werden rausgeschmissen werden.
-        virtual bool kick( const char *name, const char *pass, const char *geheim ) = 0;
-        // logt den Account aus
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
-        virtual bool logout() = 0;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        virtual bool keepAlive() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // Gibt die Id des Accounts zurück, in den sich der Client eingeloggt hat.
-        //  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
-        virtual int getAccountId() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird verwendet um sich einzuloggen oder auszuloggen
+	class LoginServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Login Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Der Client wird beim Serversystem in einen Account eingeloggt
+		//  Gibt bei Erfolg 1 zurück, 2 falls en anderer Client in dem Account eingeloggt ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual int login(const char* name, const char* pass) = 0;
+		// Diese Funktion wird in der Zukunft mal implementiert werden. Mit dem Geheimnis des Accounts können so andere Clients, welche bereits in dem Account eingeloggt werden rausgeschmissen werden.
+		virtual bool kick(const char* name, const char* pass, const char* geheim) = 0;
+		// logt den Account aus
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
+		virtual bool logout() = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// Gibt die Id des Accounts zurück, in den sich der Client eingeloggt hat.
+		//  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
+		virtual int getAccountId() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    class EditorServerClient;
-    class KartenServerClient;
-    class HistorieServerClient;
+	class EditorServerClient;
+	class KartenServerClient;
+	class HistorieServerClient;
 
-    // Wird verwendet um informationen über Accounts abzufragen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class InformationServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet ich mit dem zugewiesenen Informaion Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // fragt nach dem Informationstext
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
-        //  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
-        virtual bool getInformationText( Framework::Text *txt, int *typ ) = 0;
-        // fragt, ob das entsprechende Spiel vom Server gesperrt wurde
-        //  spielId: Die Id des Spiels
-        //  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
-        virtual bool istSpielErlaubt( int spielId ) = 0;
-        // fragt, ob die entsprechende Karte vom Server gesperrt wurde
-        //  karteId: Die Id der Karte
-        //  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
-        virtual bool istKarteErlaubt( int karteId ) = 0;
-        // Ermittelt die Id einer Karte
-        //  name: Der Name der Karte
-        //  Gibt bei misserfolg 0 zurück
-        virtual int getKarteId( 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;
-    };
+	// Wird verwendet um informationen über Accounts abzufragen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class InformationServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet ich mit dem zugewiesenen Informaion Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// fragt nach dem Informationstext
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
+		//  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
+		virtual bool getInformationText(Framework::Text* txt, int* typ) = 0;
+		// fragt, ob das entsprechende Spiel vom Server gesperrt wurde
+		//  spielId: Die Id des Spiels
+		//  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
+		virtual bool istSpielErlaubt(int spielId) = 0;
+		// fragt, ob die entsprechende Karte vom Server gesperrt wurde
+		//  karteId: Die Id der Karte
+		//  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
+		virtual bool istKarteErlaubt(int karteId) = 0;
+		// Ermittelt die Id einer Karte
+		//  name: Der Name der Karte
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getKarteId(const char* name) = 0;
+		// Fragt nach der Id eines Spiels
+		//  name: Der Name des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getSpielId(const char* name) = 0;
+		// fragt nach dem Namen eines Accounts
+		//  accountId: Die Id des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* getSpielerName(int accountId) = 0;
+		// fragt nach der Spiel Statistik eines Accounts
+		//  accountId: Die Id des Accounts
+		//  spielId: Die Id des Spiels
+		//  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+		virtual bool getSpielStatistik(int accountId, int spielId, Framework::Array< int >* werte) = 0;
+		// fragt nach dem Namen einer Karte
+		//  karteId: Die id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* getKarteName(int karteId) = 0;
+		// fragt nach dem Namen eines Spiels
+		//  spielId: Die id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* getSpielName(int spielId) = 0;
+		// fragt nach dem Namen eines Chatrooms
+		//  chatroomId: Die id des Chatrooms
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* getChatroomName(int chatroomId) = 0;
+		// fragt zu welcher Spielart die Karte gehört
+		//  karteId: Die id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getSpielId(int karteId) = 0;
+		// gibt die Id eines Accounts zurück
+		//  name: Der Angezeigte Name des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getAccountId(const char* name) = 0;
+		// gibt die Id des Chatrooms zurück
+		//  name: Der name des Chatrooms
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getChatroomId(const char* name) = 0;
+		// gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
+		//  gruppenId: Die id der Gruppe
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getGruppenKarteId(int gruppenId) = 0;
+		// gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
+		//  gruppeId: Die id der Gruppe
+		virtual bool getGruppeSpielerHinzufügen(int gruppeId) = 0;
+		// gibt die Account Id des Gruppen Administrators zurück
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getGruppeAdminId(int gruppeId) = 0;
+		// gibt die Punkte eines Spielers zurück
+		//  accountId: Die Accont Id des Spielers
+		//  spielId: Die Id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getSpielerPunkte(int accountId, int spielId) = 0;
+		// gibt eine Liste mit Ids von gekauften Spielen zurück
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Array< int >* getAccountSpielArtListe() = 0;
+		// gibt die neuste Version eines Spiels zurück
+		//  spielId: Die Id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getSpielVersion(int spielId) = 0;
+		// gibt das Kupfer des Accounts zurück
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getKupfer() = 0;
+		// Gibt die Dateigruppem Id eines Spieles zurück
+		//  spielId: Die Id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getDateiGruppeIdVonSpiel(int spielId) = 0;
+		// Gibt den Dateigruppen Pfad zurück
+		//  dgId: Die Id der Dateigruppe
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* getDateiGruppePfad(int dgId) = 0;
+		// gibt eine Liste mit gekauften Karten zurück
+		//  spielId: Die Spiel Id zu der die Karten gehören sollen
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Array< int >* getAccountKarteListe(int spielId) = 0;
+		// Gibt die Dateigruppen Id eines Pfades zurück
+		//  pfad: Der Pfad der Dateigruppe
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getDateiGruppeIdVonPfad(const char* pfad) = 0;
+		// gibt die neuste Version einer Dateigruppe zurück
+		//  dg: Die Dateigruppen Id
+		//  Gibt bei misserfolg 0 zurück
+		virtual int getDateiGruppeVersion(int dg) = 0;
+		// Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
+		//  suche: Der Text, der in den Namen enthalten sein soll
+		//  seite: Die gewünschte Seite der Tabelle (enthält nach einem Erfolgreichen Aufruf die korrekte Seite)
+		//  maxSeite: Enthält nach erfolgreichem Aufruf die Maximale Seite
+		//  sortSpalte: Die Spalte, nach der Sortiert werden soll
+		//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+		//  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
+		//  Gibt die Anzahl der gefundenen Accounts zurück
+		//  Gibt die Anzahl der Spieler zurück, -1 bei fehler
+		virtual int getSpielerListe(const char* suche, int* seite, int* maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo >* accounts) = 0;
+		// ermittelt die aktivität eines Spielers
+		//  accId: Die Id des Accounts
+		//  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
+		virtual bool getSpielerAktivität(int accId, Framework::Array< AccountActivityInfo >* info) = 0;
+		// Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
+		//  account: Die Id des Accounts
+		//  karte: Die Id der Karte
+		virtual int getAccountKarteSpiele(int account, int karte) = 0;
+		// Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
+		//  account: Die Id des Accounts
+		//  karte: Die Id der Karte
+		virtual int getAccountKarteSpieleGewonnen(int account, int karte) = 0;
+		// Gibt zurück, ob ein Spieler die Karte im Besitz hat
+		//  account: Die Id des Accounts
+		//  karte: Die Id der Karte
+		virtual bool hatAccountKarte(int account, int karte) = 0;
+		// Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
+		//  account: Die Id des Accounts
+		//  spiel: Die Id des Spiels
+		virtual bool hatAccountSpiel(int account, int spiel) = 0;
+		// gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
+		//  account: Die Id des Accounts
+		//  spiel: Die Id des Spiels 
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Array< int >* getAccountKarteGespieltListe(int account, int spielId) = 0;
+		// gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
+		//  account: Die Id des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Array< int >* getAccountSpielGespieltListe(int account) = 0;
+		// Gibt eine Liste von Spiel Partnern eines Spielers zurück
+		//  account: Die Id des Accounts
+		//  spieler: Enthält nach erfolgreichem Aufruf eine Liste mit Account Ids der Spiel Partner
+		//  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
+		//  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool getSpielPartnerListe(int account, Framework::Array< int >* spieler, Framework::Array< int >* karten, Framework::Array< int >* anzahl) = 0;
+		// Gibt eine Liste mit Spiel Statistiken zurück
+		//  account: Die Id des Accounts zu dem die Statistik ermittelt werden soll
+		//  seite: Die gewünschte Seite. Enthält nach efolgreichem Aufruf die korrekte Seite
+		//  maxSeite: Enthält nach erfolgreichem Aufruf die Macimale Seite
+		//  sortSpalte: Die Spalte, nach der Sortiert werden soll
+		//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+		//  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+		//  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool getStatistikListe(int account, int* seite, int* maxSeite, char sortSpalte, char rückwärts,
+			Framework::RCArray< Framework::Array< int > >* werte, Framework::RCArray< Framework::Text >* namen) = 0;
+		// Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
+		//  account: Die Id des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		virtual Array< SpielHistorieDaten >* getSpielHistorieDaten(int account) = 0;
+		// Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
+		//  spielId: Die id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		virtual HistorieServerClient* createHistorieServerClient(int spielId) = 0; // sucht nach dem Historie Server von einem Spiel
+		// Prüft, ob der Account bestimmte Berechtigungen besitzt
+		//  recht: Die Id der Berechtigungen
+		virtual bool hatRecht(int recht) = 0; // Prüft ob Berechtigung vorhanden
+		// Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist
+		//  filter: Die Zeichenkette, die im Namen Auftreten soll
+		//  sortSpalte: Der Index der Spalte, nach der sortiert werden soll
+		//  absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung
+		//  kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält
+		//  kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält
+		//  sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält
+		//  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
+		//  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
+		//  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
+		virtual int getKartenListe(const char* filter, char sortSpalte, char absteigend, Framework::Array< int >* kId, Framework::RCArray< Framework::Text >* kName, Framework::RCArray< Framework::Text >* sName,
+			Framework::Array< int >* kupfer, Framework::Array< int >* verkauft, Framework::Array< int >* maxSpieler) = 0;
+		// Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
+		//  karteId: Die Id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		virtual EditorServerClient* createEditorServerClient(int karteId) = 0;
+		// Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
+		//  karteId: Die Id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		virtual KartenServerClient* createKartenServerClient(int karteId) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um Chat nachrichten zu senden oder zu empfangen. Das Serversystem sendet außerdem einiege Mitteilungen über den Chat (z.B. Gefundene Spiele, Gruppeneinladungen ...)
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class ChatServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Chat Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // sendet eine Chat Nachricht zu einem Account
-        //  zuAccount: Id des Ziel Accounts
-        //  nachricht: Die Nachricht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatNachricht( int zuAccount, const char *nachricht ) = 0;
-        // ändert den angezeigten Account Namen
-        //  name: der neue Name
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool accountNameÄndern( const char *name ) = 0;
-        // beendet die Freundschaft mit einem Account
-        //  accountId: Die Id des Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool freundschaftBeenden( int accountId ) = 0;
-        // sendet eine Freundesanfragezu einem Account
-        //  accountId: Die Id des Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool freundesAnfrage( int accountId ) = 0;
-        // beantwortet eine Freundesanfrage
-        //  accountId: Die Id des Accounts
-        //  ja: 1:=annehmen,0:=ablehnen
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool freundesAnfrageBeantworten( int accountId, bool ja ) = 0;
-        // erstellt ein chatroom
-        //  name: Der Name des Chatrooms
-        //  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
-        virtual int chatroomErstellen( const char *name ) = 0;
-        // Sendet eine Einladung zum Chatroom
-        //  accountId: Die Id des Accounts der eingeladen werden soll
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatroomEinladung( int accountId, int chatroomId ) = 0;
-        // Einladung zum Chatroom wird abgelehnt
-        //  accountId: Die Id des Accounts
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatroomEinladungAblehnen( int accountId, int chatroomId ) = 0;
-        // betritt ein chatroom
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatroomBetreten( int chatroomId ) = 0;
-        // chatroom Nachricht senden
-        //  chatroomId: Die Id des Chatrooms
-        //  nachricht: Die Nachricht die gesendet werden soll
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatroomNachricht( int chatroomId, const char *nachricht ) = 0;
-        // verlässt chatroom
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatroomVerlassen( int chatroomId ) = 0;
-        // kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
-        //  chatroomId: Die Id des Chatrooms
-        //  accountId: Die Id des Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatroomKick( int chatroomId, int accountId ) = 0;
-        // fragt nach allen freunden
-        //  Die Liste der Freunde kann über getNextMessage empfangen werden
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool freundesListeAnfragen() = 0;
-        // fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
-        //  Die einzelnen Nachrichten können über getNextMessage empfangen werden
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool chatNachrichtAnfrage() = 0;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        virtual bool keepAlive() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Wartet auf eine Nachricht vom Chatserver.
-        //  Gibt bei Erfolg 1 zurück, 0 sonnst
-        //  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
-        virtual bool getNextMessage( ChatServerNachricht &nachricht ) = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird verwendet um Chat nachrichten zu senden oder zu empfangen. Das Serversystem sendet außerdem einiege Mitteilungen über den Chat (z.B. Gefundene Spiele, Gruppeneinladungen ...)
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class ChatServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Chat Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// sendet eine Chat Nachricht zu einem Account
+		//  zuAccount: Id des Ziel Accounts
+		//  nachricht: Die Nachricht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatNachricht(int zuAccount, const char* nachricht) = 0;
+		// ändert den angezeigten Account Namen
+		//  name: der neue Name
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool accountNameÄndern(const char* name) = 0;
+		// beendet die Freundschaft mit einem Account
+		//  accountId: Die Id des Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool freundschaftBeenden(int accountId) = 0;
+		// sendet eine Freundesanfragezu einem Account
+		//  accountId: Die Id des Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool freundesAnfrage(int accountId) = 0;
+		// beantwortet eine Freundesanfrage
+		//  accountId: Die Id des Accounts
+		//  ja: 1:=annehmen,0:=ablehnen
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool freundesAnfrageBeantworten(int accountId, bool ja) = 0;
+		// erstellt ein chatroom
+		//  name: Der Name des Chatrooms
+		//  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
+		virtual int chatroomErstellen(const char* name) = 0;
+		// Sendet eine Einladung zum Chatroom
+		//  accountId: Die Id des Accounts der eingeladen werden soll
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatroomEinladung(int accountId, int chatroomId) = 0;
+		// Einladung zum Chatroom wird abgelehnt
+		//  accountId: Die Id des Accounts
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatroomEinladungAblehnen(int accountId, int chatroomId) = 0;
+		// betritt ein chatroom
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatroomBetreten(int chatroomId) = 0;
+		// chatroom Nachricht senden
+		//  chatroomId: Die Id des Chatrooms
+		//  nachricht: Die Nachricht die gesendet werden soll
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatroomNachricht(int chatroomId, const char* nachricht) = 0;
+		// verlässt chatroom
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatroomVerlassen(int chatroomId) = 0;
+		// kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
+		//  chatroomId: Die Id des Chatrooms
+		//  accountId: Die Id des Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatroomKick(int chatroomId, int accountId) = 0;
+		// fragt nach allen freunden
+		//  Die Liste der Freunde kann über getNextMessage empfangen werden
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool freundesListeAnfragen() = 0;
+		// fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
+		//  Die einzelnen Nachrichten können über getNextMessage empfangen werden
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool chatNachrichtAnfrage() = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Wartet auf eine Nachricht vom Chatserver.
+		//  Gibt bei Erfolg 1 zurück, 0 sonnst
+		//  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
+		virtual bool getNextMessage(ChatServerNachricht& nachricht) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um Spiele oder Karten zu kaufen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class ShopServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Shop Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Gibt eine Liste mit Spiel Ids zurück, mit Spielen, die einen Bestimten Text im Namen haben
-        //  suche: Der Text, der im Namen der Spiele vorkommen soll
-        //  Gibt bei misserfolg 0 zurück
-        virtual Framework::Array< int > *suchSpiele( const char *suche ) = 0;
-        // läd Titelbild des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/titelbg.ltdb
-        //  id: Die Id des Spiels
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool ladeSpielTitel( int id ) = 0;
-        // läd Shop Seite des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/seite.ksgs
-        //  id: Die Id des Spiels
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool ladeSpielSeite( int id ) = 0;
-        // Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
-        //  id: Die Id des Spiels
-        virtual int getSpielBesitzStatus( int id ) = 0;
-        // gibt die Anzahl der verbleibenden Spiele der Testversion zurück
-        //  id: Die Id des Spiels
-        virtual int getSpielTestversion( int id ) = 0;
-        // Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
-        //  id: Die Id des Spiels
-        virtual int istSpielErwerbbar( int id ) = 0;
-        // Gibt den Preis eines Spiels in Kupfer zurück
-        //  id: Die Id des Spiels
-        //  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
-        virtual int getSpielPreis( int id, bool testVersion ) = 0;
-        // Kauft ein Spiel
-        //  id: Die Id des Spiels
-        //  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
-        virtual bool spielErwerben( int spielId, bool testVersion ) = 0;
-        // sucht nach Karten mit zu einem bestimmten Spiel
-        //  suche: Ein Text, der im Namen der Karte vorkommen soll
-        //  spielId: Die Id des Spiels
-        //  Gibt eine Liste Mit den Ids der gefundenen Karten zurück
-        virtual Framework::Array< int > *suchKarten( const char *suche, int spielId ) = 0;
-        // lädt das Titelbild der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/titelbg.ltdb
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool ladeKarteTitel( int id ) = 0;
-        // lädt die Shop Seite der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/seite.ksgs
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool ladeKarteSeite( int id ) = 0;
-        // Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
-        //  id: Die Id der Karte
-        virtual int getKarteBesitzStatus( int id ) = 0;
-        // gibt die Anzahl der verbleibenden Spiele der Testversion zurück
-        //  id: Die Id der Karte
-        virtual int getKarteTestversion( int id ) = 0;
-        // Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
-        //  id: Die Id der Karte
-        virtual int istKarteErwerbbar( int id ) = 0;
-        // Gibt den Preis einer Karte in Kupfer zurück
-        //  id: Die Id der Karte
-        //  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
-        virtual int getKartePreis( int id, bool testVersion ) = 0;
-        // Kauft eine Karte
-        //  id: Die Id der Karte
-        //  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
-        virtual bool karteErwerben( int karteId, bool testVersion ) = 0;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        virtual bool keepAlive() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird verwendet um Spiele oder Karten zu kaufen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class ShopServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Shop Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Gibt eine Liste mit Spiel Ids zurück, mit Spielen, die einen Bestimten Text im Namen haben
+		//  suche: Der Text, der im Namen der Spiele vorkommen soll
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Array< int >* suchSpiele(const char* suche) = 0;
+		// läd Titelbild des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/titelbg.ltdb
+		//  id: Die Id des Spiels
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeSpielTitel(int id) = 0;
+		// läd Shop Seite des Spieles herunter und speichert es unter data/tmp/shop/kazfen/spiele/{id}/seite.ksgs
+		//  id: Die Id des Spiels
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeSpielSeite(int id) = 0;
+		// Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
+		//  id: Die Id des Spiels
+		virtual int getSpielBesitzStatus(int id) = 0;
+		// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
+		//  id: Die Id des Spiels
+		virtual int getSpielTestversion(int id) = 0;
+		// Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+		//  id: Die Id des Spiels
+		virtual int istSpielErwerbbar(int id) = 0;
+		// Gibt den Preis eines Spiels in Kupfer zurück
+		//  id: Die Id des Spiels
+		//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
+		virtual int getSpielPreis(int id, bool testVersion) = 0;
+		// Kauft ein Spiel
+		//  id: Die Id des Spiels
+		//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
+		virtual bool spielErwerben(int spielId, bool testVersion) = 0;
+		// sucht nach Karten mit zu einem bestimmten Spiel
+		//  suche: Ein Text, der im Namen der Karte vorkommen soll
+		//  spielId: Die Id des Spiels
+		//  Gibt eine Liste Mit den Ids der gefundenen Karten zurück
+		virtual Framework::Array< int >* suchKarten(const char* suche, int spielId) = 0;
+		// lädt das Titelbild der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/titelbg.ltdb
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeKarteTitel(int id) = 0;
+		// lädt die Shop Seite der Karte herunter und speichert es unter data/tmp/shop/kaufen/karten/{id}/seite.ksgs
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeKarteSeite(int id) = 0;
+		// Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
+		//  id: Die Id der Karte
+		virtual int getKarteBesitzStatus(int id) = 0;
+		// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
+		//  id: Die Id der Karte
+		virtual int getKarteTestversion(int id) = 0;
+		// Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+		//  id: Die Id der Karte
+		virtual int istKarteErwerbbar(int id) = 0;
+		// Gibt den Preis einer Karte in Kupfer zurück
+		//  id: Die Id der Karte
+		//  testVersion: 1:=Es wird der Preis der Testversion zurückgegeben, 0:=Es wird der Preis der Vollversion zurückgegeben
+		virtual int getKartePreis(int id, bool testVersion) = 0;
+		// Kauft eine Karte
+		//  id: Die Id der Karte
+		//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
+		virtual bool karteErwerben(int karteId, bool testVersion) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um sich für Spiele anzumelden
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class AnmeldungServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Anmeldung Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // erstellt eine gruppe
-        //  karteId: Die Id der Karte für die die Gruppe erstellt werden soll
-        //  Gibt bei Erfolg die Id der Gruppe zurück. Bei misserfolg wird 0 zurückgegeben
-        virtual int gruppeErstellen( int karteId ) = 0;
-        // Betritt eine Gruppe
-        //  gruppeId: Die Id der Gruppe
-        //  mitglieder: Nach erfolgreichem Aufruf enthält diese Liste die Lister der Account Ids der Gruppenmitglieder
-        //  anzahl: Nach erfolgreichem Aufruf wird hier die Anzahl der Gruppenmitglieder gespeichert
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeBetreten( int gruppeId, Framework::Array< int > *mitglieder, int *anzahl ) = 0;
-        // Verlässt eine Gruppe
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeVerlassen( int gruppeId ) = 0;
-        // Trägt die Gruppe in die Warteschlange für die Karte ein (nur für den Gruppen Administrator)
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeAnmelden( int gruppeId ) = 0;
-        // Trägt die Gruppe aus der Warteschlange für die Karte aus (nur für den Gruppen Administrator)
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeAbmelden( int gruppeId ) = 0;
-        // läht Spieler ein die Gruppe zu betreten (nur für den Gruppen Administrator)
-        //  accountId: Die Id des Accounts
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeSpielerEinladen( int accountId, int gruppeId ) = 0;
-        // Zieht die Einladung eine Gruppe zu betreten zurück (nur für den Gruppen Administrator)
-        //  accountId: Die Id des Accounts
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeEinladungAbbrechen( int accountId, int gruppeId ) = 0;
-        // Einladung zur Gruppe ablehnen
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeEinladungAblehnen( int gruppeId ) = 0;
-        // wirft Spieler aus Gruppe (nur für den Gruppen Administrator)
-        //  accountId: Die Id des Accounts
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool kickSpielerAusGruppe( int accountId, int gruppeId ) = 0;
-        // Legt fest, ob die Spieler in der Gruppe alleine spielen wollen, oder ob weitere Spieler aus der Warteschlange hinzugefügt werden sollen bis die Karte voll ist
-        //  gruppeId: Die Id der Gruppe
-        //  spielStarte: 1:=alleine spielen, 0:=auf volles Spiel warten
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeSpielStarten( int gruppeId, bool spielStarten ) = 0;
-        // Sendet eine Nachricht an den Gruppen Chat
-        //  gruppeId: Die Id der Gruppe
-        //  nachricht: Die Nachricht, die gesendet werden soll
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool gruppeNachricht( int gruppeId, 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;
-    };
+	// Wird verwendet um sich für Spiele anzumelden
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class AnmeldungServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Anmeldung Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// erstellt eine gruppe
+		//  karteId: Die Id der Karte für die die Gruppe erstellt werden soll
+		//  Gibt bei Erfolg die Id der Gruppe zurück. Bei misserfolg wird 0 zurückgegeben
+		virtual int gruppeErstellen(int karteId) = 0;
+		// Betritt eine Gruppe
+		//  gruppeId: Die Id der Gruppe
+		//  mitglieder: Nach erfolgreichem Aufruf enthält diese Liste die Lister der Account Ids der Gruppenmitglieder
+		//  anzahl: Nach erfolgreichem Aufruf wird hier die Anzahl der Gruppenmitglieder gespeichert
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeBetreten(int gruppeId, Framework::Array< int >* mitglieder, int* anzahl) = 0;
+		// Verlässt eine Gruppe
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeVerlassen(int gruppeId) = 0;
+		// Trägt die Gruppe in die Warteschlange für die Karte ein (nur für den Gruppen Administrator)
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeAnmelden(int gruppeId) = 0;
+		// Trägt die Gruppe aus der Warteschlange für die Karte aus (nur für den Gruppen Administrator)
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeAbmelden(int gruppeId) = 0;
+		// läht Spieler ein die Gruppe zu betreten (nur für den Gruppen Administrator)
+		//  accountId: Die Id des Accounts
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeSpielerEinladen(int accountId, int gruppeId) = 0;
+		// Zieht die Einladung eine Gruppe zu betreten zurück (nur für den Gruppen Administrator)
+		//  accountId: Die Id des Accounts
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeEinladungAbbrechen(int accountId, int gruppeId) = 0;
+		// Einladung zur Gruppe ablehnen
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeEinladungAblehnen(int gruppeId) = 0;
+		// wirft Spieler aus Gruppe (nur für den Gruppen Administrator)
+		//  accountId: Die Id des Accounts
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool kickSpielerAusGruppe(int accountId, int gruppeId) = 0;
+		// Legt fest, ob die Spieler in der Gruppe alleine spielen wollen, oder ob weitere Spieler aus der Warteschlange hinzugefügt werden sollen bis die Karte voll ist
+		//  gruppeId: Die Id der Gruppe
+		//  spielStarte: 1:=alleine spielen, 0:=auf volles Spiel warten
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeSpielStarten(int gruppeId, bool spielStarten) = 0;
+		// Sendet eine Nachricht an den Gruppen Chat
+		//  gruppeId: Die Id der Gruppe
+		//  nachricht: Die Nachricht, die gesendet werden soll
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool gruppeNachricht(int gruppeId, const char* nachricht) = 0;
+		// Meldet den eingeloggten Account in der Warteschlange für eine Karte an
+		//  karteId: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool anmelden(int karteId) = 0;
+		// Meldet den eingeloggten Account aus der Warteschlange ab
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool abmelden() = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class KartenServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Karten Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // lädt eine Karte herunter und speichert sie unter data/tmp/Karten/{id}/spiel
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool downloadKarte( int id ) = 0;
-        // lädt das Titelbild Karte herunter und speichert es unter data/tmp/Karten/{id}/titel.ltdb
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool downloadKarteTitel( int id ) = 0;
-        // lädt die Beschreibung Karte herunter und speichert sie unter data/tmp/Karten/{id}/beschreibung.ksgs
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool downloadKarteBeschreibung( int id ) = 0;
-        // lädt die Minimap Karte herunter und speichert es unter data/tmp/Karten/{id}/minimap.ltdb
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool downloadKarteMinimap( int id ) = 0;
-        // lädt das Ladebild Karte herunter und speichert es unter data/tmp/Karten/{id}/ladebild.ltdb
-        //  id: Die Id der Karte
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool downloadKarteLadebild( int id ) = 0;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        virtual bool keepAlive() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class KartenServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Karten Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// lädt eine Karte herunter und speichert sie unter data/tmp/Karten/{id}/spiel
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool downloadKarte(int id) = 0;
+		// lädt das Titelbild Karte herunter und speichert es unter data/tmp/Karten/{id}/titel.ltdb
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool downloadKarteTitel(int id) = 0;
+		// lädt die Beschreibung Karte herunter und speichert sie unter data/tmp/Karten/{id}/beschreibung.ksgs
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool downloadKarteBeschreibung(int id) = 0;
+		// lädt die Minimap Karte herunter und speichert es unter data/tmp/Karten/{id}/minimap.ltdb
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool downloadKarteMinimap(int id) = 0;
+		// lädt das Ladebild Karte herunter und speichert es unter data/tmp/Karten/{id}/ladebild.ltdb
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool downloadKarteLadebild(int id) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird zum Online Spielen verwendet
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class SpielServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Karten Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Betritt das Vorgeschlagene Spiel
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool spielErstelltAnnehmen() = 0;
-        // Lehnt das Vorgeschlagene Spiel ab
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool spielErstelltAblehnen() = 0;
-        // Wechselt zu einem bestimmten Team
-        //  team: Die Id des teams
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool spielErstelltTeamWechseln( int team ) = 0;
-        // Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool spielErstelltTeamFertig() = 0;
-        // sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
-        //  nachricht: Die Nachricht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool spielErstelltChatNachricht( 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;
-    };
+	// Wird zum Online Spielen verwendet
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class SpielServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Karten Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Betritt das Vorgeschlagene Spiel
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool spielErstelltAnnehmen() = 0;
+		// Lehnt das Vorgeschlagene Spiel ab
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool spielErstelltAblehnen() = 0;
+		// Wechselt zu einem bestimmten Team
+		//  team: Die Id des teams
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool spielErstelltTeamWechseln(int team) = 0;
+		// Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool spielErstelltTeamFertig() = 0;
+		// sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
+		//  nachricht: Die Nachricht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool spielErstelltChatNachricht(const char* nachricht) = 0;
+		// Teilt dem Server mit, dass der Client bereit ist das Spiel zu laden
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool bereitZumLaden() = 0;
+		// Teilt dem Server mit, zu wie viel Prozent der Client das Spiel geladen hat
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool setLadenProzent(int prozent) = 0;
+		// Teilt dem Server mit, dass das Spiel fertig geladen wurde
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool bereitZumSpiel() = 0;
+		// Sendet während des Spiels eine Nachricht an den Server
+		//  län: Die Länge der Nachricht
+		//  bytes: Ein Zeiger auf die Nachricht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool spielNachricht(short län, const  char* bytes) = 0;
+		// Sendet während der Statistik eine Nachricht an den Server
+		//  län: Die Länge der Nachricht
+		//  bytes: Ein Zeiger auf die Nachricht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool statistikNachricht(short län, const char* bytes) = 0;
+		// Wartet auf eine Nachricht vom Spiel Server.
+		//  Gibt bei Erfolg 1 zurück, 0 sonnst
+		//  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
+		virtual bool getNextMessage(SpielServerNachricht& nachricht) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne() = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class HistorieServerClient : public virtual Framework::ReferenceCounter
-    {
-    protected:
-        // verbindet sich mit dem zugewiesenen Historie Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
+	// Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class HistorieServerClient : public virtual Framework::ReferenceCounter
+	{
+	protected:
+		// verbindet sich mit dem zugewiesenen Historie Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
 
-    public:
-        // Lädt die Spiel Aufzeichnung eines Spiels herunter und speichert sie unter data/tmp/historie/{spielId}
-        //  Die Spielid wurde dem Objekt zum Zeitpunkt der Erstellung vom Information Server mitgegeben
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Diese Funktion verbindet sich selbstständig mit dem Server und trennt die Verbindung nach Beendigung des Vorgangs
-        virtual bool downloadSpielHistorie() = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        virtual char *getLetzterFehler() const = 0;
-    };
+	public:
+		// Lädt die Spiel Aufzeichnung eines Spiels herunter und speichert sie unter data/tmp/historie/{spielId}
+		//  Die Spielid wurde dem Objekt zum Zeitpunkt der Erstellung vom Information Server mitgegeben
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Diese Funktion verbindet sich selbstständig mit dem Server und trennt die Verbindung nach Beendigung des Vorgangs
+		virtual bool downloadSpielHistorie() = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class MinigameServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Minigame Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Gibt die Id des aktuell spielenden Accounts zurück
-        virtual int getAccountId() = 0;
-        // Gibt den Anzeigenamen eines bestimmten Accounts zurück
-        //  id: Die id des Accounts
-        virtual Text *getAccountName( int id ) = 0;
-        // Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
-        virtual Text *getSecret() = 0;
-        // Ermittelt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
-        //  mName: Der Name des Minigames
-        //  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen
-        //  Gibt die Anzahl der Optionen zurück
-        virtual int getMinigameOptionList( 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;
-    };
+	// Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class MinigameServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Minigame Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Gibt die Id des aktuell spielenden Accounts zurück
+		virtual int getAccountId() = 0;
+		// Gibt den Anzeigenamen eines bestimmten Accounts zurück
+		//  id: Die id des Accounts
+		virtual Text* getAccountName(int id) = 0;
+		// Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
+		virtual Text* getSecret() = 0;
+		// Ermittelt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
+		//  mName: Der Name des Minigames
+		//  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen
+		//  Gibt die Anzahl der Optionen zurück
+		virtual int getMinigameOptionList(const char* mName, Framework::RCArray< Framework::Text >* zOptionList) = 0;
+		// Ermittelt eine Liste mit den Weltbesten Scores zurück
+		//  mName: Der Name des Minigames
+		//  zScore: Enthält nach erfolgreichem Aufruf eine Liste mit Scores
+		//  zPlayerList: Enthält nach erfolgreichem Aufruf eine Liste mit angezeigten Account Namen, die die Scores erreicht haben.
+		//  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen, die beim erreichen der Scores aktiv waren.
+		//  Gibt die Anzahl der Bestscores zurück
+		virtual int getMinigameBestscoreList(const char* mName, Framework::Array< int >* zScore, Framework::RCArray< Framework::Text >* zPlayerList, Framework::RCArray< Framework::Text >* zOptionList) = 0;
+		// Gibt den Welt bestscore zu einem Bestimmten Minigame mit bestimmten Optionen zurück.
+		//  mName: Der Name des Minigames
+		//  oName: Die Optionen
+		//  zPlayer: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
+		virtual int getMinigameOptionBestscore(const char* mName, const char* oName, Framework::Text* zPlayer) = 0;
+		// Meldet die Beendigung eines Minigames
+		//  mName: Der Name des Minigames
+		//  oName: Die Optionen mit denen gespielt wurde
+		//  score: Der Erreichte Score
+		//  zCapture: Ein Zeiger auf eine Datei mit der Spielaufzeichnung
+		//  Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war
+		virtual bool reportEndOfGame(const char* mName, const char* oName, int score, Framework::Datei* zCapture) = 0;
+		// Lädt ein Game Capture herunter und speichert sie unter data/tmp/minigames/wb.mgc
+		//  mName: Der Name des Minigames
+		//  oName: Die Optionen
+		//  Gibt die Datei mit dem Capture zurück
+		virtual Framework::Datei* downloadGameCapture(const char* mName, const char* oName) = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um Karten für Spiele zu erstellen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class EditorServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // verbindet sich mit dem zugewiesenen Editor Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool verbinde() = 0;
-        // Erstellt eine neue Karte
-        //  name: Der Name der Karte
-        //  spielArt: Die Id des Spiels
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool karteErstellen( 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;
-        // Setzt das arbeitsverzeichnis auf den obersten ordner
-        virtual bool deResetPath() = 0;
-        // Lädt die Kauf Statistik der geladenen Karte
-        //  verkauft: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Käufe der Karte der letzten 30 Tage
-        //  einkommen: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der verdinten Kupfer in den letzten 30 Tagen
-        //  gespielt: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Spielen der letzten 30 Tage
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual int getVerkaufStatistik( Framework::Array< int > *verkauft, Framework::Array< int > *einkommen, Framework::Array< int > *gespielt ) = 0;
-        // Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool initEditor() = 0;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        virtual bool keepAlive() = 0;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        virtual bool trenne( bool abmelden ) = 0;
-        // Beginnt eine individuelle Editor Nachricht
-        //  Gibt den Klient zurück, über den mit dem Server kommuniziert werden kann. Im Fehlerfall wird 0 zurückgegeben
-        virtual Network::Klient *beginEditorMessage() = 0;
-        // Beendet eine Editor Nachricht
-        //  sollte nur nach dem erfolgreichem Aufrufen von beginEditorMessage aufgerufen werden
-        //  Der Thread, der diese Methode aufgerufen hat, sollte nach dem Erfolgreichen Aufruf am Ende der Kommunikation mit dem Server endEditorMessage aufrufen
-        virtual void endEditorMessage() = 0;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        virtual bool istVerbunden() const = 0;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist (vom selben Thread)
-        virtual char *getLetzterFehler() const = 0;
-    };
+	// Wird verwendet um Karten für Spiele zu erstellen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class EditorServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// verbindet sich mit dem zugewiesenen Editor Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool verbinde() = 0;
+		// Erstellt eine neue Karte
+		//  name: Der Name der Karte
+		//  spielArt: Die Id des Spiels
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool karteErstellen(const char* name, int spielArt) = 0;
+		// lädt eine bestimmte Karte
+		//  id: Die Id der Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeKarte(int id) = 0;
+		// gibt eine Liste mit Abbildern der geladenen Karte zurück
+		//  name: Enthält nach erfolgreichem Aufruf eine Liste mit Namen der Abbilder
+		//  datum: Enthält nach erfolgreichem Aufruf eine Liste mit dem Datum der Erstellung für jedes Abbild
+		//  Gibt die Anzahl der Abbilder zurück
+		virtual int getAbbildListe(Framework::RCArray< Framework::Text >* name, Framework::RCArray< Framework::Zeit >* datum) = 0;
+		// Erstellt ein neues Abbild der geladenen Karte
+		//  name: Der Name des Abbildes
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool abbildErstellen(const char* name) = 0;
+		// Löscht ein altes Abbild der geladenen Karte
+		//  name: Der Name des Abbildes
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool abbildLöschen(const char* name) = 0;
+		// Stellt ein altes Abbild der geladenen Karte wieder her
+		//  name: Der Name des Abbildes
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool abbildHerstellen(const char* name) = 0;
+		// Verüffentlich eine neue Version der geladenen Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool veröffentlichen() = 0;
+		// Veröffentlich eine neue Version der Shop Seite der geladenen Karte
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool shopSeiteVeröffentlichen() = 0;
+		// Läht die Vorschau der Shop Seite der geladenen Karte herrunter und speichert sie unter data/tmp/ke/ssv
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeShopSeiteVorschau() = 0;
+		// Erstellt eine neue Shop Seiten Datei
+		//  name: Der Name der Datei
+		//  typ: 0=Ordner, 1=Bild, 2=Text
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ssDateiErstellen(const char* name, int typ) = 0;
+		// Öffnet einen Ordner der Shop Seite
+		//  name: Der Name des Ordners
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ssOrdnerÖffnen(const char* name) = 0;
+		// Lädt das ein Bild der Shop Seite und gibt es zurück
+		//  datei: Der Name der Bilddatei
+		//  bild: Der Name des Bildes
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Bild* ssBildLaden(const char* datei, const char* bild) = 0;
+		// Löscht eine Datei der Shop Seite
+		//  name: Der Name der Datei
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ssDateiLöschen(const char* name) = 0;
+		// Läd eine KSGS Datei der Shop Seite und gibt den Quellcode zurück
+		//  datei: Der Name der Datei
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* ssTextLaden(const char* datei) = 0;
+		// Spechert eine KSGS Datei der Shop Seite
+		//  datei: Der Name der Datei
+		//  zText: Ein Zeiger auf den neuen Quellcode (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ssTextSpeichern(const char* datei, Framework::Text* zText) = 0;
+		// Löscht ein Bild der Shop Seite
+		//  datei: Der Name der Bilddatei
+		//  bild: Der Name des Bildes
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ssBildLöschen(const char* datei, const char* bild) = 0;
+		// Speichert ein Bild einer ShopSeite
+		//  datei: Der name der Bilddatei
+		//  name: Der Name des Bildes
+		//  zBild: Ein Zeiger auf das Bild (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ssBildSpeichern(const char* datei, const char* name, Framework::Bild* zBild) = 0;
+		// Lädt eine Liste mit Dateien von der Shop Seite
+		//  zList: Enthält nach erfolgreichem Aufruf die Liste mit Dateinamen
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual int ssGetDateiListe(Framework::RCArray< Framework::Text >* zList) = 0;
+		// Lädt die Bild Liste einer Bild Datei der Shop Seite
+		//  name: Der Name der Bilddatei
+		//  zList: Enthält nach erfolgreichem Aufruf eine Liste mit Bildnamen
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual int ssGetBildListe(const char* name, Framework::RCArray< Framework::Text >* zList) = 0;
+		// Lädt die Shop Daten
+		//  es: Enthält nach erfolgreichem aufruf den Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+		//  tp: Enthält nach erfolgreichem Aufruf den Preis der Testversion in Kupfer
+		//  vp: Enthält nach erfolgreichem Aufruf den Preis der Vollversion in Kupfer
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool getShopDaten(int& es, int& tp, int& vp) = 0;
+		// Setzt die Shop Daten
+		//  es: der Erwerbbarkeits Status (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+		//  tp: der Preis der Testversion in Kupfer
+		//  vp: der Preis der Vollversion in Kupfer
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool setShopDaten(int es, int tp, int vp) = 0;
+		// gibt die Kartenbeschreibung als KSGScript Quellcode zurück
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Text* beschreibungLaden() = 0;
+		// gibt das Titelbild der Karte zurück
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Bild* titelbildLaden() = 0;
+		// gibt das Minimap Bild der Karte zurück
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Bild* minimapLaden() = 0;
+		// gibt das Ladebild der Karte zurück
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Bild* ladebildLaden() = 0;
+		// speichert den KSGScript Quellcode der Kartenbeschreibung
+		//  zText: Der KSGScript Quellcode (ohne erhöhten reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool beschreibungSpeichern(Framework::Text* zText) = 0;
+		// speichert das Titelbild der Karte
+		//  zBild: das neue Titelbild
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool titelbildSpeichern(Framework::Bild* zBild) = 0;
+		// speichert das Minimapbild der Karte
+		//  zBild: das neue Minimapbild
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool minimapSpeichern(Framework::Bild* zBild) = 0;
+		// speichert das Ladebild der Karte
+		//  zBild: das neue Ladebild
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladebildSpeichern(Framework::Bild* zBild) = 0;
+		// lädt die Spieler Team Daten der Karte
+		//  sts: Enthält nach erfolgreichem Aufruf die Spieler Team Daten
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool ladeTeamDaten(SpielerTeamStrukturV* sts) = 0;
+		// speichert die Team Daten
+		//  sts: die neuen Spieler Team Daten
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool speicherTeamDaten(SpielerTeamStrukturV* sts) = 0;
+		// Erstellt neue Datei im Datei Editor
+		//  typ: 0=ordner 1=bild 2=modell2d 3=sound
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deNeueDatei(char typ, Framework::Text* zName) = 0;
+		// Öffnet Ordner im Datei Editor
+		//  zName: Der Name des Ordners
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deOrdnerÖffnen(Framework::Text* zName) = 0;
+		// Gibt ein Bild aus dem Datei Editor zurück
+		//  zDatei: Der Name der Datei (ohne erhöhten Reference Counter)
+		//  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
+		//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+		//  Gibt bei misserfolg 0 zurück
+		virtual Framework::Bild* deBildLaden(Framework::Text* zDatei, Framework::Text* zBild, Framework::FBalken* zF) = 0;
+		// Löscht eine Datei aus dem Datei Editor
+		//  zName: Der Name der Datei
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deDateiLöschen(Framework::Text* zName) = 0;
+		// Löscht Bild aus Datei im Datei Editor
+		//  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
+		//  zBild: Der Name des Bildes (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deBildLöschen(Framework::Text* zDatei, Framework::Text* zBild) = 0;
+		// Speichert Bild in Datei im Datei Editor
+		//  zDatei: Der Name der Bilddatei (ohne erhöhten Reference Counter)
+		//  zName: Der Name des Bildes (ohne erhöhten Reference Counter)
+		//  zBild: Das neue Bild (ohne erhöhten Reference Counter)
+		//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deBildSpeichern(Framework::Text* zDatei, Framework::Text* zName, Framework::Bild* zBild, Framework::FBalken* zF) = 0;
+		// Lädt eine Liste mit Dateien im aktuellen Ordner des Datei Editors
+		//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit Dateinamen (ohne erhöhten Reference Counter)
+		//  Gibt die Anzahl der Dateien zurück
+		virtual int deGetDateiListe(Framework::RCArray< Framework::Text >* zNamen) = 0;
+		// Lädt eine Liste mit Bildern aus einer Bilddatei des Datei Editors
+		//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Bildnamen (ohne erhöhten Reference Counter)
+		//  Gibt die Anzahl der Bilder zurück
+		virtual int deGetBildListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen) = 0;
+		// Lädt eine Liste mit 2D Modellen aus einer Modeldatei im Datei Editor
+		//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+		//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Modelnamen (ohne erhöhten Reference Counter)
+		//  Gibt die Anzahl der Modelle zurück
+		virtual int deGetModelListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen) = 0;
+		// Lädt eine Liste mit Sounds aus einer Sounddatei im Datei Editor
+		//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+		//  zNamen: Enthält nach erfolgreichem Aufruf eine Liste mit den Soundnamen (ohne erhöhten Reference Counter)
+		//  Gibt die Anzahl der Sounds zurück
+		virtual int deGetSoundListe(Framework::Text* zDatei, Framework::RCArray<  Framework::Text >* zNamen) = 0;
+		// Löscht ein Model aus einer Modeldatei des Datei Editors
+		//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+		//  zModel: Der Name des Models (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deModelLöschen(Framework::Text* zDatei, Framework::Text* zModel) = 0;
+		// Löscht einen Sound aus einer Sounddatei des Datei Editors
+		//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+		//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deSoundLöschen(Framework::Text* zDatei, Framework::Text* zSound) = 0;
+		// Lädt ein Model aus einer Modeldatei des Datei Editors
+		//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+		//  zModel: Enthält nach erfolgreichem Aufruf das Model (ohne erhöhten Reference Counter)
+		//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual Framework::Model2DData* deModelLaden(Framework::Text* zDatei, Framework::Text* zModel, Framework::FBalken* zF) = 0;
+		// Lädt einen Sound herunter und gibt ihn zurück
+		//  file: Ein Zeiger auf die GSLDatei, in der der Sound gespeichert werden soll
+		//  zDatei: Der Name der Sounddatei (ohne erhöhten Reference Counter)
+		//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+		//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+		//  Gibt bei misserfolg 0 zurück
+		virtual GSL::GSLSoundV* deSoundLaden(GSL::GSLDateiV* file, Framework::Text* zDatei, Framework::Text* zSound, Framework::FBalken* zF) = 0;
+		// Speichert ein Model in eine Modeldatei des Datei Editors
+		//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+		//  zModel: Der Name des Models (ohne erhöhten Reference Counter)
+		//  zData: Die Daten des Models (ohne erhöhten Reference Counter)
+		//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deModelSpeichern(Framework::Text* zDatei, Framework::Text* zModel, Framework::Model2DData* zData, Framework::FBalken* zF) = 0;
+		// Speichert einen Sound in einer Sounddatei des Datei Editors
+		//  zDatei: Der Name der Modeldatei (ohne erhöhten Reference Counter)
+		//  zSound: Der Name des Sounds (ohne erhöhten Reference Counter)
+		//  zData: Die Daten des Sounts (ohne erhöhten Reference Counter)
+		//  zF: Ein Fortschrittsbalken, der automatisch aktualisiert wird (ohne erhöhten Reference Counter)
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool deSoundSpeichern(Framework::Text* zDatei, Framework::Text* zSound, GSL::GSLSoundV* zData, Framework::FBalken* zF) = 0;
+		// Setzt das arbeitsverzeichnis auf den obersten ordner
+		virtual bool deResetPath() = 0;
+		// Lädt die Kauf Statistik der geladenen Karte
+		//  verkauft: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Käufe der Karte der letzten 30 Tage
+		//  einkommen: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der verdinten Kupfer in den letzten 30 Tagen
+		//  gespielt: Enthält nach erfolgreichem Aurfuf eine Liste mit den Anzahlen der Spielen der letzten 30 Tage
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual int getVerkaufStatistik(Framework::Array< int >* verkauft, Framework::Array< int >* einkommen, Framework::Array< int >* gespielt) = 0;
+		// Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		virtual bool initEditor() = 0;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		virtual bool keepAlive() = 0;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		virtual bool trenne(bool abmelden) = 0;
+		// Beginnt eine individuelle Editor Nachricht
+		//  Gibt den Klient zurück, über den mit dem Server kommuniziert werden kann. Im Fehlerfall wird 0 zurückgegeben
+		virtual Network::Klient* beginEditorMessage() = 0;
+		// Beendet eine Editor Nachricht
+		//  sollte nur nach dem erfolgreichem Aufrufen von beginEditorMessage aufgerufen werden
+		//  Der Thread, der diese Methode aufgerufen hat, sollte nach dem Erfolgreichen Aufruf am Ende der Kommunikation mit dem Server endEditorMessage aufrufen
+		virtual void endEditorMessage() = 0;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		virtual bool istVerbunden() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist (vom selben Thread)
+		virtual const char* getLetzterFehler() const = 0;
+	};
 
-    // Wird verwendet um Eine Verbindung mit dem Serversystem herzustellen
-    class MainServerClient : public virtual Framework::ReferenceCounter
-    {
-    public:
-        // Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
-        virtual bool registerSSL( 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;
-    };
+	// Wird verwendet um Eine Verbindung mit dem Serversystem herzustellen
+	class MainServerClient : public virtual Framework::ReferenceCounter
+	{
+	public:
+		// Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers
+		virtual bool registerSSL(const char* ip, unsigned short port) = 0;
+		// Verbindet den Client mit dem Server
+		//  Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt.
+		virtual bool connect() = 0;
+		// Erzeugt einen Erhaltungs Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual ErhaltungServerClient* createErhaltungServerClient() = 0;
+		// Erzeugt einen Patch Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual PatchServerClient* createPatchServerClient() = 0;
+		// Erzeugt einen News Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual NewsServerClient* createNewsServerClient() = 0;
+		// Erzeugt einen Register Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual RegisterServerClient* createRegisterServerClient() = 0;
+		// Erzeugt einen Login Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual LoginServerClient* createLoginServerClient() = 0;
+		// Erzeugt einen Information Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual InformationServerClient* createInformationServerClient() = 0;
+		// Erzeugt einen Chat Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual ChatServerClient* createChatServerClient() = 0;
+		// Erzeugt einen Shop Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual ShopServerClient* createShopServerClient() = 0;
+		// Erzeugt einen Anmeldung Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual AnmeldungServerClient* createAnmeldungServerClient() = 0;
+		// Erzeugt einen Minigame Server Client
+		//  Gibt bei misserfolg 0 zurück
+		virtual MinigameServerClient* createMinigameServerClient() = 0;
+		// Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
+		virtual bool disconnect() = 0;
+		// Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
+		virtual bool unregister() = 0;
+		// Gibt die dem Client zugewiesene Id zurück.
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		virtual int getClientId() const = 0;
+		// Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		virtual const char* getServerIp() const = 0;
+		// Gibt den Port des dem Client zugewiesenen Main Servers zurück.
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		virtual unsigned short getServerPort() const = 0;
+		// Gibt den Zeiger auf den Schlüssel zurück
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		virtual const char* zKey() const = 0;
+		// Gibt die Länge des Schlüssels zurück
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		virtual unsigned char getKeyLen() const = 0;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		virtual const char* getLetzterFehler() const = 0;
+	};
 }

KSGNetwork/AnmeldungClient.cpp

@@ -8,129 +8,129 @@ using namespace KSGClient;
 // Inhalt der Anmeldung Klasse
 
 // Konstruktor
-AnmeldungClient::AnmeldungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+AnmeldungClient::AnmeldungClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 AnmeldungClient::~AnmeldungClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Anmeldung Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool AnmeldungClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::ANMELDUNG, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::ANMELDUNG, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Anmeldung Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Anmeldung Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Anmeldung Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::ANMELDUNG, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::ANMELDUNG, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Anmeldung Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Anmeldung Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Anmeldung Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-int AnmeldungClient::gruppeErstellen( int karteId )
+int AnmeldungClient::gruppeErstellen(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\5", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&karteId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            int gruppeId = 0;
-            k->getNachrichtEncrypted( (char *)&gruppeId, 4 );
-            cs.unlock();
-            return gruppeId;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\5", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&karteId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			int gruppeId = 0;
+			k->getNachrichtEncrypted((char*)&gruppeId, 4);
+			cs.unlock();
+			return gruppeId;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Betritt eine Gruppe
@@ -138,521 +138,521 @@ int AnmeldungClient::gruppeErstellen( int karteId )
 //  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
-bool AnmeldungClient::gruppeBetreten( int gruppeId, Framework::Array< int > *mitglieder, int *anzahl )
+bool AnmeldungClient::gruppeBetreten(int gruppeId, Framework::Array< int >* mitglieder, int* anzahl)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x6", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            k->getNachrichtEncrypted( (char *)anzahl, 4 );
-            for( int i = 0; i < *anzahl; i++ )
-            {
-                int id = 0;
-                k->getNachrichtEncrypted( (char *)&id, 4 );
-                mitglieder->add( id, i );
-            }
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x6", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			k->getNachrichtEncrypted((char*)anzahl, 4);
+			for (int i = 0; i < *anzahl; i++)
+			{
+				int id = 0;
+				k->getNachrichtEncrypted((char*)&id, 4);
+				mitglieder->add(id, i);
+			}
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Verlässt eine Gruppe
 //  gruppeId: Die Id der Gruppe
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool AnmeldungClient::gruppeVerlassen( int gruppeId )
+bool AnmeldungClient::gruppeVerlassen(int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::gruppeAnmelden( int gruppeId )
+bool AnmeldungClient::gruppeAnmelden(int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x9", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x9", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::gruppeAbmelden( int gruppeId )
+bool AnmeldungClient::gruppeAbmelden(int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xA", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::gruppeSpielerEinladen( int accountId, int gruppeId )
+bool AnmeldungClient::gruppeSpielerEinladen(int accountId, int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xB", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&accountId, 4 );
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xB", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&accountId, 4);
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::gruppeEinladungAbbrechen( int accountId, int gruppeId )
+bool AnmeldungClient::gruppeEinladungAbbrechen(int accountId, int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x11", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->sendeEncrypted( (char *)&accountId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x11", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->sendeEncrypted((char*)&accountId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Einladung zur Gruppe ablehnen
 //  gruppeId: Die Id der Gruppe
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool AnmeldungClient::gruppeEinladungAblehnen( int gruppeId )
+bool AnmeldungClient::gruppeEinladungAblehnen(int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x12", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x12", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::kickSpielerAusGruppe( int accountId, int gruppeId )
+bool AnmeldungClient::kickSpielerAusGruppe(int accountId, int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xC", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&accountId, 4 );
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xC", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&accountId, 4);
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::gruppeSpielStarten( int gruppeId, bool spielStarten )
+bool AnmeldungClient::gruppeSpielStarten(int gruppeId, bool spielStarten)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x10", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->sendeEncrypted( (char *)&spielStarten, 1 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x10", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->sendeEncrypted((char*)&spielStarten, 1);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::gruppeNachricht( int gruppeId, char *nachricht )
+bool AnmeldungClient::gruppeNachricht(int gruppeId, const char* nachricht)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( nachricht );
-    if( !län )
-        return 1;
-    cs.lock();
-    k->sendeEncrypted( "\xD", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&gruppeId, 4 );
-        k->sendeEncrypted( (char *)&län, 1 );
-        k->sendeEncrypted( nachricht, län );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(nachricht);
+	if (!län)
+		return 1;
+	cs.lock();
+	k->sendeEncrypted("\xD", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&gruppeId, 4);
+		k->sendeEncrypted((char*)&län, 1);
+		k->sendeEncrypted(nachricht, län);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool AnmeldungClient::anmelden( int karteId )
+bool AnmeldungClient::anmelden(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xE", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&karteId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xE", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&karteId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Meldet den eingeloggten Account aus der Warteschlange ab
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool AnmeldungClient::abmelden()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xF", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( serverReturn == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *message = new char[ län + 1 ];
-        message[ län ] = 0;
-        k->getNachrichtEncrypted( message, län );
-        err = message;
-        delete[] message;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xF", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (serverReturn == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* message = new char[län + 1];
+		message[län] = 0;
+		k->getNachrichtEncrypted(message, län);
+		err = message;
+		delete[] message;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erhält die Verbindung aufrecht
@@ -660,83 +660,83 @@ bool AnmeldungClient::abmelden()
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool AnmeldungClient::keepAlive()
 {
-    if( !k )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    Framework::logLine( (char *)"Verbindungstest zum Anmeldung Server..." );
-    bool ok = k->sendeEncrypted( "\x13", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	if (!k)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	Framework::logLine((char*)"Verbindungstest zum Anmeldung Server...");
+	bool ok = k->sendeEncrypted("\x13", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool AnmeldungClient::trenne( bool abmelden )
+bool AnmeldungClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Anmeldung Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Anmeldung Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Anmeldung Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Anmeldung Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool AnmeldungClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *AnmeldungClient::getLetzterFehler() const
+const char* AnmeldungClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/AnmeldungClient.h

@@ -5,98 +5,98 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um sich für Spiele anzumelden
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class AnmeldungClient : public AnmeldungServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird verwendet um sich für Spiele anzumelden
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class AnmeldungClient : public AnmeldungServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        AnmeldungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~AnmeldungClient();
-        // verbindet sich mit dem zugewiesenen Anmeldung Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // 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
-        int gruppeErstellen( int karteId ) override;
-        // 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
-        bool gruppeBetreten( int gruppeId, Framework::Array< int > *mitglieder, int *anzahl ) override;
-        // Verlässt eine Gruppe
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool gruppeVerlassen( int gruppeId ) override;
-        // 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
-        bool gruppeAnmelden( int gruppeId ) override;
-        // 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
-        bool gruppeAbmelden( int gruppeId ) override;
-        // 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
-        bool gruppeSpielerEinladen( int accountId, int gruppeId ) override;
-        // 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
-        bool gruppeEinladungAbbrechen( int accountId, int gruppeId ) override;
-        // Einladung zur Gruppe ablehnen
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool gruppeEinladungAblehnen( int gruppeId ) override;
-        // 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
-        bool kickSpielerAusGruppe( int accountId, int gruppeId ) override;
-        // 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
-        bool gruppeSpielStarten( int gruppeId, bool spielStarten ) override;
-        // 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
-        bool gruppeNachricht( int gruppeId, char *nachricht ) override;
-        // 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
-        bool anmelden( int karteId ) override;
-        // Meldet den eingeloggten Account aus der Warteschlange ab
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool abmelden() override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		AnmeldungClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~AnmeldungClient();
+		// verbindet sich mit dem zugewiesenen Anmeldung Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// 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
+		int gruppeErstellen(int karteId) override;
+		// 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
+		bool gruppeBetreten(int gruppeId, Framework::Array< int >* mitglieder, int* anzahl) override;
+		// Verlässt eine Gruppe
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool gruppeVerlassen(int gruppeId) override;
+		// 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
+		bool gruppeAnmelden(int gruppeId) override;
+		// 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
+		bool gruppeAbmelden(int gruppeId) override;
+		// 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
+		bool gruppeSpielerEinladen(int accountId, int gruppeId) override;
+		// 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
+		bool gruppeEinladungAbbrechen(int accountId, int gruppeId) override;
+		// Einladung zur Gruppe ablehnen
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool gruppeEinladungAblehnen(int gruppeId) override;
+		// 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
+		bool kickSpielerAusGruppe(int accountId, int gruppeId) override;
+		// 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
+		bool gruppeSpielStarten(int gruppeId, bool spielStarten) override;
+		// 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
+		bool gruppeNachricht(int gruppeId, const char* nachricht) override;
+		// 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
+		bool anmelden(int karteId) override;
+		// Meldet den eingeloggten Account aus der Warteschlange ab
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool abmelden() override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/ChatClient.cpp

@@ -9,538 +9,538 @@ using namespace KSGClient;
 // Inhalt der ChatClient Klasse
 
 // Konstruktor
-ChatClient::ChatClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+ChatClient::ChatClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    senden = 0;
-    empfangen = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	senden = 0;
+	empfangen = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 ChatClient::~ChatClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Chat Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool ChatClient::verbinde()
 {
-    cs.lock();
-    if( senden )
-    {
-        cs.unlock();
-        return 1;
-    }
-    senden = new Network::Klient();
-    int keyLen = 0;
-    char *key = 0;
-    Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::SENDEN );
-    senden->setSendeKey( key, keyLen );
-    delete[] key;
-    Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::EMPFANGEN );
-    senden->setEmpfangKey( key, keyLen );
-    delete[] key;
-    if( senden->verbinde( port, ip ) )
-    {
-        if( senden->sendeEncrypted( "\1", 1 ) )
-        {
-            senden->sendeEncrypted( (char *)&cId, 4 );
-            char ret = 0;
-            senden->getNachrichtEncrypted( &ret, 1 );
-            if( ret != 1 )
-            {
-                char byte = 0;
-                senden->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                senden->getNachrichtEncrypted( f, byte );
-                err = f;
-                delete[]f;
-                senden->sendeEncrypted( "\3", 1 );
-                char serverReturn = 0;
-                senden->getNachrichtEncrypted( &serverReturn, 1 );
-                senden->trenne();
-                senden = (Network::Klient *)senden->release();
-                cs.unlock();
-                return 0;
-            }
-            senden->setSendeKey( this->key, this->keyLen );
-            senden->setEmpfangKey( this->key, this->keyLen );
-            empfangen = new Network::Klient();
-            int keyLen = 0;
-            char *key = 0;
-            Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::SENDEN );
-            empfangen->setSendeKey( key, keyLen );
-            delete[] key;
-            Keys::getServerKey( &key, keyLen, Keys::CHAT, Keys::EMPFANGEN );
-            empfangen->setEmpfangKey( key, keyLen );
-            delete[] key;
-            if( empfangen->verbinde( senden->getServerPort(), senden->getServerIp() ) )
-            {
-                empfangen->sendeEncrypted( "\1", 1 );
-                empfangen->sendeEncrypted( (char *)&cId, 4 );
-                char res = 0;
-                empfangen->getNachrichtEncrypted( &res, 1 );
-                if( res == 1 )
-                {
-                    empfangen->setSendeKey( this->key, this->keyLen );
-                    empfangen->setEmpfangKey( this->key, this->keyLen );
-                    cs.unlock();
-                    return 1;
-                }
-                if( res == 3 )
-                {
-                    char län = 0;
-                    senden->getNachrichtEncrypted( &län, 1 );
-                    char *nachricht = new char[ län + 1 ];
-                    nachricht[ län ] = 0;
-                    senden->getNachrichtEncrypted( nachricht, län );
-                    err = nachricht;
-                    delete[]nachricht;
-                }
-                trenne( 0 );
-            }
-            else
-            {
-                err = "Der dir zugewiesene Chat Server kann dir keine Nachrichten senden.";
-                empfangen = (Network::Klient *)empfangen->release();
-                senden->sendeEncrypted( "\3", 1 );
-                char serverReturn = 0;
-                senden->getNachrichtEncrypted( &serverReturn, 1 );
-                senden->trenne();
-                senden = (Network::Klient *)senden->release();
-                cs.unlock();
-                return 0;
-            }
-        }
-        else
-        {
-            err = "Der dir zugewiesene Chat Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
-            senden = (Network::Klient *)senden->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "Der dir zugewiesene Chat Server antwortet nicht. Bitte versuche es Später erneut.";
-        senden = (Network::Klient *)senden->release();
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (senden)
+	{
+		cs.unlock();
+		return 1;
+	}
+	senden = new Network::Klient();
+	int keyLen = 0;
+	char* key = 0;
+	Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::SENDEN);
+	senden->setSendeKey(key, keyLen);
+	delete[] key;
+	Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::EMPFANGEN);
+	senden->setEmpfangKey(key, keyLen);
+	delete[] key;
+	if (senden->verbinde(port, ip))
+	{
+		if (senden->sendeEncrypted("\1", 1))
+		{
+			senden->sendeEncrypted((char*)&cId, 4);
+			char ret = 0;
+			senden->getNachrichtEncrypted(&ret, 1);
+			if (ret != 1)
+			{
+				char byte = 0;
+				senden->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				senden->getNachrichtEncrypted(f, byte);
+				err = f;
+				delete[]f;
+				senden->sendeEncrypted("\3", 1);
+				char serverReturn = 0;
+				senden->getNachrichtEncrypted(&serverReturn, 1);
+				senden->trenne();
+				senden = (Network::Klient*)senden->release();
+				cs.unlock();
+				return 0;
+			}
+			senden->setSendeKey(this->key, this->keyLen);
+			senden->setEmpfangKey(this->key, this->keyLen);
+			empfangen = new Network::Klient();
+			int keyLen = 0;
+			char* key = 0;
+			Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::SENDEN);
+			empfangen->setSendeKey(key, keyLen);
+			delete[] key;
+			Keys::getServerKey(&key, keyLen, Keys::CHAT, Keys::EMPFANGEN);
+			empfangen->setEmpfangKey(key, keyLen);
+			delete[] key;
+			if (empfangen->verbinde(senden->getServerPort(), senden->getServerIp()))
+			{
+				empfangen->sendeEncrypted("\1", 1);
+				empfangen->sendeEncrypted((char*)&cId, 4);
+				char res = 0;
+				empfangen->getNachrichtEncrypted(&res, 1);
+				if (res == 1)
+				{
+					empfangen->setSendeKey(this->key, this->keyLen);
+					empfangen->setEmpfangKey(this->key, this->keyLen);
+					cs.unlock();
+					return 1;
+				}
+				if (res == 3)
+				{
+					char län = 0;
+					senden->getNachrichtEncrypted(&län, 1);
+					char* nachricht = new char[län + 1];
+					nachricht[län] = 0;
+					senden->getNachrichtEncrypted(nachricht, län);
+					err = nachricht;
+					delete[]nachricht;
+				}
+				trenne(0);
+			}
+			else
+			{
+				err = "Der dir zugewiesene Chat Server kann dir keine Nachrichten senden.";
+				empfangen = (Network::Klient*)empfangen->release();
+				senden->sendeEncrypted("\3", 1);
+				char serverReturn = 0;
+				senden->getNachrichtEncrypted(&serverReturn, 1);
+				senden->trenne();
+				senden = (Network::Klient*)senden->release();
+				cs.unlock();
+				return 0;
+			}
+		}
+		else
+		{
+			err = "Der dir zugewiesene Chat Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
+			senden = (Network::Klient*)senden->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "Der dir zugewiesene Chat Server antwortet nicht. Bitte versuche es Später erneut.";
+		senden = (Network::Klient*)senden->release();
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // sendet eine Chat Nachricht zu einem Account
 //  zuAccount: Id des Ziel Accounts
 //  nachricht: Die Nachricht
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatNachricht( int zuAccount, const char *nachricht )
+bool ChatClient::chatNachricht(int zuAccount, const char* nachricht)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( nachricht );
-    if( !län )
-    {
-        cs.unlock();
-        return 1;
-    }
-    senden->sendeEncrypted( "\6", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&zuAccount, 4 );
-        senden->sendeEncrypted( &län, 1 );
-        senden->sendeEncrypted( nachricht, län );
-    }
-    else
-    {
-        err = "Fehler beim senden der Nachricht.";
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(nachricht);
+	if (!län)
+	{
+		cs.unlock();
+		return 1;
+	}
+	senden->sendeEncrypted("\6", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&zuAccount, 4);
+		senden->sendeEncrypted(&län, 1);
+		senden->sendeEncrypted(nachricht, län);
+	}
+	else
+	{
+		err = "Fehler beim senden der Nachricht.";
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // ändert den angezeigten Account Namen
 //  name: der neue Name
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::accountNameÄndern( const char *name )
+bool ChatClient::accountNameÄndern(const char* name)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( name );
-    if( !län )
-    {
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\x8", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( &län, 1 );
-        senden->sendeEncrypted( name, län );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim ändern des Namens.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(name);
+	if (!län)
+	{
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\x8", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted(&län, 1);
+		senden->sendeEncrypted(name, län);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim ändern des Namens.";
+	cs.unlock();
+	return 0;
 }
 
 // beendet die Freundschaft mit einem Account
 //  accountId: Die Id des Accounts
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::freundschaftBeenden( int accountId )
+bool ChatClient::freundschaftBeenden(int accountId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\x9", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&accountId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim beenden der Freundschaft.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\x9", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&accountId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim beenden der Freundschaft.";
+	cs.unlock();
+	return 0;
 }
 
 // sendet eine Freundesanfragezu einem Account
 //  accountId: Die Id des Accounts
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::freundesAnfrage( int accountId )
+bool ChatClient::freundesAnfrage(int accountId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xA", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&accountId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim senden der Freundschaftsanfrage.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xA", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&accountId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim senden der Freundschaftsanfrage.";
+	cs.unlock();
+	return 0;
 }
 
 // beantwortet eine Freundesanfrage
 //  accountId: Die Id des Accounts
 //  ja: 1:=annehmen,0:=ablehnen
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::freundesAnfrageBeantworten( int accountId, bool ja )
+bool ChatClient::freundesAnfrageBeantworten(int accountId, bool ja)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xB", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&accountId, 4 );
-        char ok = (char)ja;
-        senden->sendeEncrypted( &ok, 1 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim beantworten der Freundschaftsanfrage.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xB", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&accountId, 4);
+		char ok = (char)ja;
+		senden->sendeEncrypted(&ok, 1);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim beantworten der Freundschaftsanfrage.";
+	cs.unlock();
+	return 0;
 }
 
 // erstellt ein chatroom
 //  name: Der Name des Chatrooms
 //  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
-int ChatClient::chatroomErstellen( const char *name )
+int ChatClient::chatroomErstellen(const char* name)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( name );
-    if( !län )
-    {
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xC", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( &län, 1 );
-        senden->sendeEncrypted( name, län );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            int ret = 0;
-            senden->getNachrichtEncrypted( (char *)&ret, 4 );
-            cs.unlock();
-            return ret;
-        }
-    }
-    err = "Fehler beim erstellen des Chatrooms.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(name);
+	if (!län)
+	{
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xC", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted(&län, 1);
+		senden->sendeEncrypted(name, län);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			int ret = 0;
+			senden->getNachrichtEncrypted((char*)&ret, 4);
+			cs.unlock();
+			return ret;
+		}
+	}
+	err = "Fehler beim erstellen des Chatrooms.";
+	cs.unlock();
+	return 0;
 }
 
 // Sendet eine Einladung zum Chatroom
 //  accountId: Die Id des Accounts der eingeladen werden soll
 //  chatroomId: Die Id des Chatrooms
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatroomEinladung( int accountId, int chatroomId )
+bool ChatClient::chatroomEinladung(int accountId, int chatroomId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xD", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&accountId, 4 );
-        senden->sendeEncrypted( (char *)&chatroomId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim senden der Chatroomeinladung.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xD", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&accountId, 4);
+		senden->sendeEncrypted((char*)&chatroomId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim senden der Chatroomeinladung.";
+	cs.unlock();
+	return 0;
 }
 
 // Einladung zum Chatroom wird abgelehnt
 //  accountId: Die Id des Accounts
 //  chatroomId: Die Id des Chatrooms
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatroomEinladungAblehnen( int accountId, int chatroomId )
+bool ChatClient::chatroomEinladungAblehnen(int accountId, int chatroomId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xE", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&accountId, 4 );
-        senden->sendeEncrypted( (char *)&chatroomId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim beantworten der Chatroomeinladung.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xE", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&accountId, 4);
+		senden->sendeEncrypted((char*)&chatroomId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim beantworten der Chatroomeinladung.";
+	cs.unlock();
+	return 0;
 }
 
 // betritt ein chatroom
 //  chatroomId: Die Id des Chatrooms
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatroomBetreten( int chatroomId )
+bool ChatClient::chatroomBetreten(int chatroomId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xF", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&chatroomId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim betreten des Chatrooms.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xF", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&chatroomId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim betreten des Chatrooms.";
+	cs.unlock();
+	return 0;
 }
 
 // chatroom Nachricht senden
 //  chatroomId: Die Id des Chatrooms
 //  nachricht: Die Nachricht die gesendet werden soll
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatroomNachricht( int chatroomId, const char *nachricht )
+bool ChatClient::chatroomNachricht(int chatroomId, const char* nachricht)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( nachricht );
-    if( !län )
-    {
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\x10", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&chatroomId, 4 );
-        senden->sendeEncrypted( &län, 1 );
-        senden->sendeEncrypted( nachricht, län );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim senden der Nachricht.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(nachricht);
+	if (!län)
+	{
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\x10", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&chatroomId, 4);
+		senden->sendeEncrypted(&län, 1);
+		senden->sendeEncrypted(nachricht, län);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim senden der Nachricht.";
+	cs.unlock();
+	return 0;
 }
 
 // verlässt chatroom
 //  chatroomId: Die Id des Chatrooms
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatroomVerlassen( int chatroomId )
+bool ChatClient::chatroomVerlassen(int chatroomId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\x11", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&chatroomId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim verlassen des Chatrooms.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\x11", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&chatroomId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim verlassen des Chatrooms.";
+	cs.unlock();
+	return 0;
 }
 
 // kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
 //  chatroomId: Die Id des Chatrooms
 //  accountId: Die Id des Accounts
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool ChatClient::chatroomKick( int chatroomId, int accountId )
+bool ChatClient::chatroomKick(int chatroomId, int accountId)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\x12", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn )
-    {
-        senden->sendeEncrypted( (char *)&chatroomId, 4 );
-        senden->sendeEncrypted( (char *)&accountId, 4 );
-        senden->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    err = "Fehler beim kicken eines Spielers aus dem Chatroom.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\x12", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn)
+	{
+		senden->sendeEncrypted((char*)&chatroomId, 4);
+		senden->sendeEncrypted((char*)&accountId, 4);
+		senden->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	err = "Fehler beim kicken eines Spielers aus dem Chatroom.";
+	cs.unlock();
+	return 0;
 }
 
 // fragt nach allen freunden
@@ -548,24 +548,24 @@ bool ChatClient::chatroomKick( int chatroomId, int accountId )
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool ChatClient::freundesListeAnfragen()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char serverReturn = 0;
-    senden->sendeEncrypted( "\x13", 1 );
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        cs.unlock();
-        return 1;
-    }
-    err = "Fehler beim Anfragen der Freundesliste.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char serverReturn = 0;
+	senden->sendeEncrypted("\x13", 1);
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		cs.unlock();
+		return 1;
+	}
+	err = "Fehler beim Anfragen der Freundesliste.";
+	cs.unlock();
+	return 0;
 }
 
 // fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
@@ -573,24 +573,24 @@ bool ChatClient::freundesListeAnfragen()
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool ChatClient::chatNachrichtAnfrage()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char serverReturn = 0;
-    senden->sendeEncrypted( "\x14", 1 );
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        cs.unlock();
-        return 1;
-    }
-    err = "Fehler beim Anfragen der Chatnachrichten.";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char serverReturn = 0;
+	senden->sendeEncrypted("\x14", 1);
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		cs.unlock();
+		return 1;
+	}
+	err = "Fehler beim Anfragen der Chatnachrichten.";
+	cs.unlock();
+	return 0;
 }
 
 // Erhält die Verbindung aufrecht
@@ -598,300 +598,300 @@ bool ChatClient::chatNachrichtAnfrage()
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool ChatClient::keepAlive()
 {
-    if( !senden )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    Framework::logLine( (char *)"Verbindungstest zum Chat Server..." );
-    bool ok = senden->sendeEncrypted( "\x15", 1 );
-    ok &= senden->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	if (!senden)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	Framework::logLine((char*)"Verbindungstest zum Chat Server...");
+	bool ok = senden->sendeEncrypted("\x15", 1);
+	ok &= senden->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool ChatClient::trenne( bool abmelden )
+bool ChatClient::trenne(bool abmelden)
 {
-    if( !senden )
-        return 1;
-    cs.lock();
-    senden->sendeEncrypted( "\3", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    senden->trenne();
-    senden = (Network::Klient *)senden->release();
-    if( empfangen )
-    {
-        empfangen->trenne();
-        empfangen = (Network::Klient *)empfangen->release();
-    }
-    cs.unlock();
-    return 1;
+	if (!senden)
+		return 1;
+	cs.lock();
+	senden->sendeEncrypted("\3", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	senden->trenne();
+	senden = (Network::Klient*)senden->release();
+	if (empfangen)
+	{
+		empfangen->trenne();
+		empfangen = (Network::Klient*)empfangen->release();
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Wartet auf eine Nachricht vom Chatserver.
 //  Gibt bei Erfolg 1 zurück, 0 sonnst
 //  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
-bool ChatClient::getNextMessage( ChatServerNachricht &nachricht )
+bool ChatClient::getNextMessage(ChatServerNachricht& nachricht)
 {
-    if( !empfangen )
-    {
-        err = "Der Client ist nicht verbunden.";
-        return 0;
-    }
-    do
-    {
-        if( !empfangen->getNachrichtEncrypted( &nachricht.type, 1 ) )
-        {
-            err = "Fehler beim Empfangen der Nachricht.";
-            return 0;
-        }
-        switch( nachricht.type )
-        {
-        case 3: // Fehler
-            if( 1 )
-            {
-                char länge = 0;
-                empfangen->getNachrichtEncrypted( &länge, 1 );
-                char *txt = new char[ länge + 1 ];
-                txt[ länge ] = 0;
-                empfangen->getNachrichtEncrypted( txt, länge );
-                nachricht.message = txt;
-                delete[] txt;
-            }
-            break;
-        case 4: // Chat Nachricht
-            if( 1 )
-            {
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-                char länge = 0;
-                empfangen->getNachrichtEncrypted( &länge, 1 );
-                char *txt = new char[ länge + 1 ];
-                txt[ länge ] = 0;
-                empfangen->getNachrichtEncrypted( txt, länge );
-                nachricht.message = txt;
-                delete[] txt;
-            }
-            break;
-        case 5: // Spiel Einladung
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            break;
-        case 6: // Account Status ändert sich
-            if( 1 )
-            {
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-                char län = 0;
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                char *status = new char[ län + 1 ];
-                status[ län ] = 0;
-                empfangen->getNachrichtEncrypted( status, län );
-                nachricht.message = status;
-                delete[] status;
-            }
-            break;
-        case 7: // Account Name ändert sich
-            if( 1 )
-            {
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-                char län = 0;
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                char *name = new char[ län + 1 ];
-                name[ län ] = 0;
-                empfangen->getNachrichtEncrypted( name, län );
-                nachricht.message = name;
-                delete[] name;
-            }
-            break;
-        case 8: // kein Freund mehr
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 9: // Freundesanfrage
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0xA: // Neuer Freund
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0xB: // Freundesanfrage abgelehnt
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0xC: // Einladung zum Chatroom
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-            break;
-        case 0xD: // Einladung zum Chatroom abgelehnt
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-            break;
-        case 0xE: // Spieler betritt Chatroom
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0xF: // Chatroom Nachricht
-            if( 1 )
-            {
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-                char län = 0;
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                char *txt = new char[ län + 1 ];
-                txt[ län ] = 0;
-                if( län )
-                {
-                    empfangen->getNachrichtEncrypted( txt, län );
-                    nachricht.message = txt;
-                }
-                delete[] txt;
-            }
-            break;
-        case 0x10: // Spieler verlässt Chatroom
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x11: // Freunde
-            if( 1 )
-            {
-                char freundeAnzahl;
-                empfangen->getNachrichtEncrypted( &freundeAnzahl, 1 );
-                for( int i = 0; i < freundeAnzahl; i++ )
-                {
-                    int accountId = 0;
-                    empfangen->getNachrichtEncrypted( (char *)&accountId, 4 );
-                    nachricht.ids.add( accountId );
-                }
-            }
-            break;
-        case 0x12: // Spieler im Chatroom
-            if( 1 )
-            {
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-                char anzahl = 0;
-                empfangen->getNachrichtEncrypted( &anzahl, 1 );
-                for( char i = 0; i < anzahl; i++ )
-                {
-                    int accountId = 0;
-                    empfangen->getNachrichtEncrypted( (char *)&accountId, 4 );
-                    nachricht.ids.add( accountId );
-                }
-            }
-            break;
-        case 0x13: // Freund online
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x14: // Freund offline
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x15: // Chatroom Admin
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-            break;
-        case 0x16: // Chatroom Kick
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.chatroom, 4 );
-            break;
-        case 0x17: // Spieler betritt Gruppe
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            break;
-        case 0x18: // Spieler verlässt Gruppe
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            break;
-        case 0x19: // gruppe Nachricht
-            if( 1 )
-            {
-                char län = 0;
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                if( län )
-                {
-                    char *txt = new char[ län + 1 ];
-                    txt[ län ] = 0;
-                    empfangen->getNachrichtEncrypted( txt, län );
-                    nachricht.message = txt;
-                    delete[] txt;
-                }
-            }
-            break;
-        case 0x1A: // gruppe Angemeldet
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            break;
-        case 0x1B: // gruppe Abgemeldet
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            break;
-        case 0x1C: // gruppe Spiel starten
-            if( 1 )
-            {
-                char starten = 0;
-                empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-                empfangen->getNachrichtEncrypted( &starten, 1 );
-                nachricht.account = starten;
-            }
-            break;
-        case 0x1D: // kick aus Gruppe
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            break;
-        case 0x1E: // gruppe Admin
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x1F: // gruppe Einladung abgelehnt
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x20: // SpielServer Verbindungs Anfrage
-            if( 1 )
-            {
-                unsigned short port;
-                unsigned char *ip = new unsigned char[ 4 ];
-                empfangen->getNachrichtEncrypted( (char *)&port, 2 );
-                empfangen->getNachrichtEncrypted( (char *)ip, 4 );
-                Text *ipT = new Text( "" );
-                ipT->append( (int)ip[ 0 ] );
-                ipT->append( "." );
-                ipT->append( (int)ip[ 1 ] );
-                ipT->append( "." );
-                ipT->append( (int)ip[ 2 ] );
-                ipT->append( "." );
-                ipT->append( (int)ip[ 3 ] );
-                delete[] ip;
-                nachricht.client = new SpielClient( cId, port, ipT->getText(), this->key, this->keyLen );
-                ipT->release();
-            }
-            break;
-        case 0x21: // Gruppe Einladung abgebrochen
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x22: // Gruppe Einladung hinzufügen
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.gruppe, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.account, 4 );
-            break;
-        case 0x23: // ping
-            empfangen->sendeEncrypted( "\1", 1 );
-            break;
-        }
-    } while( nachricht.type == 0x23 );
-    return 1;
+	if (!empfangen)
+	{
+		err = "Der Client ist nicht verbunden.";
+		return 0;
+	}
+	do
+	{
+		if (!empfangen->getNachrichtEncrypted(&nachricht.type, 1))
+		{
+			err = "Fehler beim Empfangen der Nachricht.";
+			return 0;
+		}
+		switch (nachricht.type)
+		{
+		case 3: // Fehler
+			if (1)
+			{
+				char länge = 0;
+				empfangen->getNachrichtEncrypted(&länge, 1);
+				char* txt = new char[länge + 1];
+				txt[länge] = 0;
+				empfangen->getNachrichtEncrypted(txt, länge);
+				nachricht.message = txt;
+				delete[] txt;
+			}
+			break;
+		case 4: // Chat Nachricht
+			if (1)
+			{
+				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+				char länge = 0;
+				empfangen->getNachrichtEncrypted(&länge, 1);
+				char* txt = new char[länge + 1];
+				txt[länge] = 0;
+				empfangen->getNachrichtEncrypted(txt, länge);
+				nachricht.message = txt;
+				delete[] txt;
+			}
+			break;
+		case 5: // Spiel Einladung
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			break;
+		case 6: // Account Status ändert sich
+			if (1)
+			{
+				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+				char län = 0;
+				empfangen->getNachrichtEncrypted(&län, 1);
+				char* status = new char[län + 1];
+				status[län] = 0;
+				empfangen->getNachrichtEncrypted(status, län);
+				nachricht.message = status;
+				delete[] status;
+			}
+			break;
+		case 7: // Account Name ändert sich
+			if (1)
+			{
+				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+				char län = 0;
+				empfangen->getNachrichtEncrypted(&län, 1);
+				char* name = new char[län + 1];
+				name[län] = 0;
+				empfangen->getNachrichtEncrypted(name, län);
+				nachricht.message = name;
+				delete[] name;
+			}
+			break;
+		case 8: // kein Freund mehr
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 9: // Freundesanfrage
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0xA: // Neuer Freund
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0xB: // Freundesanfrage abgelehnt
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0xC: // Einladung zum Chatroom
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+			break;
+		case 0xD: // Einladung zum Chatroom abgelehnt
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+			break;
+		case 0xE: // Spieler betritt Chatroom
+			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0xF: // Chatroom Nachricht
+			if (1)
+			{
+				empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+				empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+				char län = 0;
+				empfangen->getNachrichtEncrypted(&län, 1);
+				char* txt = new char[län + 1];
+				txt[län] = 0;
+				if (län)
+				{
+					empfangen->getNachrichtEncrypted(txt, län);
+					nachricht.message = txt;
+				}
+				delete[] txt;
+			}
+			break;
+		case 0x10: // Spieler verlässt Chatroom
+			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x11: // Freunde
+			if (1)
+			{
+				char freundeAnzahl;
+				empfangen->getNachrichtEncrypted(&freundeAnzahl, 1);
+				for (int i = 0; i < freundeAnzahl; i++)
+				{
+					int accountId = 0;
+					empfangen->getNachrichtEncrypted((char*)&accountId, 4);
+					nachricht.ids.add(accountId);
+				}
+			}
+			break;
+		case 0x12: // Spieler im Chatroom
+			if (1)
+			{
+				empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+				char anzahl = 0;
+				empfangen->getNachrichtEncrypted(&anzahl, 1);
+				for (char i = 0; i < anzahl; i++)
+				{
+					int accountId = 0;
+					empfangen->getNachrichtEncrypted((char*)&accountId, 4);
+					nachricht.ids.add(accountId);
+				}
+			}
+			break;
+		case 0x13: // Freund online
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x14: // Freund offline
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x15: // Chatroom Admin
+			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+			break;
+		case 0x16: // Chatroom Kick
+			empfangen->getNachrichtEncrypted((char*)&nachricht.chatroom, 4);
+			break;
+		case 0x17: // Spieler betritt Gruppe
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			break;
+		case 0x18: // Spieler verlässt Gruppe
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			break;
+		case 0x19: // gruppe Nachricht
+			if (1)
+			{
+				char län = 0;
+				empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+				empfangen->getNachrichtEncrypted(&län, 1);
+				if (län)
+				{
+					char* txt = new char[län + 1];
+					txt[län] = 0;
+					empfangen->getNachrichtEncrypted(txt, län);
+					nachricht.message = txt;
+					delete[] txt;
+				}
+			}
+			break;
+		case 0x1A: // gruppe Angemeldet
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			break;
+		case 0x1B: // gruppe Abgemeldet
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			break;
+		case 0x1C: // gruppe Spiel starten
+			if (1)
+			{
+				char starten = 0;
+				empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+				empfangen->getNachrichtEncrypted(&starten, 1);
+				nachricht.account = starten;
+			}
+			break;
+		case 0x1D: // kick aus Gruppe
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			break;
+		case 0x1E: // gruppe Admin
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x1F: // gruppe Einladung abgelehnt
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x20: // SpielServer Verbindungs Anfrage
+			if (1)
+			{
+				unsigned short port;
+				unsigned char* ip = new unsigned char[4];
+				empfangen->getNachrichtEncrypted((char*)&port, 2);
+				empfangen->getNachrichtEncrypted((char*)ip, 4);
+				Text* ipT = new Text("");
+				ipT->append((int)ip[0]);
+				ipT->append(".");
+				ipT->append((int)ip[1]);
+				ipT->append(".");
+				ipT->append((int)ip[2]);
+				ipT->append(".");
+				ipT->append((int)ip[3]);
+				delete[] ip;
+				nachricht.client = new SpielClient(cId, port, ipT->getText(), this->key, this->keyLen);
+				ipT->release();
+			}
+			break;
+		case 0x21: // Gruppe Einladung abgebrochen
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x22: // Gruppe Einladung hinzufügen
+			empfangen->getNachrichtEncrypted((char*)&nachricht.gruppe, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.account, 4);
+			break;
+		case 0x23: // ping
+			empfangen->sendeEncrypted("\1", 1);
+			break;
+		}
+	} while (nachricht.type == 0x23);
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool ChatClient::istVerbunden() const
 {
-    return senden != 0;
+	return senden != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *ChatClient::getLetzterFehler() const
+const char* ChatClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/ChatClient.h

@@ -5,107 +5,107 @@
 
 namespace KSGClient
 {
-    // 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 ChatClient : public ChatServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *senden;
-        Network::Klient *empfangen;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// 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 ChatClient : public ChatServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* senden;
+		Network::Klient* empfangen;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        ChatClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~ChatClient();
-        // verbindet sich mit dem zugewiesenen Chat Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // sendet eine Chat Nachricht zu einem Account
-        //  zuAccount: Id des Ziel Accounts
-        //  nachricht: Die Nachricht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatNachricht( int zuAccount, const char *nachricht ) override;
-        // ändert den angezeigten Account Namen
-        //  name: der neue Name
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool accountNameÄndern( const char *name ) override;
-        // beendet die Freundschaft mit einem Account
-        //  accountId: Die Id des Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool freundschaftBeenden( int accountId ) override;
-        // sendet eine Freundesanfragezu einem Account
-        //  accountId: Die Id des Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool freundesAnfrage( int accountId ) override;
-        // beantwortet eine Freundesanfrage
-        //  accountId: Die Id des Accounts
-        //  ja: 1:=annehmen,0:=ablehnen
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool freundesAnfrageBeantworten( int accountId, bool ja ) override;
-        // erstellt ein chatroom
-        //  name: Der Name des Chatrooms
-        //  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
-        int chatroomErstellen( const char *name ) override;
-        // Sendet eine Einladung zum Chatroom
-        //  accountId: Die Id des Accounts der eingeladen werden soll
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatroomEinladung( int accountId, int chatroomId ) override;
-        // Einladung zum Chatroom wird abgelehnt
-        //  accountId: Die Id des Accounts
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatroomEinladungAblehnen( int accountId, int chatroomId ) override;
-        // betritt ein chatroom
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatroomBetreten( int chatroomId ) override;
-        // chatroom Nachricht senden
-        //  chatroomId: Die Id des Chatrooms
-        //  nachricht: Die Nachricht die gesendet werden soll
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatroomNachricht( int chatroomId, const char *nachricht ) override;
-        // verlässt chatroom
-        //  chatroomId: Die Id des Chatrooms
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatroomVerlassen( int chatroomId ) override;
-        // kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
-        //  chatroomId: Die Id des Chatrooms
-        //  accountId: Die Id des Accounts
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatroomKick( int chatroomId, int accountId ) override;
-        // fragt nach allen freunden
-        //  Die Liste der Freunde kann über getNextMessage empfangen werden
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool freundesListeAnfragen() override;
-        // fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
-        //  Die einzelnen Nachrichten können über getNextMessage empfangen werden
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool chatNachrichtAnfrage() override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Wartet auf eine Nachricht vom Chatserver.
-        //  Gibt bei Erfolg 1 zurück, 0 sonnst
-        //  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
-        bool getNextMessage( ChatServerNachricht &nachricht ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		ChatClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~ChatClient();
+		// verbindet sich mit dem zugewiesenen Chat Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// sendet eine Chat Nachricht zu einem Account
+		//  zuAccount: Id des Ziel Accounts
+		//  nachricht: Die Nachricht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatNachricht(int zuAccount, const char* nachricht) override;
+		// ändert den angezeigten Account Namen
+		//  name: der neue Name
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool accountNameÄndern(const char* name) override;
+		// beendet die Freundschaft mit einem Account
+		//  accountId: Die Id des Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool freundschaftBeenden(int accountId) override;
+		// sendet eine Freundesanfragezu einem Account
+		//  accountId: Die Id des Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool freundesAnfrage(int accountId) override;
+		// beantwortet eine Freundesanfrage
+		//  accountId: Die Id des Accounts
+		//  ja: 1:=annehmen,0:=ablehnen
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool freundesAnfrageBeantworten(int accountId, bool ja) override;
+		// erstellt ein chatroom
+		//  name: Der Name des Chatrooms
+		//  Gibt bei erfolg die Id des Chatrooms zurück, 0 sonst
+		int chatroomErstellen(const char* name) override;
+		// Sendet eine Einladung zum Chatroom
+		//  accountId: Die Id des Accounts der eingeladen werden soll
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatroomEinladung(int accountId, int chatroomId) override;
+		// Einladung zum Chatroom wird abgelehnt
+		//  accountId: Die Id des Accounts
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatroomEinladungAblehnen(int accountId, int chatroomId) override;
+		// betritt ein chatroom
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatroomBetreten(int chatroomId) override;
+		// chatroom Nachricht senden
+		//  chatroomId: Die Id des Chatrooms
+		//  nachricht: Die Nachricht die gesendet werden soll
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatroomNachricht(int chatroomId, const char* nachricht) override;
+		// verlässt chatroom
+		//  chatroomId: Die Id des Chatrooms
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatroomVerlassen(int chatroomId) override;
+		// kickt Account aus Chatroom (nur wenn als admin des Chatrooms eingeloggt)
+		//  chatroomId: Die Id des Chatrooms
+		//  accountId: Die Id des Accounts
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatroomKick(int chatroomId, int accountId) override;
+		// fragt nach allen freunden
+		//  Die Liste der Freunde kann über getNextMessage empfangen werden
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool freundesListeAnfragen() override;
+		// fragt nach allen chatnachrichten, die gesendet wurden, während der Account in den der Client eingeloggt ist, offline war
+		//  Die einzelnen Nachrichten können über getNextMessage empfangen werden
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool chatNachrichtAnfrage() override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Wartet auf eine Nachricht vom Chatserver.
+		//  Gibt bei Erfolg 1 zurück, 0 sonnst
+		//  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
+		bool getNextMessage(ChatServerNachricht& nachricht) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/EditorClient.cpp

@@ -14,997 +14,997 @@ using namespace KSGClient;
 class DownloadSound : public GSL::GSLSoundV
 {
 private:
-    bool istM;
-    int sample;
-    __int64 län;
-    Network::Klient *k;
-    FBalken *f;
+	bool istM;
+	int sample;
+	__int64 län;
+	Network::Klient* k;
+	FBalken* f;
 
 public:
-    // Konstruktor
-    DownloadSound( Network::Klient *zK, FBalken *zF )
-        : Thread()
-    {
-        k = zK;
-        f = zF;
-    }
-    // nicht constant
-    // GSL
-    void playSound() override
-    {}
-    void setPause( bool p ) override
-    {}
-    void stopSound() override
-    {}
-    void warteAufSound( int zeit ) override
-    {}
-    // Lautstärke: 0 - 0xFFFF
-    void setVolume( unsigned int links, unsigned int rechts ) override
-    {}
-    // zum Speichern
-    void open() override
-    {
-        char m = 0;
-        k->getNachrichtEncrypted( &m, 1 );
-        istM = ( m == 1 );
-        sample = 0;
-        k->getNachrichtEncrypted( (char *)&sample, 4 );
-        län = 0;
-        k->getNachrichtEncrypted( (char *)&län, 8 );
-        if( f )
-            f->setAktionAnzahl( län );
-    }
-    int getDaten( char *buffer, int län ) override
-    {
-        int l = län < this->län ? län : (int)this->län;
-        if( !l )
-            return -1;
-        k->getNachricht( buffer, l );
-        this->län -= l;
-        if( f )
-            f->aktionPlus( l );
-        return l;
-    }
-    void close() override
-    {}
-    bool istMono() const override
-    {
-        return istM;
-    }
-    int getSampleRate() const override
-    {
-        return sample;
-    }
-    __int64 getDatLength() const override
-    {
-        return län;
-    }
+	// Konstruktor
+	DownloadSound(Network::Klient* zK, FBalken* zF)
+		: Thread()
+	{
+		k = zK;
+		f = zF;
+	}
+	// nicht constant
+	// GSL
+	void playSound() override
+	{}
+	void setPause(bool p) override
+	{}
+	void stopSound() override
+	{}
+	void warteAufSound(int zeit) override
+	{}
+	// Lautstärke: 0 - 0xFFFF
+	void setVolume(unsigned int links, unsigned int rechts) override
+	{}
+	// zum Speichern
+	void open() override
+	{
+		char m = 0;
+		k->getNachrichtEncrypted(&m, 1);
+		istM = (m == 1);
+		sample = 0;
+		k->getNachrichtEncrypted((char*)&sample, 4);
+		län = 0;
+		k->getNachrichtEncrypted((char*)&län, 8);
+		if (f)
+			f->setAktionAnzahl(län);
+	}
+	int getDaten(char* buffer, int län) override
+	{
+		int l = län < this->län ? län : (int)this->län;
+		if (!l)
+			return -1;
+		k->getNachricht(buffer, l);
+		this->län -= l;
+		if (f)
+			f->aktionPlus(l);
+		return l;
+	}
+	void close() override
+	{}
+	bool istMono() const override
+	{
+		return istM;
+	}
+	int getSampleRate() const override
+	{
+		return sample;
+	}
+	__int64 getDatLength() const override
+	{
+		return län;
+	}
 };
 
 // Inhalt der KSGClient Klasse
 
 // Konstruktor
-EditorClient::EditorClient( int kId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+EditorClient::EditorClient(int kId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = kId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = kId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 EditorClient::~EditorClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Editor Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool EditorClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::EDITOR, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::EDITOR, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Editor Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Editor Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Editor Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::EDITOR, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::EDITOR, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Editor Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Editor Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Editor Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool EditorClient::karteErstellen( char *name, int spielArt )
+bool EditorClient::karteErstellen(const char* name, int spielArt)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char l = (char)textLength( name );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( name, l );
-        k->sendeEncrypted( (char *)&spielArt, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xA", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char l = (char)textLength(name);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(name, l);
+		k->sendeEncrypted((char*)&spielArt, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // lädt eine bestimmte Karte
 //  id: Die Id der Karte
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::ladeKarte( int id )
+bool EditorClient::ladeKarte(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x6", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x6", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-int EditorClient::getAbbildListe( Framework::RCArray< Framework::Text > *name, Framework::RCArray< Framework::Zeit > *datum )
+int EditorClient::getAbbildListe(Framework::RCArray< Framework::Text >* name, Framework::RCArray< Framework::Zeit >* datum)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x5", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                char l = 0;
-                k->getNachrichtEncrypted( &l, 1 );
-                char *n = new char[ l + 1 ];
-                n[ l ] = 0;
-                k->getNachrichtEncrypted( n, l );
-                name->set( new Text( n ), i );
-                delete[] n;
-                Zeit *dat = new Zeit();
-                int d = 0;
-                k->getNachrichtEncrypted( (char *)&d, 4 );
-                dat->setJahr( d );
-                k->getNachrichtEncrypted( (char *)&d, 4 );
-                dat->setMonat( d );
-                k->getNachrichtEncrypted( (char *)&d, 4 );
-                dat->setTag( d );
-                k->getNachrichtEncrypted( (char *)&d, 4 );
-                dat->setStunde( d );
-                k->getNachrichtEncrypted( (char *)&d, 4 );
-                dat->setMinute( d );
-                k->getNachrichtEncrypted( (char *)&d, 4 );
-                dat->setSekunde( d );
-                datum->set( dat, i );
-            }
-            cs.unlock();
-            return anz;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x5", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				char l = 0;
+				k->getNachrichtEncrypted(&l, 1);
+				char* n = new char[l + 1];
+				n[l] = 0;
+				k->getNachrichtEncrypted(n, l);
+				name->set(new Text(n), i);
+				delete[] n;
+				Zeit* dat = new Zeit();
+				int d = 0;
+				k->getNachrichtEncrypted((char*)&d, 4);
+				dat->setJahr(d);
+				k->getNachrichtEncrypted((char*)&d, 4);
+				dat->setMonat(d);
+				k->getNachrichtEncrypted((char*)&d, 4);
+				dat->setTag(d);
+				k->getNachrichtEncrypted((char*)&d, 4);
+				dat->setStunde(d);
+				k->getNachrichtEncrypted((char*)&d, 4);
+				dat->setMinute(d);
+				k->getNachrichtEncrypted((char*)&d, 4);
+				dat->setSekunde(d);
+				datum->set(dat, i);
+			}
+			cs.unlock();
+			return anz;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erstellt ein neues Abbild der geladenen Karte
 //  name: Der Name des Abbildes
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::abbildErstellen( char *name )
+bool EditorClient::abbildErstellen(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x1", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            char l = (char)textLength( name );
-            k->sendeEncrypted( &l, 1 );
-            if( l )
-                k->sendeEncrypted( name, l );
-            k->getNachrichtEncrypted( &ret, 1 );
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x1", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			char l = (char)textLength(name);
+			k->sendeEncrypted(&l, 1);
+			if (l)
+				k->sendeEncrypted(name, l);
+			k->getNachrichtEncrypted(&ret, 1);
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Löscht ein altes Abbild der geladenen Karte
 //  name: Der Name des Abbildes
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::abbildLöschen( char *name )
+bool EditorClient::abbildLöschen(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x2", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            char l = (char)textLength( name );
-            k->sendeEncrypted( &l, 1 );
-            if( l )
-                k->sendeEncrypted( name, l );
-            k->getNachrichtEncrypted( &ret, 1 );
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x2", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			char l = (char)textLength(name);
+			k->sendeEncrypted(&l, 1);
+			if (l)
+				k->sendeEncrypted(name, l);
+			k->getNachrichtEncrypted(&ret, 1);
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool EditorClient::abbildHerstellen( char *name )
+bool EditorClient::abbildHerstellen(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x3", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            char l = (char)textLength( name );
-            k->sendeEncrypted( &l, 1 );
-            if( l )
-                k->sendeEncrypted( name, l );
-            k->getNachrichtEncrypted( &ret, 1 );
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x3", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			char l = (char)textLength(name);
+			k->sendeEncrypted(&l, 1);
+			if (l)
+				k->sendeEncrypted(name, l);
+			k->getNachrichtEncrypted(&ret, 1);
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Verüffentlich eine neue Version der geladenen Karte
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool EditorClient::veröffentlichen()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x4", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-            k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x4", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+			k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Veröffentlich eine neue Version der Shop Seite der geladenen Karte
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool EditorClient::shopSeiteVeröffentlichen()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x6", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-            k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x6", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+			k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
 bool EditorClient::ladeShopSeiteVorschau()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x8", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            Text pf = "data/tmp/ke/ssv";
-            for( int i = 0; i < anz; i++ )
-            {
-                char l = 0;
-                k->getNachrichtEncrypted( &l, 1 );
-                char *pfad = new char[ l + 1 ];
-                pfad[ l ] = 0;
-                k->getNachrichtEncrypted( pfad, l );
-                Text p = pf.getText();
-                p += pfad;
-                delete[] pfad;
-                Datei d;
-                d.setDatei( p );
-                d.erstellen();
-                d.open( Datei::Style::schreiben );
-                __int64 größe = 0;
-                k->getNachrichtEncrypted( (char *)&größe, 8 );
-                char *buffer = new char[ 2048 ];
-                while( größe > 0 )
-                {
-                    int l = größe > 2048 ? 2048 : (int)größe;
-                    k->getNachricht( buffer, l );
-                    d.schreibe( buffer, l );
-                    größe -= l;
-                }
-                delete[] buffer;
-                d.close();
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x8", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			Text pf = "data/tmp/ke/ssv";
+			for (int i = 0; i < anz; i++)
+			{
+				char l = 0;
+				k->getNachrichtEncrypted(&l, 1);
+				char* pfad = new char[l + 1];
+				pfad[l] = 0;
+				k->getNachrichtEncrypted(pfad, l);
+				Text p = pf.getText();
+				p += pfad;
+				delete[] pfad;
+				Datei d;
+				d.setDatei(p);
+				d.erstellen();
+				d.open(Datei::Style::schreiben);
+				__int64 größe = 0;
+				k->getNachrichtEncrypted((char*)&größe, 8);
+				char* buffer = new char[2048];
+				while (größe > 0)
+				{
+					int l = größe > 2048 ? 2048 : (int)größe;
+					k->getNachricht(buffer, l);
+					d.schreibe(buffer, l);
+					größe -= l;
+				}
+				delete[] buffer;
+				d.close();
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool EditorClient::ssDateiErstellen( char *name, int typ )
+bool EditorClient::ssDateiErstellen(const char* name, int typ)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x1", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char t = typ;
-                k->sendeEncrypted( &t, 1 );
-                char l = (char)textLength( name );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( name, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x1", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char t = typ;
+				k->sendeEncrypted(&t, 1);
+				char l = (char)textLength(name);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(name, l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Öffnet einen Ordner der Shop Seite
 //  name: Der Name des Ordners
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::ssOrdnerÖffnen( char *name )
+bool EditorClient::ssOrdnerÖffnen(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x2", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( name );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( name, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x2", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(name);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(name, l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-Framework::Bild *EditorClient::ssBildLaden( char *datei, char *bild )
+Framework::Bild* EditorClient::ssBildLaden(const char* datei, const char* bild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x3", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( datei );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( datei, l );
-                l = (char)textLength( bild );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( bild, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    Bild *ret = new Bild();
-                    int br = 0;
-                    int hö = 0;
-                    k->getNachrichtEncrypted( (char *)&br, 4 );
-                    k->getNachrichtEncrypted( (char *)&hö, 4 );
-                    ret->neuBild( br, hö, 0 );
-                    char *buffer = (char *)ret->getBuffer();
-                    __int64 län = br * hö * 4;
-                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
-                    {
-                        k->getNachricht( &( buffer[ i ] ), l );
-                        i += l;
-                        län -= l;
-                    }
-                    cs.unlock();
-                    return ret;
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x3", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(datei);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(datei, l);
+				l = (char)textLength(bild);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(bild, l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					Bild* ret = new Bild();
+					int br = 0;
+					int hö = 0;
+					k->getNachrichtEncrypted((char*)&br, 4);
+					k->getNachrichtEncrypted((char*)&hö, 4);
+					ret->neuBild(br, hö, 0);
+					char* buffer = (char*)ret->getBuffer();
+					__int64 län = br * hö * 4;
+					for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
+					{
+						k->getNachricht(&(buffer[i]), l);
+						i += l;
+						län -= l;
+					}
+					cs.unlock();
+					return ret;
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Löscht eine Datei der Shop Seite
 //  name: Der Name der Datei
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::ssDateiLöschen( char *name )
+bool EditorClient::ssDateiLöschen(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x4", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( name );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( name, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x4", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(name);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(name, l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-Framework::Text *EditorClient::ssTextLaden( char *datei )
+Framework::Text* EditorClient::ssTextLaden(const char* datei)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xA", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( datei );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( datei, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int län = 0;
-                    k->getNachrichtEncrypted( (char *)&län, 4 );
-                    char *txt = new char[ län + 1 ];
-                    txt[ län ] = 0;
-                    for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
-                        k->getNachricht( &( txt[ i ] ), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                    if( ret == 1 )
-                    {
-                        Text *t = new Text( txt );
-                        delete[] txt;
-                        cs.unlock();
-                        return t;
-                    }
-                    delete[] txt;
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xA", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(datei);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(datei, l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int län = 0;
+					k->getNachrichtEncrypted((char*)&län, 4);
+					char* txt = new char[län + 1];
+					txt[län] = 0;
+					for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
+						k->getNachricht(&(txt[i]), l);
+					k->getNachrichtEncrypted(&ret, 1);
+					if (ret == 1)
+					{
+						Text* t = new Text(txt);
+						delete[] txt;
+						cs.unlock();
+						return t;
+					}
+					delete[] txt;
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // 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
-bool EditorClient::ssTextSpeichern( char *datei, Framework::Text *zText )
+bool EditorClient::ssTextSpeichern(const char* datei, Framework::Text* zText)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x5", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( datei );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( datei, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int län = zText->getLength();
-                    k->sendeEncrypted( (char *)&län, 4 );
-                    for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
-                        k->sende( &( zText->getText()[ i ] ), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x5", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(datei);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(datei, l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int län = zText->getLength();
+					k->sendeEncrypted((char*)&län, 4);
+					for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
+						k->sende(&(zText->getText()[i]), l);
+					k->getNachrichtEncrypted(&ret, 1);
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool EditorClient::ssBildLöschen( char *datei, char *bild )
+bool EditorClient::ssBildLöschen(const char* datei, const char* bild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x6", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( datei );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( datei, l );
-                l = (char)textLength( bild );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( bild, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x6", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(datei);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(datei, l);
+				l = (char)textLength(bild);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(bild, l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Speichert ein Bild einer ShopSeite
@@ -1012,195 +1012,195 @@ bool EditorClient::ssBildL
 //  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
-bool EditorClient::ssBildSpeichern( char *datei, char *name, Framework::Bild *zBild )
+bool EditorClient::ssBildSpeichern(const char* datei, const char* name, Framework::Bild* zBild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x7", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( datei );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( datei, l );
-                l = (char)textLength( name );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( name, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int br = zBild->getBreite();
-                    int hö = zBild->getHeight();
-                    k->sendeEncrypted( (char *)&br, 4 );
-                    k->sendeEncrypted( (char *)&hö, 4 );
-                    __int64 län = br * hö * 4;
-                    char *buffer = (char *)zBild->getBuffer();
-                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
-                        k->sende( &( buffer[ i ] ), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x7", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(datei);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(datei, l);
+				l = (char)textLength(name);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(name, l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int br = zBild->getBreite();
+					int hö = zBild->getHeight();
+					k->sendeEncrypted((char*)&br, 4);
+					k->sendeEncrypted((char*)&hö, 4);
+					__int64 län = br * hö * 4;
+					char* buffer = (char*)zBild->getBuffer();
+					for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
+						k->sende(&(buffer[i]), l);
+					k->getNachrichtEncrypted(&ret, 1);
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-int EditorClient::ssGetDateiListe( Framework::RCArray< Framework::Text > *zList )
+int EditorClient::ssGetDateiListe(Framework::RCArray< Framework::Text >* zList)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x8", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int anz = 0;
-                k->getNachrichtEncrypted( (char *)&anz, 4 );
-                for( int i = 0; i < anz; i++ )
-                {
-                    char l = 0;
-                    k->getNachrichtEncrypted( &l, 1 );
-                    char *n = new char[ l + 1 ];
-                    n[ l ] = 0;
-                    k->getNachrichtEncrypted( n, l );
-                    zList->add( new Text( n ) );
-                    delete[] n;
-                }
-                cs.unlock();
-                return anz;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return -1;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x8", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int anz = 0;
+				k->getNachrichtEncrypted((char*)&anz, 4);
+				for (int i = 0; i < anz; i++)
+				{
+					char l = 0;
+					k->getNachrichtEncrypted(&l, 1);
+					char* n = new char[l + 1];
+					n[l] = 0;
+					k->getNachrichtEncrypted(n, l);
+					zList->add(new Text(n));
+					delete[] n;
+				}
+				cs.unlock();
+				return anz;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return -1;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-int EditorClient::ssGetBildListe( char *name, Framework::RCArray< Framework::Text > *zList )
+int EditorClient::ssGetBildListe(const char* name, Framework::RCArray< Framework::Text >* zList)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x7", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x9", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)textLength( name );
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( name, l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int anz = 0;
-                    k->getNachrichtEncrypted( (char *)&anz, 4 );
-                    for( int i = 0; i < anz; i++ )
-                    {
-                        l = 0;
-                        k->getNachrichtEncrypted( &l, 1 );
-                        char *n = new char[ l + 1 ];
-                        n[ l ] = 0;
-                        k->getNachrichtEncrypted( n, l );
-                        zList->add( new Text( n ) );
-                        delete[] n;
-                    }
-                    cs.unlock();
-                    return anz;
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return -1;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x7", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x9", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)textLength(name);
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(name, l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int anz = 0;
+					k->getNachrichtEncrypted((char*)&anz, 4);
+					for (int i = 0; i < anz; i++)
+					{
+						l = 0;
+						k->getNachrichtEncrypted(&l, 1);
+						char* n = new char[l + 1];
+						n[l] = 0;
+						k->getNachrichtEncrypted(n, l);
+						zList->add(new Text(n));
+						delete[] n;
+					}
+					cs.unlock();
+					return anz;
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return -1;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Lädt die Shop Daten
@@ -1208,46 +1208,46 @@ int EditorClient::ssGetBildListe( char *name, Framework::RCArray< Framework::Tex
 //  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
-bool EditorClient::getShopDaten( int &es, int &tp, int &vp )
+bool EditorClient::getShopDaten(int& es, int& tp, int& vp)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x9", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->getNachrichtEncrypted( (char *)&es, 4 );
-            k->getNachrichtEncrypted( (char *)&tp, 4 );
-            k->getNachrichtEncrypted( (char *)&vp, 4 );
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x9", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->getNachrichtEncrypted((char*)&es, 4);
+			k->getNachrichtEncrypted((char*)&tp, 4);
+			k->getNachrichtEncrypted((char*)&vp, 4);
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Setzt die Shop Daten
@@ -1255,755 +1255,755 @@ bool EditorClient::getShopDaten( int &es, int &tp, int &vp )
 //  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
-bool EditorClient::setShopDaten( int es, int tp, int vp )
+bool EditorClient::setShopDaten(int es, int tp, int vp)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xA", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( (char *)&es, 4 );
-            k->sendeEncrypted( (char *)&tp, 4 );
-            k->sendeEncrypted( (char *)&vp, 4 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                cs.unlock();
-                return 1;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xA", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted((char*)&es, 4);
+			k->sendeEncrypted((char*)&tp, 4);
+			k->sendeEncrypted((char*)&vp, 4);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				cs.unlock();
+				return 1;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt die Kartenbeschreibung als KSGScript Quellcode zurück
 //  Gibt bei misserfolg 0 zurück
-Framework::Text *EditorClient::beschreibungLaden()
+Framework::Text* EditorClient::beschreibungLaden()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x1", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int län = 0;
-                k->getNachrichtEncrypted( (char *)&län, 4 );
-                char *txt = new char[ län + 1 ];
-                txt[ län ] = 0;
-                for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
-                    k->getNachricht( &( txt[ i ] ), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    Text *t = new Text( txt );
-                    delete[] txt;
-                    cs.unlock();
-                    return t;
-                }
-                delete[] txt;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x1", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int län = 0;
+				k->getNachrichtEncrypted((char*)&län, 4);
+				char* txt = new char[län + 1];
+				txt[län] = 0;
+				for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
+					k->getNachricht(&(txt[i]), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					Text* t = new Text(txt);
+					delete[] txt;
+					cs.unlock();
+					return t;
+				}
+				delete[] txt;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt das Titelbild der Karte zurück
 //  Gibt bei misserfolg 0 zurück
-Framework::Bild *EditorClient::titelbildLaden()
+Framework::Bild* EditorClient::titelbildLaden()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x2", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                Bild *ret = new Bild();
-                int br = 0;
-                int hö = 0;
-                k->getNachrichtEncrypted( (char *)&br, 4 );
-                k->getNachrichtEncrypted( (char *)&hö, 4 );
-                ret->neuBild( br, hö, 0 );
-                char *buffer = (char *)ret->getBuffer();
-                __int64 län = br * hö * 4;
-                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
-                {
-                    k->getNachricht( &( buffer[ i ] ), l );
-                    i += l;
-                    län -= l;
-                }
-                cs.unlock();
-                return ret;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x2", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				Bild* ret = new Bild();
+				int br = 0;
+				int hö = 0;
+				k->getNachrichtEncrypted((char*)&br, 4);
+				k->getNachrichtEncrypted((char*)&hö, 4);
+				ret->neuBild(br, hö, 0);
+				char* buffer = (char*)ret->getBuffer();
+				__int64 län = br * hö * 4;
+				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
+				{
+					k->getNachricht(&(buffer[i]), l);
+					i += l;
+					län -= l;
+				}
+				cs.unlock();
+				return ret;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt das Minimap Bild der Karte zurück
 //  Gibt bei misserfolg 0 zurück
-Framework::Bild *EditorClient::minimapLaden()
+Framework::Bild* EditorClient::minimapLaden()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x3", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                Bild *ret = new Bild();
-                int br = 0;
-                int hö = 0;
-                k->getNachrichtEncrypted( (char *)&br, 4 );
-                k->getNachrichtEncrypted( (char *)&hö, 4 );
-                ret->neuBild( br, hö, 0 );
-                char *buffer = (char *)ret->getBuffer();
-                __int64 län = br * hö * 4;
-                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
-                {
-                    k->getNachricht( &( buffer[ i ] ), l );
-                    i += l;
-                    län -= l;
-                }
-                cs.unlock();
-                return ret;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x3", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				Bild* ret = new Bild();
+				int br = 0;
+				int hö = 0;
+				k->getNachrichtEncrypted((char*)&br, 4);
+				k->getNachrichtEncrypted((char*)&hö, 4);
+				ret->neuBild(br, hö, 0);
+				char* buffer = (char*)ret->getBuffer();
+				__int64 län = br * hö * 4;
+				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
+				{
+					k->getNachricht(&(buffer[i]), l);
+					i += l;
+					län -= l;
+				}
+				cs.unlock();
+				return ret;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt das Ladebild der Karte zurück
 //  Gibt bei misserfolg 0 zurück
-Framework::Bild *EditorClient::ladebildLaden()
+Framework::Bild* EditorClient::ladebildLaden()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x4", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                Bild *ret = new Bild();
-                int br = 0;
-                int hö = 0;
-                k->getNachrichtEncrypted( (char *)&br, 4 );
-                k->getNachrichtEncrypted( (char *)&hö, 4 );
-                ret->neuBild( br, hö, 0 );
-                char *buffer = (char *)ret->getBuffer();
-                __int64 län = br * hö * 4;
-                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
-                {
-                    k->getNachricht( &( buffer[ i ] ), l );
-                    i += l;
-                    län -= l;
-                }
-                cs.unlock();
-                return ret;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x4", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				Bild* ret = new Bild();
+				int br = 0;
+				int hö = 0;
+				k->getNachrichtEncrypted((char*)&br, 4);
+				k->getNachrichtEncrypted((char*)&hö, 4);
+				ret->neuBild(br, hö, 0);
+				char* buffer = (char*)ret->getBuffer();
+				__int64 län = br * hö * 4;
+				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
+				{
+					k->getNachricht(&(buffer[i]), l);
+					i += l;
+					län -= l;
+				}
+				cs.unlock();
+				return ret;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // 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
-bool EditorClient::beschreibungSpeichern( Framework::Text *zText )
+bool EditorClient::beschreibungSpeichern(Framework::Text* zText)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x5", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int län = zText->getLength();
-                k->sendeEncrypted( (char *)&län, 4 );
-                for( int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län )
-                    k->sende( &( zText->getText()[ i ] ), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x5", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int län = zText->getLength();
+				k->sendeEncrypted((char*)&län, 4);
+				for (int i = 0, l = län > 2048 ? 2048 : län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : län)
+					k->sende(&(zText->getText()[i]), l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // speichert das Titelbild der Karte
 //  zBild: das neue Titelbild
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::titelbildSpeichern( Framework::Bild *zBild )
+bool EditorClient::titelbildSpeichern(Framework::Bild* zBild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x6", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int br = zBild->getBreite();
-                int hö = zBild->getHeight();
-                k->sendeEncrypted( (char *)&br, 4 );
-                k->sendeEncrypted( (char *)&hö, 4 );
-                __int64 län = br * hö * 4;
-                char *buffer = (char *)zBild->getBuffer();
-                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
-                    k->sende( &( buffer[ i ] ), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x6", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int br = zBild->getBreite();
+				int hö = zBild->getHeight();
+				k->sendeEncrypted((char*)&br, 4);
+				k->sendeEncrypted((char*)&hö, 4);
+				__int64 län = br * hö * 4;
+				char* buffer = (char*)zBild->getBuffer();
+				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
+					k->sende(&(buffer[i]), l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // speichert das Minimapbild der Karte
 //  zBild: das neue Minimapbild
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::minimapSpeichern( Framework::Bild *zBild )
+bool EditorClient::minimapSpeichern(Framework::Bild* zBild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x7", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int br = zBild->getBreite();
-                int hö = zBild->getHeight();
-                k->sendeEncrypted( (char *)&br, 4 );
-                k->sendeEncrypted( (char *)&hö, 4 );
-                __int64 län = br * hö * 4;
-                char *buffer = (char *)zBild->getBuffer();
-                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
-                    k->sende( &( buffer[ i ] ), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x7", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int br = zBild->getBreite();
+				int hö = zBild->getHeight();
+				k->sendeEncrypted((char*)&br, 4);
+				k->sendeEncrypted((char*)&hö, 4);
+				__int64 län = br * hö * 4;
+				char* buffer = (char*)zBild->getBuffer();
+				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
+					k->sende(&(buffer[i]), l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // speichert das Ladebild der Karte
 //  zBild: das neue Ladebild
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::ladebildSpeichern( Framework::Bild *zBild )
+bool EditorClient::ladebildSpeichern(Framework::Bild* zBild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xB", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x8", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int br = zBild->getBreite();
-                int hö = zBild->getHeight();
-                k->sendeEncrypted( (char *)&br, 4 );
-                k->sendeEncrypted( (char *)&hö, 4 );
-                __int64 län = br * hö * 4;
-                char *buffer = (char *)zBild->getBuffer();
-                for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län )
-                    k->sende( &( buffer[ i ] ), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xB", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x8", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int br = zBild->getBreite();
+				int hö = zBild->getHeight();
+				k->sendeEncrypted((char*)&br, 4);
+				k->sendeEncrypted((char*)&hö, 4);
+				__int64 län = br * hö * 4;
+				char* buffer = (char*)zBild->getBuffer();
+				for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; i += l, län -= l, l = län > 2048 ? 2048 : (int)län)
+					k->sende(&(buffer[i]), l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool EditorClient::ladeTeamDaten( SpielerTeamStrukturV *sts )
+bool EditorClient::ladeTeamDaten(SpielerTeamStrukturV* sts)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xC", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x1", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                k->getNachrichtEncrypted( (char *)&sts->spielerAnzahl, 4 );
-                k->getNachrichtEncrypted( (char *)&sts->teamAnzahl, 4 );
-                for( int i = 0; i < sts->spielerAnzahl; i++ )
-                {
-                    int f = 0;
-                    k->getNachrichtEncrypted( (char *)&f, 4 );
-                    sts->spielerFarbe->set( f, i );
-                }
-                for( int i = 0; i < sts->teamAnzahl; i++ )
-                {
-                    int f = 0;
-                    k->getNachrichtEncrypted( (char *)&f, 4 );
-                    sts->teamFarbe->set( f, i );
-                }
-                for( int i = 0; i < sts->teamAnzahl; i++ )
-                {
-                    char l = 0;
-                    k->getNachrichtEncrypted( &l, 1 );
-                    char *n = new char[ l + 1 ];
-                    n[ l ] = 0;
-                    k->getNachrichtEncrypted( n, l );
-                    sts->teamName->set( new Text( n ), i );
-                    delete[] n;
-                }
-                for( int i = 0; i < sts->teamAnzahl; i++ )
-                {
-                    int g = 0;
-                    k->getNachrichtEncrypted( (char *)&g, 4 );
-                    sts->teamSize->set( g, i );
-                }
-                cs.unlock();
-                return 1;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xC", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x1", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				k->getNachrichtEncrypted((char*)&sts->spielerAnzahl, 4);
+				k->getNachrichtEncrypted((char*)&sts->teamAnzahl, 4);
+				for (int i = 0; i < sts->spielerAnzahl; i++)
+				{
+					int f = 0;
+					k->getNachrichtEncrypted((char*)&f, 4);
+					sts->spielerFarbe->set(f, i);
+				}
+				for (int i = 0; i < sts->teamAnzahl; i++)
+				{
+					int f = 0;
+					k->getNachrichtEncrypted((char*)&f, 4);
+					sts->teamFarbe->set(f, i);
+				}
+				for (int i = 0; i < sts->teamAnzahl; i++)
+				{
+					char l = 0;
+					k->getNachrichtEncrypted(&l, 1);
+					char* n = new char[l + 1];
+					n[l] = 0;
+					k->getNachrichtEncrypted(n, l);
+					sts->teamName->set(new Text(n), i);
+					delete[] n;
+				}
+				for (int i = 0; i < sts->teamAnzahl; i++)
+				{
+					int g = 0;
+					k->getNachrichtEncrypted((char*)&g, 4);
+					sts->teamSize->set(g, i);
+				}
+				cs.unlock();
+				return 1;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // speichert die Team Daten
 //  sts: die neuen Spieler Team Daten
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::speicherTeamDaten( SpielerTeamStrukturV *sts )
+bool EditorClient::speicherTeamDaten(SpielerTeamStrukturV* sts)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xC", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x2", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                k->sendeEncrypted( (char *)&sts->spielerAnzahl, 4 );
-                k->sendeEncrypted( (char *)&sts->teamAnzahl, 4 );
-                for( int i = 0; i < sts->spielerAnzahl; i++ )
-                {
-                    int f = sts->spielerFarbe->get( i );
-                    k->sendeEncrypted( (char *)&f, 4 );
-                }
-                for( int i = 0; i < sts->teamAnzahl; i++ )
-                {
-                    int f = sts->teamFarbe->get( i );
-                    k->sendeEncrypted( (char *)&f, 4 );
-                }
-                for( int i = 0; i < sts->teamAnzahl; i++ )
-                {
-                    char l = (char)sts->teamName->z( i )->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( sts->teamName->z( i )->getText(), l );
-                }
-                for( int i = 0; i < sts->teamAnzahl; i++ )
-                {
-                    int g = sts->teamSize->get( i );
-                    k->sendeEncrypted( (char *)&g, 4 );
-                }
-                cs.unlock();
-                return 1;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xC", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x2", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				k->sendeEncrypted((char*)&sts->spielerAnzahl, 4);
+				k->sendeEncrypted((char*)&sts->teamAnzahl, 4);
+				for (int i = 0; i < sts->spielerAnzahl; i++)
+				{
+					int f = sts->spielerFarbe->get(i);
+					k->sendeEncrypted((char*)&f, 4);
+				}
+				for (int i = 0; i < sts->teamAnzahl; i++)
+				{
+					int f = sts->teamFarbe->get(i);
+					k->sendeEncrypted((char*)&f, 4);
+				}
+				for (int i = 0; i < sts->teamAnzahl; i++)
+				{
+					char l = (char)sts->teamName->z(i)->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(sts->teamName->z(i)->getText(), l);
+				}
+				for (int i = 0; i < sts->teamAnzahl; i++)
+				{
+					int g = sts->teamSize->get(i);
+					k->sendeEncrypted((char*)&g, 4);
+				}
+				cs.unlock();
+				return 1;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // 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
-bool EditorClient::deNeueDatei( char typ, Framework::Text *zName )
+bool EditorClient::deNeueDatei(char typ, Framework::Text* zName)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x1", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                k->sendeEncrypted( &typ, 1 );
-                char l = (char)zName->getLength();
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( zName->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x1", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				k->sendeEncrypted(&typ, 1);
+				char l = (char)zName->getLength();
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(zName->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Öffnet Ordner im Datei Editor
 //  zName: Der Name des Ordners
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::deOrdnerÖffnen( Framework::Text *zName )
+bool EditorClient::deOrdnerÖffnen(Framework::Text* zName)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x2", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char län = (char)zName->getLength();
-                k->sendeEncrypted( &län, 1 );
-                if( län )
-                    k->sendeEncrypted( zName->getText(), län );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x2", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char län = (char)zName->getLength();
+				k->sendeEncrypted(&län, 1);
+				if (län)
+					k->sendeEncrypted(zName->getText(), län);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Gibt ein Bild aus dem Datei Editor zurück
@@ -2011,187 +2011,187 @@ bool EditorClient::deOrdner
 //  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
-Framework::Bild *EditorClient::deBildLaden( Framework::Text *zDatei, Framework::Text *zBild, Framework::FBalken *zF )
+Framework::Bild* EditorClient::deBildLaden(Framework::Text* zDatei, Framework::Text* zBild, Framework::FBalken* zF)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    Bild *retB = 0;
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x3", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char län = (char)zDatei->getLength();
-                k->sendeEncrypted( &län, 1 );
-                if( län )
-                    k->sendeEncrypted( zDatei->getText(), län );
-                län = (char)zBild->getLength();
-                k->sendeEncrypted( &län, 1 );
-                if( län )
-                    k->sendeEncrypted( zBild->getText(), län );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int br = 0;
-                    int hö = 0;
-                    k->getNachrichtEncrypted( (char *)&br, 4 );
-                    k->getNachrichtEncrypted( (char *)&hö, 4 );
-                    retB = new Bild();
-                    retB->neuBild( br, hö, 0 );
-                    char *buffer = (char *)retB->getBuffer();
-                    __int64 län = br * hö * 4;
-                    if( zF )
-                        zF->setAktionAnzahl( län );
-                    for( int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län )
-                    {
-                        k->getNachricht( &( buffer[ i ] ), l );
-                        i += l;
-                        län -= l;
-                        if( zF )
-                            zF->aktionPlus( l );
-                    }
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    if( !ret && retB )
-        retB = (Bild *)retB->release();
-    if( !retB )
-        err = "Unbekannter Fehler";
-    return retB;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	Bild* retB = 0;
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x3", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char län = (char)zDatei->getLength();
+				k->sendeEncrypted(&län, 1);
+				if (län)
+					k->sendeEncrypted(zDatei->getText(), län);
+				län = (char)zBild->getLength();
+				k->sendeEncrypted(&län, 1);
+				if (län)
+					k->sendeEncrypted(zBild->getText(), län);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int br = 0;
+					int hö = 0;
+					k->getNachrichtEncrypted((char*)&br, 4);
+					k->getNachrichtEncrypted((char*)&hö, 4);
+					retB = new Bild();
+					retB->neuBild(br, hö, 0);
+					char* buffer = (char*)retB->getBuffer();
+					__int64 län = br * hö * 4;
+					if (zF)
+						zF->setAktionAnzahl(län);
+					for (int i = 0, l = län > 2048 ? 2048 : (int)län; län > 0; l = län > 2048 ? 2048 : (int)län)
+					{
+						k->getNachricht(&(buffer[i]), l);
+						i += l;
+						län -= l;
+						if (zF)
+							zF->aktionPlus(l);
+					}
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	if (!ret && retB)
+		retB = (Bild*)retB->release();
+	if (!retB)
+		err = "Unbekannter Fehler";
+	return retB;
 }
 
 // Löscht eine Datei aus dem Datei Editor
 //  zName: Der Name der Datei
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool EditorClient::deDateiLöschen( Framework::Text *zName )
+bool EditorClient::deDateiLöschen(Framework::Text* zName)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x4", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char län = (char)zName->getLength();
-                k->sendeEncrypted( &län, 1 );
-                if( län )
-                    k->sendeEncrypted( zName->getText(), län );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x4", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char län = (char)zName->getLength();
+				k->sendeEncrypted(&län, 1);
+				if (län)
+					k->sendeEncrypted(zName->getText(), län);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool EditorClient::deBildLöschen( Framework::Text *zDatei, Framework::Text *zBild )
+bool EditorClient::deBildLöschen(Framework::Text* zDatei, Framework::Text* zBild)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x5", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( zDatei->getText(), l );
-                l = (char)zBild->getLength();
-                k->sendeEncrypted( &l, 1 );
-                if( l )
-                    k->sendeEncrypted( zBild->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x5", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(zDatei->getText(), l);
+				l = (char)zBild->getLength();
+				k->sendeEncrypted(&l, 1);
+				if (l)
+					k->sendeEncrypted(zBild->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Speichert Bild in Datei im Datei Editor
@@ -2200,495 +2200,495 @@ bool EditorClient::deBildL
 //  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
-bool EditorClient::deBildSpeichern( Framework::Text *zDatei, Framework::Text *zName, Framework::Bild *zBild, Framework::FBalken *zF )
+bool EditorClient::deBildSpeichern(Framework::Text* zDatei, Framework::Text* zName, Framework::Bild* zBild, Framework::FBalken* zF)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x6", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char län = (char)zDatei->getLength();
-                k->sendeEncrypted( &län, 1 );
-                if( län )
-                    k->sendeEncrypted( zDatei->getText(), län );
-                län = (char)zName->getLength();
-                k->sendeEncrypted( &län, 1 );
-                if( län )
-                    k->sendeEncrypted( zName->getText(), län );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int br = zBild->getBreite();
-                    int hö = zBild->getHeight();
-                    k->sendeEncrypted( (char *)&br, 4 );
-                    k->sendeEncrypted( (char *)&hö, 4 );
-                    char *buffer = (char *)zBild->getBuffer();
-                    __int64 gr = br * hö * 4;
-                    if( zF )
-                        zF->setAktionAnzahl( gr );
-                    for( int i = 0, l = gr > 2048 ? 2048 : (int)gr; gr > 0; i += l, gr -= l, l = gr > 2048 ? 2048 : (int)gr )
-                    {
-                        k->sende( &( buffer[ i ] ), l );
-                        if( zF )
-                            zF->aktionPlus( l );
-                    }
-                    k->getNachrichtEncrypted( &ret, 1 );
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x6", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char län = (char)zDatei->getLength();
+				k->sendeEncrypted(&län, 1);
+				if (län)
+					k->sendeEncrypted(zDatei->getText(), län);
+				län = (char)zName->getLength();
+				k->sendeEncrypted(&län, 1);
+				if (län)
+					k->sendeEncrypted(zName->getText(), län);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int br = zBild->getBreite();
+					int hö = zBild->getHeight();
+					k->sendeEncrypted((char*)&br, 4);
+					k->sendeEncrypted((char*)&hö, 4);
+					char* buffer = (char*)zBild->getBuffer();
+					__int64 gr = br * hö * 4;
+					if (zF)
+						zF->setAktionAnzahl(gr);
+					for (int i = 0, l = gr > 2048 ? 2048 : (int)gr; gr > 0; i += l, gr -= l, l = gr > 2048 ? 2048 : (int)gr)
+					{
+						k->sende(&(buffer[i]), l);
+						if (zF)
+							zF->aktionPlus(l);
+					}
+					k->getNachrichtEncrypted(&ret, 1);
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-int EditorClient::deGetDateiListe( Framework::RCArray< Framework::Text > *zNamen )
+int EditorClient::deGetDateiListe(Framework::RCArray< Framework::Text >* zNamen)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x7", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                int anz = 0;
-                k->getNachrichtEncrypted( (char *)&anz, 4 );
-                for( int i = 0; i < anz; i++ )
-                {
-                    char l = 0;
-                    k->getNachrichtEncrypted( &l, 1 );
-                    char *n = new char[ l + 1 ];
-                    n[ l ] = 0;
-                    if( l )
-                        k->getNachrichtEncrypted( n, l );
-                    zNamen->add( new Text( n ) );
-                    delete[] n;
-                }
-                cs.unlock();
-                return anz;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return -1;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x7", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				int anz = 0;
+				k->getNachrichtEncrypted((char*)&anz, 4);
+				for (int i = 0; i < anz; i++)
+				{
+					char l = 0;
+					k->getNachrichtEncrypted(&l, 1);
+					char* n = new char[l + 1];
+					n[l] = 0;
+					if (l)
+						k->getNachrichtEncrypted(n, l);
+					zNamen->add(new Text(n));
+					delete[] n;
+				}
+				cs.unlock();
+				return anz;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return -1;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-int EditorClient::deGetBildListe( Framework::Text *zDatei, Framework::RCArray< Framework::Text > *zNamen )
+int EditorClient::deGetBildListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x8", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int anz = 0;
-                    k->getNachrichtEncrypted( (char *)&anz, 4 );
-                    for( int i = 0; i < anz; i++ )
-                    {
-                        k->getNachrichtEncrypted( &l, 1 );
-                        char *n = new char[ l + 1 ];
-                        n[ l ] = 0;
-                        if( l )
-                            k->getNachrichtEncrypted( n, l );
-                        zNamen->add( new Text( n ) );
-                        delete[] n;
-                    }
-                    cs.unlock();
-                    return anz;
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x8", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int anz = 0;
+					k->getNachrichtEncrypted((char*)&anz, 4);
+					for (int i = 0; i < anz; i++)
+					{
+						k->getNachrichtEncrypted(&l, 1);
+						char* n = new char[l + 1];
+						n[l] = 0;
+						if (l)
+							k->getNachrichtEncrypted(n, l);
+						zNamen->add(new Text(n));
+						delete[] n;
+					}
+					cs.unlock();
+					return anz;
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-int EditorClient::deGetModelListe( Framework::Text *zDatei, Framework::RCArray< Framework::Text > *zNamen )
+int EditorClient::deGetModelListe(Framework::Text* zDatei, Framework::RCArray< Framework::Text >* zNamen)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x9", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int anz = 0;
-                    k->getNachrichtEncrypted( (char *)&anz, 4 );
-                    for( int i = 0; i < anz; i++ )
-                    {
-                        k->getNachrichtEncrypted( &l, 1 );
-                        char *n = new char[ l + 1 ];
-                        n[ l ] = 0;
-                        if( l )
-                            k->getNachrichtEncrypted( n, l );
-                        zNamen->add( new Text( n ) );
-                        delete[] n;
-                    }
-                    cs.unlock();
-                    return anz;
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x9", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int anz = 0;
+					k->getNachrichtEncrypted((char*)&anz, 4);
+					for (int i = 0; i < anz; i++)
+					{
+						k->getNachrichtEncrypted(&l, 1);
+						char* n = new char[l + 1];
+						n[l] = 0;
+						if (l)
+							k->getNachrichtEncrypted(n, l);
+						zNamen->add(new Text(n));
+						delete[] n;
+					}
+					cs.unlock();
+					return anz;
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-int EditorClient::deGetSoundListe( Framework::Text *zDatei, Framework::RCArray<  Framework::Text > *zNamen )
+int EditorClient::deGetSoundListe(Framework::Text* zDatei, Framework::RCArray<  Framework::Text >* zNamen)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xA", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    int anz = 0;
-                    k->getNachrichtEncrypted( (char *)&anz, 4 );
-                    for( int i = 0; i < anz; i++ )
-                    {
-                        k->getNachrichtEncrypted( &l, 1 );
-                        char *n = new char[ l + 1 ];
-                        n[ l ] = 0;
-                        if( l )
-                            k->getNachrichtEncrypted( n, l );
-                        zNamen->add( new Text( n ) );
-                        delete[] n;
-                    }
-                    cs.unlock();
-                    return anz;
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xA", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					int anz = 0;
+					k->getNachrichtEncrypted((char*)&anz, 4);
+					for (int i = 0; i < anz; i++)
+					{
+						k->getNachrichtEncrypted(&l, 1);
+						char* n = new char[l + 1];
+						n[l] = 0;
+						if (l)
+							k->getNachrichtEncrypted(n, l);
+						zNamen->add(new Text(n));
+						delete[] n;
+					}
+					cs.unlock();
+					return anz;
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool EditorClient::deModelLöschen( Framework::Text *zDatei, Framework::Text *zModel )
+bool EditorClient::deModelLöschen(Framework::Text* zDatei, Framework::Text* zModel)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xB", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    l = (char)zModel->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( zModel->getText(), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xB", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					l = (char)zModel->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(zModel->getText(), l);
+					k->getNachrichtEncrypted(&ret, 1);
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool EditorClient::deSoundLöschen( Framework::Text *zDatei, Framework::Text *zSound )
+bool EditorClient::deSoundLöschen(Framework::Text* zDatei, Framework::Text* zSound)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xC", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    l = (char)zSound->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( zSound->getText(), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xC", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					l = (char)zSound->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(zSound->getText(), l);
+					k->getNachrichtEncrypted(&ret, 1);
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Setzt das arbeitsverzeichnis auf den obersten ordner
 bool EditorClient::deResetPath()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x11", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x11", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Lädt ein Model aus einer Modeldatei des Datei Editors
@@ -2696,102 +2696,102 @@ bool EditorClient::deResetPath()
 //  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
-Framework::Model2DData *EditorClient::deModelLaden( Framework::Text *zDatei, Framework::Text *zModel, Framework::FBalken *zF )
+Framework::Model2DData* EditorClient::deModelLaden(Framework::Text* zDatei, Framework::Text* zModel, Framework::FBalken* zF)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xD", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    l = (char)zModel->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( zModel->getText(), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                    if( ret == 1 )
-                    {
-                        int anz = 0;
-                        k->getNachrichtEncrypted( (char *)&anz, 4 );
-                        if( zF )
-                            zF->setAktionAnzahl( anz );
-                        Array< Polygon2D > *pol = new Array< Polygon2D >();
-                        for( int i = 0; i < anz; i++ )
-                        {
-                            Polygon2D p;
-                            p.schwerpunkt = new Vertex( 0, 0 );
-                            p.vertex = new Array< Vertex >();
-                            p.tKordinaten = new Array< Vertex >();
-                            k->getNachrichtEncrypted( (char *)&p.transparent, 1 );
-                            char nLän = 0;
-                            k->getNachrichtEncrypted( &nLän, 1 );
-                            char *txt = new char[ nLän + 1 ];
-                            if( nLän )
-                                k->getNachrichtEncrypted( txt, nLän );
-                            txt[ nLän ] = 0;
-                            p.name = new Text( txt );
-                            delete[] txt;
-                            int anz2 = 0;
-                            k->getNachrichtEncrypted( (char *)&anz2, 4 );
-                            for( int j = 0; j < anz2; j++ )
-                            {
-                                Vertex v;
-                                k->getNachrichtEncrypted( (char *)&v.x, 4 );
-                                k->getNachrichtEncrypted( (char *)&v.y, 4 );
-                                *p.schwerpunkt += v * (float)( 1.0 / anz2 );
-                                Vertex t;
-                                k->getNachrichtEncrypted( (char *)&t.x, 4 );
-                                k->getNachrichtEncrypted( (char *)&t.y, 4 );
-                                p.vertex->add( v );
-                                p.tKordinaten->add( t );
-                            }
-                            pol->add( p );
-                            if( zF )
-                                zF->aktionPlus();
-                        }
-                        Model2DData *data = new Model2DData();
-                        data->erstelleModell( pol );
-                        cs.unlock();
-                        return data;
-                    }
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xD", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					l = (char)zModel->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(zModel->getText(), l);
+					k->getNachrichtEncrypted(&ret, 1);
+					if (ret == 1)
+					{
+						int anz = 0;
+						k->getNachrichtEncrypted((char*)&anz, 4);
+						if (zF)
+							zF->setAktionAnzahl(anz);
+						Array< Polygon2D >* pol = new Array< Polygon2D >();
+						for (int i = 0; i < anz; i++)
+						{
+							Polygon2D p;
+							p.schwerpunkt = new Vertex(0, 0);
+							p.vertex = new Array< Vertex >();
+							p.tKordinaten = new Array< Vertex >();
+							k->getNachrichtEncrypted((char*)&p.transparent, 1);
+							char nLän = 0;
+							k->getNachrichtEncrypted(&nLän, 1);
+							char* txt = new char[nLän + 1];
+							if (nLän)
+								k->getNachrichtEncrypted(txt, nLän);
+							txt[nLän] = 0;
+							p.name = new Text(txt);
+							delete[] txt;
+							int anz2 = 0;
+							k->getNachrichtEncrypted((char*)&anz2, 4);
+							for (int j = 0; j < anz2; j++)
+							{
+								Vertex v;
+								k->getNachrichtEncrypted((char*)&v.x, 4);
+								k->getNachrichtEncrypted((char*)&v.y, 4);
+								*p.schwerpunkt += v * (float)(1.0 / anz2);
+								Vertex t;
+								k->getNachrichtEncrypted((char*)&t.x, 4);
+								k->getNachrichtEncrypted((char*)&t.y, 4);
+								p.vertex->add(v);
+								p.tKordinaten->add(t);
+							}
+							pol->add(p);
+							if (zF)
+								zF->aktionPlus();
+						}
+						Model2DData* data = new Model2DData();
+						data->erstelleModell(pol);
+						cs.unlock();
+						return data;
+					}
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Lädt einen Sound herunter und gibt ihn zurück
@@ -2800,69 +2800,69 @@ Framework::Model2DData *EditorClient::deModelLaden( Framework::Text *zDatei, Fra
 //  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
-GSL::GSLSoundV *EditorClient::deSoundLaden( GSL::GSLDateiV *file, Framework::Text *zDatei, Framework::Text *zSound, Framework::FBalken *zF )
+GSL::GSLSoundV* EditorClient::deSoundLaden(GSL::GSLDateiV* file, Framework::Text* zDatei, Framework::Text* zSound, Framework::FBalken* zF)
 {
-    file->setDatei( (char *)"data/tmp/editor/dateien/sounds/tmp.gsl" );
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        file->release();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xE", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    l = (char)zSound->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( zSound->getText(), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                    if( ret == 1 )
-                    {
-                        DownloadSound dws( k, zF );
-                        file->speicherSound( &dws, zSound->getText() );
-                        GSL::GSLSoundV *s = file->getSound( zSound->getText() );
-                        file->release();
-                        cs.unlock();
-                        return s;
-                    }
-                }
-            }
-        }
-    }
-    file->release();
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	file->setDatei((char*)"data/tmp/editor/dateien/sounds/tmp.gsl");
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		file->release();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xE", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					l = (char)zSound->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(zSound->getText(), l);
+					k->getNachrichtEncrypted(&ret, 1);
+					if (ret == 1)
+					{
+						DownloadSound dws(k, zF);
+						file->speicherSound(&dws, zSound->getText());
+						GSL::GSLSoundV* s = file->getSound(zSound->getText());
+						file->release();
+						cs.unlock();
+						return s;
+					}
+				}
+			}
+		}
+	}
+	file->release();
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Speichert ein Model in eine Modeldatei des Datei Editors
@@ -2871,90 +2871,90 @@ GSL::GSLSoundV *EditorClient::deSoundLaden( GSL::GSLDateiV *file, Framework::Tex
 //  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
-bool EditorClient::deModelSpeichern( Framework::Text *zDatei, Framework::Text *zModel, Framework::Model2DData *zData, Framework::FBalken *zF )
+bool EditorClient::deModelSpeichern(Framework::Text* zDatei, Framework::Text* zModel, Framework::Model2DData* zData, Framework::FBalken* zF)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\xF", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    l = (char)zModel->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( zModel->getText(), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                    if( ret == 1 )
-                    {
-                        int anz = zData->polygons ? zData->polygons->getEintragAnzahl() : 0;
-                        if( zF )
-                            zF->setAktionAnzahl( anz );
-                        k->sendeEncrypted( (char *)&anz, 4 );
-                        for( int i = 0; i < anz; i++ )
-                        {
-                            Polygon2D pol = zData->polygons->get( i );
-                            k->sendeEncrypted( (char *)&pol.transparent, 1 );
-                            char nLän = pol.name->getLength();
-                            k->sendeEncrypted( &nLän, 1 );
-                            if( nLän )
-                                k->sendeEncrypted( pol.name->getText(), nLän );
-                            int anz2 = pol.vertex->getEintragAnzahl();
-                            k->sendeEncrypted( (char *)&anz2, 4 );
-                            for( int j = 0; j < anz2; j++ )
-                            {
-                                Vertex v = pol.vertex->get( j );
-                                Vertex p;
-                                if( pol.tKordinaten )
-                                    p = pol.tKordinaten->hat( j ) ? pol.tKordinaten->get( j ) : Vertex( 0, 0 );
-                                k->sendeEncrypted( (char *)&v.x, 4 );
-                                k->sendeEncrypted( (char *)&v.y, 4 );
-                                k->sendeEncrypted( (char *)&p.x, 4 );
-                                k->sendeEncrypted( (char *)&p.y, 4 );
-                            }
-                            if( zF )
-                                zF->aktionPlus();
-                        }
-                        k->getNachrichtEncrypted( &ret, 1 );
-                    }
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\xF", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					l = (char)zModel->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(zModel->getText(), l);
+					k->getNachrichtEncrypted(&ret, 1);
+					if (ret == 1)
+					{
+						int anz = zData->polygons ? zData->polygons->getEintragAnzahl() : 0;
+						if (zF)
+							zF->setAktionAnzahl(anz);
+						k->sendeEncrypted((char*)&anz, 4);
+						for (int i = 0; i < anz; i++)
+						{
+							Polygon2D pol = zData->polygons->get(i);
+							k->sendeEncrypted((char*)&pol.transparent, 1);
+							char nLän = pol.name->getLength();
+							k->sendeEncrypted(&nLän, 1);
+							if (nLän)
+								k->sendeEncrypted(pol.name->getText(), nLän);
+							int anz2 = pol.vertex->getEintragAnzahl();
+							k->sendeEncrypted((char*)&anz2, 4);
+							for (int j = 0; j < anz2; j++)
+							{
+								Vertex v = pol.vertex->get(j);
+								Vertex p;
+								if (pol.tKordinaten)
+									p = pol.tKordinaten->hat(j) ? pol.tKordinaten->get(j) : Vertex(0, 0);
+								k->sendeEncrypted((char*)&v.x, 4);
+								k->sendeEncrypted((char*)&v.y, 4);
+								k->sendeEncrypted((char*)&p.x, 4);
+								k->sendeEncrypted((char*)&p.y, 4);
+							}
+							if (zF)
+								zF->aktionPlus();
+						}
+						k->getNachrichtEncrypted(&ret, 1);
+					}
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Speichert einen Sound in einer Sounddatei des Datei Editors
@@ -2963,82 +2963,82 @@ bool EditorClient::deModelSpeichern( Framework::Text *zDatei, Framework::Text *z
 //  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
-bool EditorClient::deSoundSpeichern( Framework::Text *zDatei, Framework::Text *zSound, GSL::GSLSoundV *zData, Framework::FBalken *zF )
+bool EditorClient::deSoundSpeichern(Framework::Text* zDatei, Framework::Text* zSound, GSL::GSLSoundV* zData, Framework::FBalken* zF)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xD", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->sendeEncrypted( "\x10", 1 );
-            k->getNachrichtEncrypted( &ret, 1 );
-            if( ret == 1 )
-            {
-                char l = (char)zDatei->getLength();
-                k->sendeEncrypted( &l, 1 );
-                k->sendeEncrypted( zDatei->getText(), l );
-                k->getNachrichtEncrypted( &ret, 1 );
-                if( ret == 1 )
-                {
-                    l = (char)zSound->getLength();
-                    k->sendeEncrypted( &l, 1 );
-                    k->sendeEncrypted( zSound->getText(), l );
-                    k->getNachrichtEncrypted( &ret, 1 );
-                    if( ret == 1 )
-                    {
-                        char channels = zData->istMono() ? 1 : 2;
-                        k->sendeEncrypted( &channels, 1 );
-                        int sample = zData->getSampleRate();
-                        k->sendeEncrypted( (char *)&sample, 4 );
-                        __int64 slän = zData->getDatLength();
-                        k->sendeEncrypted( (char *)&slän, 8 );
-                        if( zF )
-                            zF->setAktionAnzahl( slän );
-                        zData->open();
-                        char *buffer = new char[ 2048 ];
-                        while( slän > 0 )
-                        {
-                            int l = slän > 2048 ? 2048 : (int)slän;
-                            zData->getDaten( buffer, l );
-                            k->sende( buffer, l );
-                            slän -= l;
-                            if( zF )
-                                zF->aktionPlus( l );
-                        }
-                        delete[] buffer;
-                        zData->close();
-                    }
-                }
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xD", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->sendeEncrypted("\x10", 1);
+			k->getNachrichtEncrypted(&ret, 1);
+			if (ret == 1)
+			{
+				char l = (char)zDatei->getLength();
+				k->sendeEncrypted(&l, 1);
+				k->sendeEncrypted(zDatei->getText(), l);
+				k->getNachrichtEncrypted(&ret, 1);
+				if (ret == 1)
+				{
+					l = (char)zSound->getLength();
+					k->sendeEncrypted(&l, 1);
+					k->sendeEncrypted(zSound->getText(), l);
+					k->getNachrichtEncrypted(&ret, 1);
+					if (ret == 1)
+					{
+						char channels = zData->istMono() ? 1 : 2;
+						k->sendeEncrypted(&channels, 1);
+						int sample = zData->getSampleRate();
+						k->sendeEncrypted((char*)&sample, 4);
+						__int64 slän = zData->getDatLength();
+						k->sendeEncrypted((char*)&slän, 8);
+						if (zF)
+							zF->setAktionAnzahl(slän);
+						zData->open();
+						char* buffer = new char[2048];
+						while (slän > 0)
+						{
+							int l = slän > 2048 ? 2048 : (int)slän;
+							zData->getDaten(buffer, l);
+							k->sende(buffer, l);
+							slän -= l;
+							if (zF)
+								zF->aktionPlus(l);
+						}
+						delete[] buffer;
+						zData->close();
+					}
+				}
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Lädt die Kauf Statistik der geladenen Karte
@@ -3046,96 +3046,96 @@ bool EditorClient::deSoundSpeichern( Framework::Text *zDatei, Framework::Text *z
 //  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
-int EditorClient::getVerkaufStatistik( Framework::Array< int > *verkauft, Framework::Array< int > *einkommen, Framework::Array< int > *gespielt )
+int EditorClient::getVerkaufStatistik(Framework::Array< int >* verkauft, Framework::Array< int >* einkommen, Framework::Array< int >* gespielt)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\x10", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int kaufAnz = 0;
-            k->getNachrichtEncrypted( (char *)&kaufAnz, 4 );
-            char anz = 0;
-            k->getNachrichtEncrypted( &anz, 1 );
-            for( int i = 0; i < anz; i++ )
-            {
-                int kupfer = 0;
-                int kauf = 0;
-                int games = 0;
-                k->getNachrichtEncrypted( (char *)&kupfer, 4 );
-                k->getNachrichtEncrypted( (char *)&kauf, 4 );
-                k->getNachrichtEncrypted( (char *)&games, 4 );
-                einkommen->add( kupfer );
-                verkauft->add( kauf );
-                gespielt->add( games );
-            }
-            cs.unlock();
-            return kaufAnz;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\x10", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int kaufAnz = 0;
+			k->getNachrichtEncrypted((char*)&kaufAnz, 4);
+			char anz = 0;
+			k->getNachrichtEncrypted(&anz, 1);
+			for (int i = 0; i < anz; i++)
+			{
+				int kupfer = 0;
+				int kauf = 0;
+				int games = 0;
+				k->getNachrichtEncrypted((char*)&kupfer, 4);
+				k->getNachrichtEncrypted((char*)&kauf, 4);
+				k->getNachrichtEncrypted((char*)&games, 4);
+				einkommen->add(kupfer);
+				verkauft->add(kauf);
+				gespielt->add(games);
+			}
+			cs.unlock();
+			return kaufAnz;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Startet den Editor Modus, welcher für jedes Spiel unterschiedlich funktioniert
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool EditorClient::initEditor()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xE", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    if( ret != 1 )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xE", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	if (ret != 1)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Erhält die Verbindung aufrecht
@@ -3143,128 +3143,128 @@ bool EditorClient::initEditor()
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool EditorClient::keepAlive()
 {
-    if( !cs.tryLock() )
-        return 1;
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char res = 0;
-    bool ok = k->sendeEncrypted( "\x5", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-        trenne( 0 );
-    if( res != 1 )
-        err = "Unbekannter Fehler";
-    return res == 1;
+	if (!cs.tryLock())
+		return 1;
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char res = 0;
+	bool ok = k->sendeEncrypted("\x5", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+		trenne(0);
+	if (res != 1)
+		err = "Unbekannter Fehler";
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool EditorClient::trenne( bool abmelden )
+bool EditorClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Editor Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Editor Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Editor Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Editor Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Beginnt eine individuelle Editor Nachricht
 //  Gibt den Klient zurück, über den mit dem Server kommuniziert werden kann. Im Fehlerfall wird 0 zurückgegeben
 //  Der Thread, der diese Methode aufgerufen hat, sollte nach dem Erfolgreichen Aufruf am Ende der Kommunikation mit dem Server endEditorMessage aufrufen
-Network::Klient *EditorClient::beginEditorMessage()
+Network::Klient* EditorClient::beginEditorMessage()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( "\xF", 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-            return k;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while beginning Editor Message Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted("\xF", 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+			return k;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while beginning Editor Message Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Beendet eine Editor Nachricht
 //  sollte nur nach dem erfolgreichem Aufrufen von beginEditorMessage aufgerufen werden (vom selben Thread)
 void EditorClient::endEditorMessage()
 {
-    cs.unlock();
+	cs.unlock();
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool EditorClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *EditorClient::getLetzterFehler() const
+const char* EditorClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/EditorClient.h

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

KSGNetwork/ErhaltungClient.cpp

@@ -7,132 +7,132 @@ using namespace KSGClient;
 // Inhalt der ErhaltungClient Klasse
 
 // Konstruktor
-ErhaltungClient::ErhaltungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : Thread()
+ErhaltungClient::ErhaltungClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: Thread()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
-    abmel = 0;
-    trenn = 0;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
+	abmel = 0;
+	trenn = 0;
 }
 
 // Destruktor
 ErhaltungClient::~ErhaltungClient()
 {
-    if( k )
-    {
-        abmelden();
-        trenne();
-    }
-    if( k )
-        k->release();
-    delete[] key;
+	if (k)
+	{
+		abmelden();
+		trenne();
+	}
+	if (k)
+		k->release();
+	delete[] key;
 }
 
 // DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
 void ErhaltungClient::thread()
 {
-    while( 1 )
-    {
-        char n = 0;
-        k->getNachrichtEncrypted( &n, 1 );
-        if( n != 1 )
-        {
-            Sleep( 250 );
-            continue;
-        }
-        if( trenn )
-        {
-            if( abmel )
-            {
-                k->sendeEncrypted( "\1", 1 );
-                k->getNachrichtEncrypted( &n, 1 );
-            }
-            k->trenne();
-            run = 0;
-            return;
-        }
-        else
-            k->sendeEncrypted( "\0", 1 );
-    }
+	while (1)
+	{
+		char n = 0;
+		k->getNachrichtEncrypted(&n, 1);
+		if (n != 1)
+		{
+			Sleep(250);
+			continue;
+		}
+		if (trenn)
+		{
+			if (abmel)
+			{
+				k->sendeEncrypted("\1", 1);
+				k->getNachrichtEncrypted(&n, 1);
+			}
+			k->trenne();
+			run = 0;
+			return;
+		}
+		else
+			k->sendeEncrypted("\0", 1);
+	}
 }
 
 // verbindet ich mit dem Erhaltung Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool ErhaltungClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::ERHALTUNG, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::ERHALTUNG, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        k->sende( "\0", 1 ); // Verschlüsselung Aktivieren
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifyin client Erhaltung Server returned: ";
-                err += f;
-                delete[]f;
-                k->sendeEncrypted( "\3", 1 );
-                k->getNachrichtEncrypted( &serverReturn, 1 );
-                k->trenne();
-                k = (Network::Klient *)k->release();
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-            start();
-        }
-        else
-        {
-            err = "network error while sending to Erhaltung Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Erhaltung Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::ERHALTUNG, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::ERHALTUNG, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		k->sende("\0", 1); // Verschlüsselung Aktivieren
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifyin client Erhaltung Server returned: ";
+				err += f;
+				delete[]f;
+				k->sendeEncrypted("\3", 1);
+				k->getNachrichtEncrypted(&serverReturn, 1);
+				k->trenne();
+				k = (Network::Klient*)k->release();
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+			start();
+		}
+		else
+		{
+			err = "network error while sending to Erhaltung Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Erhaltung Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Meldet sich beim Server ab und trennt die Verbindung
 void ErhaltungClient::abmelden()
 {
-    abmel = 1;
+	abmel = 1;
 }
 
 // Trennt die Verbindung zum Server
@@ -140,13 +140,13 @@ void ErhaltungClient::abmelden()
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
 bool ErhaltungClient::trenne()
 {
-    trenn = 1;
-    return 1;
+	trenn = 1;
+	return 1;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *ErhaltungClient::getLetzterFehler() const
+const char* ErhaltungClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/ErhaltungClient.h

@@ -5,39 +5,39 @@
 
 namespace KSGClient
 {
-    class ErhaltungClient : public ErhaltungServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
-        bool abmel;
-        bool trenn;
+	class ErhaltungClient : public ErhaltungServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
+		bool abmel;
+		bool trenn;
 
-        // DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
-        void thread() override;
+		// DBeantwortet Ping - Anfragen des Servers. Falls diese 60 Sekunden lang unbeantwortet bleiben, wird der Client vom Serversystem abgemeldet
+		void thread() override;
 
-    public:
-        // Konstruktor
-        ErhaltungClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        virtual ~ErhaltungClient();
-        // verbindet ich mit dem Erhaltung Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // Meldet sich beim Server ab und trennt die Verbindung
-        void abmelden() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne() override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		ErhaltungClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		virtual ~ErhaltungClient();
+		// verbindet ich mit dem Erhaltung Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// Meldet sich beim Server ab und trennt die Verbindung
+		void abmelden() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne() override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/HistorieClient.cpp

@@ -8,120 +8,120 @@ using namespace KSGClient;
 // Inhalt der HistorieClient Klasse
 
 // Konstruktor
-HistorieClient::HistorieClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen, int spielId )
-    : ReferenceCounter()
+HistorieClient::HistorieClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen, int spielId)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
-    this->spielId = spielId;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
+	this->spielId = spielId;
 }
 
 // Destruktor
 HistorieClient::~HistorieClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Historie Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool HistorieClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::HISTORIE, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::HISTORIE, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Historie Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Historie Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Historie Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::HISTORIE, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::HISTORIE, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Historie Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Historie Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Historie Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool HistorieClient::trenne( bool abmelden )
+bool HistorieClient::trenne(bool abmelden)
 {
-    if( !k && !abmelden )
-        return 1;
-    if( !k && abmelden )
-        verbinde();
-    if( !k )
-        return 0;
-    char serverReturn;
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 3 )
-        {
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            char *nachricht = new char[ län + 1 ];
-            nachricht[ län ] = 0;
-            k->getNachrichtEncrypted( nachricht, län );
-            err = nachricht;
-            delete[]nachricht;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    return 1;
+	if (!k && !abmelden)
+		return 1;
+	if (!k && abmelden)
+		verbinde();
+	if (!k)
+		return 0;
+	char serverReturn;
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 3)
+		{
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			char* nachricht = new char[län + 1];
+			nachricht[län] = 0;
+			k->getNachrichtEncrypted(nachricht, län);
+			err = nachricht;
+			delete[]nachricht;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	return 1;
 }
 
 // Lädt die Spiel Aufzeichnung eines Spiels herunter und speichert sie unter data/tmp/historie/{spielId}
@@ -130,80 +130,80 @@ bool HistorieClient::trenne( bool abmelden )
 //  Diese Funktion verbindet sich selbstständig mit dem Server und trennt die Verbindung nach Beendigung des Vorgangs
 bool HistorieClient::downloadSpielHistorie()
 {
-    if( DateiIstVerzeichnis( Text( "data/tmp/historie/" ) += spielId ) )
-        return 1;
-    cs.lock();
-    if( !verbinde() )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&spielId, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            while( län )
-            {
-                char *pf = new char[ län + 1 ];
-                pf[ län ] = 0;
-                k->getNachrichtEncrypted( pf, län );
-                __int64 gr = 0;
-                k->getNachrichtEncrypted( (char *)&gr, 8 );
-                Text *pfad = new Text( "data/tmp/historie/" );
-                pfad->append( spielId );
-                pfad->append( pf );
-                delete[] pf;
-                Datei *d = new Datei();
-                d->setDatei( pfad );
-                d->erstellen();
-                d->open( Datei::Style::schreiben );
-                char *bytes = new char[ 2048 ];
-                while( gr )
-                {
-                    int dLän = gr > 2048 ? 2048 : (int)gr;
-                    k->getNachricht( bytes, dLän );
-                    d->schreibe( bytes, dLän );
-                    gr -= dLän;
-                }
-                delete[] bytes;
-                d->close();
-                d->release();
-                k->getNachrichtEncrypted( &län, 1 );
-            }
-            trenne( 0 );
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( ret == 3 )
-    {
-        char län = 0;
-        k->getNachrichtEncrypted( &län, 1 );
-        char *nachricht = new char[ län + 1 ];
-        nachricht[ län ] = 0;
-        k->getNachrichtEncrypted( nachricht, län );
-        err = nachricht;
-        delete[]nachricht;
-        trenne( 0 );
-        cs.unlock();
-        return 0;
-    }
-    err = "unbekannter Fehler";
-    trenne( 0 );
-    cs.unlock();
-    return 0;
+	if (DateiIstVerzeichnis(Text("data/tmp/historie/") += spielId))
+		return 1;
+	cs.lock();
+	if (!verbinde())
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&spielId, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			while (län)
+			{
+				char* pf = new char[län + 1];
+				pf[län] = 0;
+				k->getNachrichtEncrypted(pf, län);
+				__int64 gr = 0;
+				k->getNachrichtEncrypted((char*)&gr, 8);
+				Text* pfad = new Text("data/tmp/historie/");
+				pfad->append(spielId);
+				pfad->append(pf);
+				delete[] pf;
+				Datei* d = new Datei();
+				d->setDatei(pfad);
+				d->erstellen();
+				d->open(Datei::Style::schreiben);
+				char* bytes = new char[2048];
+				while (gr)
+				{
+					int dLän = gr > 2048 ? 2048 : (int)gr;
+					k->getNachricht(bytes, dLän);
+					d->schreibe(bytes, dLän);
+					gr -= dLän;
+				}
+				delete[] bytes;
+				d->close();
+				d->release();
+				k->getNachrichtEncrypted(&län, 1);
+			}
+			trenne(0);
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (ret == 3)
+	{
+		char län = 0;
+		k->getNachrichtEncrypted(&län, 1);
+		char* nachricht = new char[län + 1];
+		nachricht[län] = 0;
+		k->getNachrichtEncrypted(nachricht, län);
+		err = nachricht;
+		delete[]nachricht;
+		trenne(0);
+		cs.unlock();
+		return 0;
+	}
+	err = "unbekannter Fehler";
+	trenne(0);
+	cs.unlock();
+	return 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *HistorieClient::getLetzterFehler() const
+const char* HistorieClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/HistorieClient.h

@@ -5,42 +5,42 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class HistorieClient : public HistorieServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
-        int spielId;
+	// Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class HistorieClient : public HistorieServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
+		int spielId;
 
-    protected:
-        // verbindet sich mit dem zugewiesenen Historie Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
+	protected:
+		// verbindet sich mit dem zugewiesenen Historie Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
 
-    public:
-        // Konstruktor
-        HistorieClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen, int spielId );
-        // Destruktor
-        ~HistorieClient();
-        // 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
-        bool downloadSpielHistorie() override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		HistorieClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen, int spielId);
+		// Destruktor
+		~HistorieClient();
+		// 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
+		bool downloadSpielHistorie() override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/InformationClient.cpp

@@ -10,1055 +10,1055 @@ using namespace KSGClient;
 // Inhalt der InformationClient Klasse
 
 // Konstruktor
-InformationClient::InformationClient( int kId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+InformationClient::InformationClient(int kId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = kId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = kId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 InformationClient::~InformationClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet ich mit dem zugewiesenen Informaion Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool InformationClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::INFORMATION, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::INFORMATION, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Information Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Information Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Information Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::INFORMATION, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::INFORMATION, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Information Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Information Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Information Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // fragt nach dem Informationstext
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
 //  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
-bool InformationClient::getInformationText( Framework::Text *txt, int *typ )
+bool InformationClient::getInformationText(Framework::Text* txt, int* typ)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    bool ret = 1;
-    ret = ret & k->sendeEncrypted( "\5", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    short län = 0;
-    ret = ret & k->getNachrichtEncrypted( (char *)&län, 2 );
-    char *text = new char[ län + 1 ];
-    text[ län ] = 0;
-    if( län )
-        ret = ret & k->getNachrichtEncrypted( text, län );
-    txt->setText( text );
-    delete[]text;
-    char type = 0;
-    ret = ret & k->getNachrichtEncrypted( &type, 1 );
-    *typ = type;
-    if( !ret )
-        err = "Verbindungsfehler";
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	bool ret = 1;
+	ret = ret & k->sendeEncrypted("\5", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	short län = 0;
+	ret = ret & k->getNachrichtEncrypted((char*)&län, 2);
+	char* text = new char[län + 1];
+	text[län] = 0;
+	if (län)
+		ret = ret & k->getNachrichtEncrypted(text, län);
+	txt->setText(text);
+	delete[]text;
+	char type = 0;
+	ret = ret & k->getNachrichtEncrypted(&type, 1);
+	*typ = type;
+	if (!ret)
+		err = "Verbindungsfehler";
+	cs.unlock();
+	return ret;
 }
 
 // fragt, ob das entsprechende Spiel vom Server gesperrt wurde
 //  spielId: Die Id des Spiels
 //  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
-bool InformationClient::istSpielErlaubt( int spielId )
+bool InformationClient::istSpielErlaubt(int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&spielId, 4 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( !ret )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret != 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&spielId, 4);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (!ret)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret != 0;
 }
 
 // fragt, ob die entsprechende Karte vom Server gesperrt wurde
 //  karteId: Die Id der Karte
 //  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
-bool InformationClient::istKarteErlaubt( int karteId )
+bool InformationClient::istKarteErlaubt(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\7", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&karteId, 4 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( !ret )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret != 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\7", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&karteId, 4);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (!ret)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret != 0;
 }
 
 // Ermittelt die Id einer Karte
 //  name: Der Name der Karte
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getKarteId( char *name )
+int InformationClient::getKarteId(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x9", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( name );
-    k->sendeEncrypted( &län, 1 );
-    k->sendeEncrypted( name, län );
-    int id = 0;
-    k->getNachrichtEncrypted( (char *)&id, 4 );
-    cs.unlock();
-    return id;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x9", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(name);
+	k->sendeEncrypted(&län, 1);
+	k->sendeEncrypted(name, län);
+	int id = 0;
+	k->getNachrichtEncrypted((char*)&id, 4);
+	cs.unlock();
+	return id;
 }
 
 // Fragt nach der Id eines Spiels
 //  name: Der Name des Spiels
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getSpielId( char *name )
+int InformationClient::getSpielId(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x8", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( name );
-    k->sendeEncrypted( &län, 1 );
-    k->sendeEncrypted( name, län );
-    int id = 0;
-    k->getNachrichtEncrypted( (char *)&id, 4 );
-    cs.unlock();
-    return id;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x8", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(name);
+	k->sendeEncrypted(&län, 1);
+	k->sendeEncrypted(name, län);
+	int id = 0;
+	k->getNachrichtEncrypted((char*)&id, 4);
+	cs.unlock();
+	return id;
 }
 
 // fragt nach dem Namen eines Accounts
 //  accountId: Die Id des Accounts
 //  Gibt bei misserfolg 0 zurück
-Framework::Text *InformationClient::getSpielerName( int accountId )
+Framework::Text* InformationClient::getSpielerName(int accountId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&accountId, 4 );
-    char län = 0;
-    k->getNachrichtEncrypted( &län, 1 );
-    char *name = new char[ län + 1 ];
-    name[ län ] = 0;
-    if( län )
-        k->getNachrichtEncrypted( name, län );
-    Text *ret = new Text( name );
-    delete[]name;
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xA", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&accountId, 4);
+	char län = 0;
+	k->getNachrichtEncrypted(&län, 1);
+	char* name = new char[län + 1];
+	name[län] = 0;
+	if (län)
+		k->getNachrichtEncrypted(name, län);
+	Text* ret = new Text(name);
+	delete[]name;
+	cs.unlock();
+	return ret;
 }
 
 // fragt nach der Spiel Statistik eines Accounts
 //  accountId: Die Id des Accounts
 //  spielId: Die Id des Spiels
 //  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
-bool InformationClient::getSpielStatistik( int accountId, int spielId, Framework::Array< int > *werte )
+bool InformationClient::getSpielStatistik(int accountId, int spielId, Framework::Array< int >* werte)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    bool ret = 1;
-    ret = ret & k->sendeEncrypted( "\xB", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    ret = ret & k->sendeEncrypted( (char *)&accountId, 4 );
-    ret = ret & k->sendeEncrypted( (char *)&spielId, 4 );
-    for( int i = 0; i < 10; i++ )
-    {
-        int tmp = 0;
-        ret = ret & k->getNachrichtEncrypted( (char *)&tmp, 4 );
-        werte->add( tmp, i );
-    }
-    if( !ret )
-        err = "Verbindungsfehler";
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	bool ret = 1;
+	ret = ret & k->sendeEncrypted("\xB", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	ret = ret & k->sendeEncrypted((char*)&accountId, 4);
+	ret = ret & k->sendeEncrypted((char*)&spielId, 4);
+	for (int i = 0; i < 10; i++)
+	{
+		int tmp = 0;
+		ret = ret & k->getNachrichtEncrypted((char*)&tmp, 4);
+		werte->add(tmp, i);
+	}
+	if (!ret)
+		err = "Verbindungsfehler";
+	cs.unlock();
+	return ret;
 }
 
 // fragt nach dem Namen einer Karte
 //  karteId: Die id der Karte
 //  Gibt bei misserfolg 0 zurück
-Framework::Text *InformationClient::getKarteName( int karteId )
+Framework::Text* InformationClient::getKarteName(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xE", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&karteId, 4 );
-    char län = 0;
-    k->getNachrichtEncrypted( &län, 1 );
-    char *name = new char[ län + 1 ];
-    name[ län ] = 0;
-    if( län )
-        k->getNachrichtEncrypted( name, län );
-    Text *ret = new Text( name );
-    delete[]name;
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xE", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&karteId, 4);
+	char län = 0;
+	k->getNachrichtEncrypted(&län, 1);
+	char* name = new char[län + 1];
+	name[län] = 0;
+	if (län)
+		k->getNachrichtEncrypted(name, län);
+	Text* ret = new Text(name);
+	delete[]name;
+	cs.unlock();
+	return ret;
 }
 
 // fragt nach dem Namen eines Spiels
 //  spielId: Die id des Spiels
 //  Gibt bei misserfolg 0 zurück
-Framework::Text *InformationClient::getSpielName( int spielId )
+Framework::Text* InformationClient::getSpielName(int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xF", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&spielId, 4 );
-    char län = 0;
-    k->getNachrichtEncrypted( &län, 1 );
-    char *name = new char[ län + 1 ];
-    name[ län ] = 0;
-    if( län )
-        k->getNachrichtEncrypted( name, län );
-    Text *ret = new Text( name );
-    delete[]name;
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xF", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&spielId, 4);
+	char län = 0;
+	k->getNachrichtEncrypted(&län, 1);
+	char* name = new char[län + 1];
+	name[län] = 0;
+	if (län)
+		k->getNachrichtEncrypted(name, län);
+	Text* ret = new Text(name);
+	delete[]name;
+	cs.unlock();
+	return ret;
 }
 
 // fragt nach dem Namen eines Chatrooms
 //  chatroomId: Die id des Chatrooms
 //  Gibt bei misserfolg 0 zurück
-Framework::Text *InformationClient::getChatroomName( int chatroomId )
+Framework::Text* InformationClient::getChatroomName(int chatroomId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x10", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&chatroomId, 4 );
-    char län = 0;
-    k->getNachrichtEncrypted( &län, 1 );
-    char *name = new char[ län + 1 ];
-    name[ län ] = 0;
-    if( län )
-        k->getNachrichtEncrypted( name, län );
-    Text *ret = new Text( name );
-    delete[]name;
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x10", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&chatroomId, 4);
+	char län = 0;
+	k->getNachrichtEncrypted(&län, 1);
+	char* name = new char[län + 1];
+	name[län] = 0;
+	if (län)
+		k->getNachrichtEncrypted(name, län);
+	Text* ret = new Text(name);
+	delete[]name;
+	cs.unlock();
+	return ret;
 }
 
 // fragt zu welcher Spielart die Karte gehört
 //  karteId: Die id der Karte
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getSpielId( int karteId )
+int InformationClient::getSpielId(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x11", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&karteId, 4 );
-    int ret = 0;
-    k->getNachrichtEncrypted( (char *)&ret, 4 );
-    if( !ret )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x11", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&karteId, 4);
+	int ret = 0;
+	k->getNachrichtEncrypted((char*)&ret, 4);
+	if (!ret)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret;
 }
 
 // gibt die Id eines Accounts zurück
 //  name: Der Angezeigte Name des Accounts
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getAccountId( char *name )
+int InformationClient::getAccountId(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( name );
-    if( !län )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x12", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( &län, 1 );
-    k->sendeEncrypted( name, län );
-    int ret = 0;
-    k->getNachrichtEncrypted( (char *)&ret, 4 );
-    if( !ret )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(name);
+	if (!län)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x12", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted(&län, 1);
+	k->sendeEncrypted(name, län);
+	int ret = 0;
+	k->getNachrichtEncrypted((char*)&ret, 4);
+	if (!ret)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret;
 }
 
 // gibt die Id des Chatrooms zurück
 //  name: Der name des Chatrooms
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getChatroomId( char *name )
+int InformationClient::getChatroomId(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char län = textLength( name );
-    if( !län )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x13", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( &län, 1 );
-    k->sendeEncrypted( name, län );
-    int ret = 0;
-    k->getNachrichtEncrypted( (char *)&ret, 4 );
-    if( !ret )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char län = textLength(name);
+	if (!län)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x13", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted(&län, 1);
+	k->sendeEncrypted(name, län);
+	int ret = 0;
+	k->getNachrichtEncrypted((char*)&ret, 4);
+	if (!ret)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return ret;
 }
 
 // gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
 //  gruppenId: Die id der Gruppe
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getGruppenKarteId( int gruppenId )
+int InformationClient::getGruppenKarteId(int gruppenId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xD", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&gruppenId, 4 );
-    int id = 0;
-    k->getNachrichtEncrypted( (char *)&id, 4 );
-    if( !id )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return id;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xD", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&gruppenId, 4);
+	int id = 0;
+	k->getNachrichtEncrypted((char*)&id, 4);
+	if (!id)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return id;
 }
 
 // gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
 //  gruppeId: Die id der Gruppe
-bool InformationClient::getGruppeSpielerHinzufügen( int gruppeId )
+bool InformationClient::getGruppeSpielerHinzufügen(int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x1E", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&gruppeId, 4 );
-    char sh = 0;
-    k->getNachrichtEncrypted( (char *)&sh, 1 );
-    cs.unlock();
-    return sh == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x1E", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&gruppeId, 4);
+	char sh = 0;
+	k->getNachrichtEncrypted((char*)&sh, 1);
+	cs.unlock();
+	return sh == 1;
 }
 
 // gibt die Account Id des Gruppen Administrators zurück
 //  gruppeId: Die Id der Gruppe
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getGruppeAdminId( int gruppeId )
+int InformationClient::getGruppeAdminId(int gruppeId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x15", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&gruppeId, 4 );
-    int id = 0;
-    k->getNachrichtEncrypted( (char *)&id, 4 );
-    if( !id )
-        err = "Unbekannter Fehler";
-    cs.unlock();
-    return id;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x15", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&gruppeId, 4);
+	int id = 0;
+	k->getNachrichtEncrypted((char*)&id, 4);
+	if (!id)
+		err = "Unbekannter Fehler";
+	cs.unlock();
+	return id;
 }
 
 // gibt die Punkte eines Spielers zurück
 //  accountId: Die Accont Id des Spielers
 //  spielId: Die Id des Spiels
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getSpielerPunkte( int accountId, int spielId )
+int InformationClient::getSpielerPunkte(int accountId, int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x14", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[]f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&spielId, 4 );
-    k->sendeEncrypted( (char *)&accountId, 4 );
-    int punkte = 0;
-    k->getNachrichtEncrypted( (char *)&punkte, 4 );
-    cs.unlock();
-    return punkte;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x14", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[]f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&spielId, 4);
+	k->sendeEncrypted((char*)&accountId, 4);
+	int punkte = 0;
+	k->getNachrichtEncrypted((char*)&punkte, 4);
+	cs.unlock();
+	return punkte;
 }
 
 // gibt eine Liste mit Ids von gekauften Spielen zurück
 //  Gibt bei misserfolg 0 zurück
-Framework::Array< int > *InformationClient::getAccountSpielArtListe()
+Framework::Array< int >* InformationClient::getAccountSpielArtListe()
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x16", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        Array< int > *list = new Array< int >();
-        for( int i = 0; i < anz; i++ )
-        {
-            int id = 0;
-            k->getNachrichtEncrypted( (char *)&id, 4 );
-            list->add( id );
-        }
-        cs.unlock();
-        return list;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *f = new char[ ret + 1 ];
-        f[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( f, ret );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x16", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		Array< int >* list = new Array< int >();
+		for (int i = 0; i < anz; i++)
+		{
+			int id = 0;
+			k->getNachrichtEncrypted((char*)&id, 4);
+			list->add(id);
+		}
+		cs.unlock();
+		return list;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* f = new char[ret + 1];
+		f[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(f, ret);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt die neuste Version eines Spiels zurück
 //  spielId: Die Id des Spiels
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getSpielVersion( int spielId )
+int InformationClient::getSpielVersion(int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x17", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&spielId, 4 );
-    int version = 0;
-    k->getNachrichtEncrypted( (char *)&version, 4 );
-    cs.unlock();
-    return version;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x17", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&spielId, 4);
+	int version = 0;
+	k->getNachrichtEncrypted((char*)&version, 4);
+	cs.unlock();
+	return version;
 }
 
 // gibt das Kupfer des Accounts zurück
 //  Gibt bei misserfolg 0 zurück
 int InformationClient::getKupfer()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x18", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    int kupfer = 0;
-    k->getNachrichtEncrypted( (char *)&kupfer, 4 );
-    cs.unlock();
-    return kupfer;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x18", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	int kupfer = 0;
+	k->getNachrichtEncrypted((char*)&kupfer, 4);
+	cs.unlock();
+	return kupfer;
 }
 
 // Gibt die Dateigruppem Id eines Spieles zurück
 //  spielId: Die Id des Spiels
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getDateiGruppeIdVonSpiel( int spielId )
+int InformationClient::getDateiGruppeIdVonSpiel(int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x19", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&spielId, 4 );
-    int dgId = 0;
-    k->getNachrichtEncrypted( (char *)&dgId, 4 );
-    cs.unlock();
-    return dgId;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x19", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&spielId, 4);
+	int dgId = 0;
+	k->getNachrichtEncrypted((char*)&dgId, 4);
+	cs.unlock();
+	return dgId;
 }
 
 // Gibt den Dateigruppen Pfad zurück
 //  dgId: Die Id der Dateigruppe
 //  Gibt bei misserfolg 0 zurück
-Framework::Text *InformationClient::getDateiGruppePfad( int dgId )
+Framework::Text* InformationClient::getDateiGruppePfad(int dgId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x1A", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&dgId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            char *pf = new char[ län + 1 ];
-            pf[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( pf, län );
-            Text *pfad = new Text( pf );
-            delete[] pf;
-            cs.unlock();
-            return pfad;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x1A", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&dgId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			char* pf = new char[län + 1];
+			pf[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(pf, län);
+			Text* pfad = new Text(pf);
+			delete[] pf;
+			cs.unlock();
+			return pfad;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt eine Liste mit gekauften Karten zurück
 //  spielId: Die Spiel Id zu der die Karten gehören sollen
 //  Gibt bei misserfolg 0 zurück
-Framework::Array< int > *InformationClient::getAccountKarteListe( int spielId )
+Framework::Array< int >* InformationClient::getAccountKarteListe(int spielId)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x1B", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&spielId, 4 );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        Array< int > *list = new Array< int >();
-        for( int i = 0; i < anz; i++ )
-        {
-            int id = 0;
-            k->getNachrichtEncrypted( (char *)&id, 4 );
-            list->add( id );
-        }
-        cs.unlock();
-        return list;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *f = new char[ ret + 1 ];
-        f[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( f, ret );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x1B", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&spielId, 4);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		Array< int >* list = new Array< int >();
+		for (int i = 0; i < anz; i++)
+		{
+			int id = 0;
+			k->getNachrichtEncrypted((char*)&id, 4);
+			list->add(id);
+		}
+		cs.unlock();
+		return list;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* f = new char[ret + 1];
+		f[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(f, ret);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt die Dateigruppen Id eines Pfades zurück
 //  pfad: Der Pfad der Dateigruppe
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getDateiGruppeIdVonPfad( char *pfad )
+int InformationClient::getDateiGruppeIdVonPfad(const char* pfad)
 {
-    char län = textLength( pfad );
-    if( !län )
-        return 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x2A", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&län, 1 );
-    k->sendeEncrypted( (char *)pfad, län );
-    int dgId = 0;
-    k->getNachrichtEncrypted( (char *)&dgId, 4 );
-    cs.unlock();
-    return dgId;
+	char län = textLength(pfad);
+	if (!län)
+		return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x2A", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&län, 1);
+	k->sendeEncrypted((char*)pfad, län);
+	int dgId = 0;
+	k->getNachrichtEncrypted((char*)&dgId, 4);
+	cs.unlock();
+	return dgId;
 }
 
 // gibt die neuste Version einer Dateigruppe zurück
 //  dg: Die Dateigruppen Id
 //  Gibt bei misserfolg 0 zurück
-int InformationClient::getDateiGruppeVersion( int dg )
+int InformationClient::getDateiGruppeVersion(int dg)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x2B", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&dg, 4 );
-    int version = 0;
-    k->getNachrichtEncrypted( (char *)&version, 4 );
-    cs.unlock();
-    return version;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x2B", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&dg, 4);
+	int version = 0;
+	k->getNachrichtEncrypted((char*)&version, 4);
+	cs.unlock();
+	return version;
 }
 
 // Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
@@ -1070,401 +1070,401 @@ int InformationClient::getDateiGruppeVersion( int dg )
 //  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
 //  Gibt die Anzahl der gefundenen Accounts zurück
 //  Gibt die Anzahl der Spieler zurück, -1 bei fehler
-int InformationClient::getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo > *accounts )
+int InformationClient::getSpielerListe(const char* suche, int* seite, int* maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo >* accounts)
 {
-    char län = textLength( suche );
-    if( !län )
-        return -1;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char serverReturn = 0;
-    k->sendeEncrypted( "\xC", 1 );
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( &län, 1 );
-        k->sendeEncrypted( suche, län );
-        k->sendeEncrypted( (char *)seite, 4 );
-        k->sendeEncrypted( &sortSpalte, 1 );
-        k->sendeEncrypted( &rückwärts, 1 );
-        k->getNachrichtEncrypted( (char *)seite, 4 );
-        k->getNachrichtEncrypted( (char *)maxSeite, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        for( int i = 0; i < ret; i++ )
-        {
-            AccountInfo info;
-            k->getNachrichtEncrypted( (char *)&info.id, 4 );
-            k->getNachrichtEncrypted( &län, 1 );
-            char *txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            k->getNachrichtEncrypted( txt, län );
-            info.name = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            k->getNachrichtEncrypted( txt, län );
-            info.zuletztOnline = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            k->getNachrichtEncrypted( txt, län );
-            info.letztesSpiel = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            k->getNachrichtEncrypted( txt, län );
-            info.letzteKarte = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            k->getNachrichtEncrypted( txt, län );
-            info.punkte = txt;
-            delete[] txt;
-            accounts->add( info );
-        }
-        cs.unlock();
-        return ret;
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return -1;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return -1;
+	char län = textLength(suche);
+	if (!län)
+		return -1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char serverReturn = 0;
+	k->sendeEncrypted("\xC", 1);
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted(&län, 1);
+		k->sendeEncrypted(suche, län);
+		k->sendeEncrypted((char*)seite, 4);
+		k->sendeEncrypted(&sortSpalte, 1);
+		k->sendeEncrypted(&rückwärts, 1);
+		k->getNachrichtEncrypted((char*)seite, 4);
+		k->getNachrichtEncrypted((char*)maxSeite, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		for (int i = 0; i < ret; i++)
+		{
+			AccountInfo info;
+			k->getNachrichtEncrypted((char*)&info.id, 4);
+			k->getNachrichtEncrypted(&län, 1);
+			char* txt = new char[län + 1];
+			txt[län] = 0;
+			k->getNachrichtEncrypted(txt, län);
+			info.name = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			k->getNachrichtEncrypted(txt, län);
+			info.zuletztOnline = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			k->getNachrichtEncrypted(txt, län);
+			info.letztesSpiel = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			k->getNachrichtEncrypted(txt, län);
+			info.letzteKarte = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			k->getNachrichtEncrypted(txt, län);
+			info.punkte = txt;
+			delete[] txt;
+			accounts->add(info);
+		}
+		cs.unlock();
+		return ret;
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return -1;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return -1;
 }
 
 // ermittelt die aktivität eines Spielers
 //  accId: Die Id des Accounts
 //  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
-bool InformationClient::getSpielerAktivität( int accId, Framework::Array< AccountActivityInfo > *info )
+bool InformationClient::getSpielerAktivität(int accId, Framework::Array< AccountActivityInfo >* info)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    k->sendeEncrypted( "\x1F", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&accId, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            k->getNachrichtEncrypted( &ret, 1 );
-            for( int i = 0; ret; i++ )
-            {
-                AccountActivityInfo inf;
-                char *txt = new char[ ret + 1 ];
-                txt[ ret ] = 0;
-                k->getNachrichtEncrypted( txt, ret );
-                inf.datum = txt;
-                delete[] txt;
-                k->getNachrichtEncrypted( (char *)&inf.stOnline, 8 );
-                k->getNachrichtEncrypted( (char *)&inf.stGespielt, 8 );
-                k->getNachrichtEncrypted( (char *)&inf.anzSpiele, 4 );
-                k->getNachrichtEncrypted( (char *)&inf.anzGewonnen, 4 );
-                k->getNachrichtEncrypted( &ret, 1 );
-                info->add( inf );
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	k->sendeEncrypted("\x1F", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&accId, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			k->getNachrichtEncrypted(&ret, 1);
+			for (int i = 0; ret; i++)
+			{
+				AccountActivityInfo inf;
+				char* txt = new char[ret + 1];
+				txt[ret] = 0;
+				k->getNachrichtEncrypted(txt, ret);
+				inf.datum = txt;
+				delete[] txt;
+				k->getNachrichtEncrypted((char*)&inf.stOnline, 8);
+				k->getNachrichtEncrypted((char*)&inf.stGespielt, 8);
+				k->getNachrichtEncrypted((char*)&inf.anzSpiele, 4);
+				k->getNachrichtEncrypted((char*)&inf.anzGewonnen, 4);
+				k->getNachrichtEncrypted(&ret, 1);
+				info->add(inf);
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
 //  account: Die Id des Accounts
 //  karte: Die Id der Karte
-int InformationClient::getAccountKarteSpiele( int account, int karte )
+int InformationClient::getAccountKarteSpiele(int account, int karte)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    k->sendeEncrypted( "\x20", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        k->sendeEncrypted( (char *)&karte, 4 );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        cs.unlock();
-        return anz;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	k->sendeEncrypted("\x20", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		k->sendeEncrypted((char*)&karte, 4);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		cs.unlock();
+		return anz;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
 //  account: Die Id des Accounts
 //  karte: Die Id der Karte
-int InformationClient::getAccountKarteSpieleGewonnen( int account, int karte )
+int InformationClient::getAccountKarteSpieleGewonnen(int account, int karte)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    k->sendeEncrypted( "\x21", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        k->sendeEncrypted( (char *)&karte, 4 );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        cs.unlock();
-        return anz;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	k->sendeEncrypted("\x21", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		k->sendeEncrypted((char*)&karte, 4);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		cs.unlock();
+		return anz;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt zurück, ob ein Spieler die Karte im Besitz hat
 //  account: Die Id des Accounts
 //  karte: Die Id der Karte
-bool InformationClient::hatAccountKarte( int account, int karte )
+bool InformationClient::hatAccountKarte(int account, int karte)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    k->sendeEncrypted( "\x22", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        k->sendeEncrypted( (char *)&karte, 4 );
-        char status = 0;
-        k->getNachrichtEncrypted( &status, 1 );
-        cs.unlock();
-        return status != 0;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	k->sendeEncrypted("\x22", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		k->sendeEncrypted((char*)&karte, 4);
+		char status = 0;
+		k->getNachrichtEncrypted(&status, 1);
+		cs.unlock();
+		return status != 0;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
 //  account: Die Id des Accounts
 //  spiel: Die Id des Spiels
-bool InformationClient::hatAccountSpiel( int account, int spiel )
+bool InformationClient::hatAccountSpiel(int account, int spiel)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    k->sendeEncrypted( "\x23", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        k->sendeEncrypted( (char *)&spiel, 4 );
-        char status = 0;
-        k->getNachrichtEncrypted( &status, 1 );
-        cs.unlock();
-        return status != 0;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	k->sendeEncrypted("\x23", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		k->sendeEncrypted((char*)&spiel, 4);
+		char status = 0;
+		k->getNachrichtEncrypted(&status, 1);
+		cs.unlock();
+		return status != 0;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
 //  account: Die Id des Accounts
 //  spiel: Die Id des Spiels 
 //  Gibt bei misserfolg 0 zurück
-Framework::Array< int > *InformationClient::getAccountKarteGespieltListe( int account, int spielId )
+Framework::Array< int >* InformationClient::getAccountKarteGespieltListe(int account, int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x24", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        k->sendeEncrypted( (char *)&spielId, 4 );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        Array< int > *ret = new Array< int >();
-        for( int i = 0; i < anz; i++ )
-        {
-            int val = 0;
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            ret->set( val, i );
-        }
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x24", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		k->sendeEncrypted((char*)&spielId, 4);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		Array< int >* ret = new Array< int >();
+		for (int i = 0; i < anz; i++)
+		{
+			int val = 0;
+			k->getNachrichtEncrypted((char*)&val, 4);
+			ret->set(val, i);
+		}
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
 //  account: Die Id des Accounts
 //  Gibt bei misserfolg 0 zurück
-Framework::Array< int > *InformationClient::getAccountSpielGespieltListe( int account )
+Framework::Array< int >* InformationClient::getAccountSpielGespieltListe(int account)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x25", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        Array< int > *ret = new Array< int >();
-        for( int i = 0; i < anz; i++ )
-        {
-            int val = 0;
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            ret->set( val, i );
-        }
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x25", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		Array< int >* ret = new Array< int >();
+		for (int i = 0; i < anz; i++)
+		{
+			int val = 0;
+			k->getNachrichtEncrypted((char*)&val, 4);
+			ret->set(val, i);
+		}
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt eine Liste von Spiel Partnern eines Spielers zurück
@@ -1473,51 +1473,51 @@ Framework::Array< int > *InformationClient::getAccountSpielGespieltListe( int ac
 //  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
 //  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool InformationClient::getSpielPartnerListe( int account, Framework::Array< int > *spieler, Framework::Array< int > *karten, Framework::Array< int > *anzahl )
+bool InformationClient::getSpielPartnerListe(int account, Framework::Array< int >* spieler, Framework::Array< int >* karten, Framework::Array< int >* anzahl)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x26", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int val = 0;
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            spieler->set( val, i );
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            karten->set( val, i );
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            anzahl->set( val, i );
-        }
-        cs.unlock();
-        return 1;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x26", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int val = 0;
+			k->getNachrichtEncrypted((char*)&val, 4);
+			spieler->set(val, i);
+			k->getNachrichtEncrypted((char*)&val, 4);
+			karten->set(val, i);
+			k->getNachrichtEncrypted((char*)&val, 4);
+			anzahl->set(val, i);
+		}
+		cs.unlock();
+		return 1;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt eine Liste mit Spiel Statistiken zurück
@@ -1529,304 +1529,304 @@ bool InformationClient::getSpielPartnerListe( int account, Framework::Array< int
 //  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
 //  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool InformationClient::getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts,
-                                           Framework::RCArray< Framework::Array< int > > *werte, Framework::RCArray< Framework::Text > *namen )
+bool InformationClient::getStatistikListe(int account, int* seite, int* maxSeite, char sortSpalte, char rückwärts,
+	Framework::RCArray< Framework::Array< int > >* werte, Framework::RCArray< Framework::Text >* namen)
 {
-    if( !*seite )
-        *seite = 1;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char serverReturn = 0;
-    k->sendeEncrypted( "\x27", 1 );
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&account, 4 );
-        k->sendeEncrypted( (char *)seite, 4 );
-        k->sendeEncrypted( &sortSpalte, 1 );
-        k->sendeEncrypted( &rückwärts, 1 );
-        k->getNachrichtEncrypted( (char *)seite, 4 );
-        k->getNachrichtEncrypted( (char *)maxSeite, 4 );
-        int zAnz = 0;
-        int sAnz = 0;
-        k->getNachrichtEncrypted( (char *)&zAnz, 4 );
-        k->getNachrichtEncrypted( (char *)&sAnz, 4 );
-        for( int i = 0; i < zAnz; i++ )
-        {
-            Array< int > *tmp = new Array< int >();
-            for( int j = 0; j < sAnz; j++ )
-            {
-                if( j != 1 )
-                {
-                    int val = 0;
-                    k->getNachrichtEncrypted( (char *)&val, 4 );
-                    tmp->set( val, j );
-                }
-                else
-                {
-                    char län = 0;
-                    k->getNachrichtEncrypted( &län, 1 );
-                    char *n = new char[ län + 1 ];
-                    n[ län ] = 0;
-                    if( län )
-                        k->getNachrichtEncrypted( n, län );
-                    namen->set( new Text( n ), i );
-                    delete[] n;
-                }
-            }
-            werte->set( tmp, i );
-        }
-        cs.unlock();
-        return 1;
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-    }
-    cs.unlock();
-    return 0;
+	if (!*seite)
+		*seite = 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char serverReturn = 0;
+	k->sendeEncrypted("\x27", 1);
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&account, 4);
+		k->sendeEncrypted((char*)seite, 4);
+		k->sendeEncrypted(&sortSpalte, 1);
+		k->sendeEncrypted(&rückwärts, 1);
+		k->getNachrichtEncrypted((char*)seite, 4);
+		k->getNachrichtEncrypted((char*)maxSeite, 4);
+		int zAnz = 0;
+		int sAnz = 0;
+		k->getNachrichtEncrypted((char*)&zAnz, 4);
+		k->getNachrichtEncrypted((char*)&sAnz, 4);
+		for (int i = 0; i < zAnz; i++)
+		{
+			Array< int >* tmp = new Array< int >();
+			for (int j = 0; j < sAnz; j++)
+			{
+				if (j != 1)
+				{
+					int val = 0;
+					k->getNachrichtEncrypted((char*)&val, 4);
+					tmp->set(val, j);
+				}
+				else
+				{
+					char län = 0;
+					k->getNachrichtEncrypted(&län, 1);
+					char* n = new char[län + 1];
+					n[län] = 0;
+					if (län)
+						k->getNachrichtEncrypted(n, län);
+					namen->set(new Text(n), i);
+					delete[] n;
+				}
+			}
+			werte->set(tmp, i);
+		}
+		cs.unlock();
+		return 1;
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+	}
+	cs.unlock();
+	return 0;
 }
 
 // Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
 //  account: Die Id des Accounts
 //  Gibt bei misserfolg 0 zurück
-Array< SpielHistorieDaten > *InformationClient::getSpielHistorieDaten( int account )
+Array< SpielHistorieDaten >* InformationClient::getSpielHistorieDaten(int account)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x28", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        Array< SpielHistorieDaten > *daten = new Array< SpielHistorieDaten >();
-        k->sendeEncrypted( (char *)&account, 4 );
-        char anz = 0;
-        k->getNachrichtEncrypted( &anz, 1 );
-        for( char i = 0; i < anz; i++ )
-        {
-            SpielHistorieDaten spiel;
-            k->getNachrichtEncrypted( (char *)&spiel.id, 4 );
-            k->getNachrichtEncrypted( (char *)&spiel.karteId, 4 );
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            char *txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.spiel = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.karte = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.datum = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.status = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.dauer = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.spielStatus = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            spiel.gewinner = txt;
-            delete[] txt;
-            k->getNachrichtEncrypted( (char *)&spiel.sAnzahl, 4 );
-            char tAnz = 0;
-            k->getNachrichtEncrypted( &tAnz, 1 );
-            for( char j = 0; j < tAnz; j++ )
-            {
-                SpielHistorieTeamDaten team;
-                char län = 0;
-                k->getNachrichtEncrypted( &län, 1 );
-                char *txt = new char[ län + 1 ];
-                txt[ län ] = 0;
-                if( län )
-                    k->getNachrichtEncrypted( txt, län );
-                team.name = txt;
-                delete[] txt;
-                k->getNachrichtEncrypted( (char *)&team.sAnzahl, 4 );
-                k->getNachrichtEncrypted( &län, 1 );
-                txt = new char[ län + 1 ];
-                txt[ län ] = 0;
-                if( län )
-                    k->getNachrichtEncrypted( txt, län );
-                team.status = txt;
-                delete[] txt;
-                k->getNachrichtEncrypted( (char *)&team.farbe, 4 );
-                char sAnz = 0;
-                k->getNachrichtEncrypted( &sAnz, 1 );
-                for( char ki = 0; ki < sAnz; ki++ )
-                {
-                    SpielHistorieSpielerDaten spieler;
-                    char län = 0;
-                    k->getNachrichtEncrypted( &län, 1 );
-                    char *txt = new char[ län + 1 ];
-                    txt[ län ] = 0;
-                    if( län )
-                        k->getNachrichtEncrypted( txt, län );
-                    spieler.name = txt;
-                    delete[] txt;
-                    k->getNachrichtEncrypted( (char *)&spieler.punkte, 4 );
-                    k->getNachrichtEncrypted( &län, 1 );
-                    txt = new char[ län + 1 ];
-                    txt[ län ] = 0;
-                    if( län )
-                        k->getNachrichtEncrypted( txt, län );
-                    spieler.status = txt;
-                    delete[] txt;
-                    k->getNachrichtEncrypted( (char *)&spieler.farbe, 4 );
-                    team.spieler.add( spieler );
-                }
-                spiel.teams.add( team );
-            }
-            daten->add( spiel );
-        }
-        cs.unlock();
-        return daten;
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x28", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		Array< SpielHistorieDaten >* daten = new Array< SpielHistorieDaten >();
+		k->sendeEncrypted((char*)&account, 4);
+		char anz = 0;
+		k->getNachrichtEncrypted(&anz, 1);
+		for (char i = 0; i < anz; i++)
+		{
+			SpielHistorieDaten spiel;
+			k->getNachrichtEncrypted((char*)&spiel.id, 4);
+			k->getNachrichtEncrypted((char*)&spiel.karteId, 4);
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			char* txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.spiel = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.karte = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.datum = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.status = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.dauer = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.spielStatus = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			spiel.gewinner = txt;
+			delete[] txt;
+			k->getNachrichtEncrypted((char*)&spiel.sAnzahl, 4);
+			char tAnz = 0;
+			k->getNachrichtEncrypted(&tAnz, 1);
+			for (char j = 0; j < tAnz; j++)
+			{
+				SpielHistorieTeamDaten team;
+				char län = 0;
+				k->getNachrichtEncrypted(&län, 1);
+				char* txt = new char[län + 1];
+				txt[län] = 0;
+				if (län)
+					k->getNachrichtEncrypted(txt, län);
+				team.name = txt;
+				delete[] txt;
+				k->getNachrichtEncrypted((char*)&team.sAnzahl, 4);
+				k->getNachrichtEncrypted(&län, 1);
+				txt = new char[län + 1];
+				txt[län] = 0;
+				if (län)
+					k->getNachrichtEncrypted(txt, län);
+				team.status = txt;
+				delete[] txt;
+				k->getNachrichtEncrypted((char*)&team.farbe, 4);
+				char sAnz = 0;
+				k->getNachrichtEncrypted(&sAnz, 1);
+				for (char ki = 0; ki < sAnz; ki++)
+				{
+					SpielHistorieSpielerDaten spieler;
+					char län = 0;
+					k->getNachrichtEncrypted(&län, 1);
+					char* txt = new char[län + 1];
+					txt[län] = 0;
+					if (län)
+						k->getNachrichtEncrypted(txt, län);
+					spieler.name = txt;
+					delete[] txt;
+					k->getNachrichtEncrypted((char*)&spieler.punkte, 4);
+					k->getNachrichtEncrypted(&län, 1);
+					txt = new char[län + 1];
+					txt[län] = 0;
+					if (län)
+						k->getNachrichtEncrypted(txt, län);
+					spieler.status = txt;
+					delete[] txt;
+					k->getNachrichtEncrypted((char*)&spieler.farbe, 4);
+					team.spieler.add(spieler);
+				}
+				spiel.teams.add(team);
+			}
+			daten->add(spiel);
+		}
+		cs.unlock();
+		return daten;
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
 //  spielId: Die id des Spiels
 //  Gibt bei misserfolg 0 zurück
-HistorieServerClient *InformationClient::createHistorieServerClient( int spielId )
+HistorieServerClient* InformationClient::createHistorieServerClient(int spielId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x29", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&spielId, 4 );
-        k->getNachrichtEncrypted( (char *)&ret, 1 );
-        if( ret == 1 )
-        {
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            char *ip = new char[ län + 1 ];
-            ip[ län ] = 0;
-            k->getNachrichtEncrypted( ip, län );
-            HistorieClient *ret = new HistorieClient( cId, port, ip, key, keyLen, spielId );
-            delete[] ip;
-            cs.unlock();
-            return ret;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x29", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&spielId, 4);
+		k->getNachrichtEncrypted((char*)&ret, 1);
+		if (ret == 1)
+		{
+			k->getNachrichtEncrypted((char*)&port, 4);
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			ip[län] = 0;
+			k->getNachrichtEncrypted(ip, län);
+			HistorieClient* ret = new HistorieClient(cId, port, ip, key, keyLen, spielId);
+			delete[] ip;
+			cs.unlock();
+			return ret;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // sucht nach dem Historie Server von einem Spiel
 // Prüft, ob der Account bestimmte Berechtigungen besitzt
 //  recht: Die Id der Berechtigungen
-bool InformationClient::hatRecht( int recht )
+bool InformationClient::hatRecht(int recht)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x2D", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&recht, 4 );
-        k->getNachrichtEncrypted( (char *)&ret, 1 );
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-    }
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x2D", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&recht, 4);
+		k->getNachrichtEncrypted((char*)&ret, 1);
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+	}
+	cs.unlock();
+	return ret == 1;
 }
 
 // Prüft ob Berechtigung vorhanden
@@ -1840,169 +1840,169 @@ bool InformationClient::hatRecht( int recht )
 //  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
 //  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
 //  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
-int InformationClient::getKartenListe( 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 )
+int InformationClient::getKartenListe(const char* filter, char sortSpalte, char absteigend, Framework::Array< int >* kId, Framework::RCArray< Framework::Text >* kName, Framework::RCArray< Framework::Text >* sName,
+	Framework::Array< int >* kupfer, Framework::Array< int >* verkauft, Framework::Array< int >* maxSpieler)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x2E", 1 );
-    char res = 0;
-    k->getNachrichtEncrypted( &res, 1 );
-    int ret = 0;
-    if( res == 1 )
-    {
-        char län = textLength( filter );
-        k->sendeEncrypted( &län, 1 );
-        k->sendeEncrypted( filter, län );
-        k->sendeEncrypted( &sortSpalte, 1 );
-        k->sendeEncrypted( &absteigend, 1 );
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        for( int i = 0; i < ret; i++ )
-        {
-            int val = 0;
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            kId->set( val, i );
-            k->getNachrichtEncrypted( &län, 1 );
-            char *txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            kName->set( new Text( txt ), i );
-            delete[] txt;
-            k->getNachrichtEncrypted( &län, 1 );
-            txt = new char[ län + 1 ];
-            txt[ län ] = 0;
-            if( län )
-                k->getNachrichtEncrypted( txt, län );
-            sName->set( new Text( txt ), i );
-            delete[] txt;
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            kupfer->set( val, i );
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            verkauft->set( val, i );
-            k->getNachrichtEncrypted( (char *)&val, 4 );
-            maxSpieler->set( val, i );
-        }
-    }
-    if( res == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-    }
-    cs.unlock();
-    return ret;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x2E", 1);
+	char res = 0;
+	k->getNachrichtEncrypted(&res, 1);
+	int ret = 0;
+	if (res == 1)
+	{
+		char län = textLength(filter);
+		k->sendeEncrypted(&län, 1);
+		k->sendeEncrypted(filter, län);
+		k->sendeEncrypted(&sortSpalte, 1);
+		k->sendeEncrypted(&absteigend, 1);
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		for (int i = 0; i < ret; i++)
+		{
+			int val = 0;
+			k->getNachrichtEncrypted((char*)&val, 4);
+			kId->set(val, i);
+			k->getNachrichtEncrypted(&län, 1);
+			char* txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			kName->set(new Text(txt), i);
+			delete[] txt;
+			k->getNachrichtEncrypted(&län, 1);
+			txt = new char[län + 1];
+			txt[län] = 0;
+			if (län)
+				k->getNachrichtEncrypted(txt, län);
+			sName->set(new Text(txt), i);
+			delete[] txt;
+			k->getNachrichtEncrypted((char*)&val, 4);
+			kupfer->set(val, i);
+			k->getNachrichtEncrypted((char*)&val, 4);
+			verkauft->set(val, i);
+			k->getNachrichtEncrypted((char*)&val, 4);
+			maxSpieler->set(val, i);
+		}
+	}
+	if (res == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+	}
+	cs.unlock();
+	return ret;
 }
 
 // Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
 //  karteId: Die Id der Karte
 //  Gibt bei misserfolg 0 zurück
-EditorServerClient *InformationClient::createEditorServerClient( int karteId )
+EditorServerClient* InformationClient::createEditorServerClient(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x2F", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&karteId, 4 );
-        k->getNachrichtEncrypted( (char *)&ret, 1 );
-        if( ret == 1 )
-        {
-            int port = 0;
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            char *ip = new char[ län + 1 ];
-            ip[ län ] = 0;
-            k->getNachrichtEncrypted( ip, län );
-            EditorClient *ret = new EditorClient( cId, (unsigned short)port, ip, this->key, this->keyLen );
-            delete[] ip;
-            cs.unlock();
-            return ret;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x2F", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&karteId, 4);
+		k->getNachrichtEncrypted((char*)&ret, 1);
+		if (ret == 1)
+		{
+			int port = 0;
+			k->getNachrichtEncrypted((char*)&port, 4);
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			ip[län] = 0;
+			k->getNachrichtEncrypted(ip, län);
+			EditorClient* ret = new EditorClient(cId, (unsigned short)port, ip, this->key, this->keyLen);
+			delete[] ip;
+			cs.unlock();
+			return ret;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
 //  karteId: Die Id der Karte
 //  Gibt bei misserfolg 0 zurück
-KartenServerClient *InformationClient::createKartenServerClient( int karteId )
+KartenServerClient* InformationClient::createKartenServerClient(int karteId)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x30", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&karteId, 4 );
-        k->getNachrichtEncrypted( (char *)&ret, 1 );
-        if( ret == 1 )
-        {
-            int port = 0;
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            char län = 0;
-            k->getNachrichtEncrypted( &län, 1 );
-            char *ip = new char[ län + 1 ];
-            ip[ län ] = 0;
-            k->getNachrichtEncrypted( ip, län );
-            KartenClient *ret = new KartenClient( cId, (unsigned short)port, ip, this->key, this->keyLen );
-            delete[] ip;
-            cs.unlock();
-            return ret;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x30", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&karteId, 4);
+		k->getNachrichtEncrypted((char*)&ret, 1);
+		if (ret == 1)
+		{
+			int port = 0;
+			k->getNachrichtEncrypted((char*)&port, 4);
+			char län = 0;
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			ip[län] = 0;
+			k->getNachrichtEncrypted(ip, län);
+			KartenClient* ret = new KartenClient(cId, (unsigned short)port, ip, this->key, this->keyLen);
+			delete[] ip;
+			cs.unlock();
+			return ret;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erhält die Verbindung aufrecht
@@ -2010,81 +2010,81 @@ KartenServerClient *InformationClient::createKartenServerClient( int karteId )
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool InformationClient::keepAlive()
 {
-    if( !cs.tryLock() )
-        return 1;
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char res = 0;
-    bool ok = k->sendeEncrypted( "\x2C", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-        trenne( 0 );
-    return res == 1;
+	if (!cs.tryLock())
+		return 1;
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char res = 0;
+	bool ok = k->sendeEncrypted("\x2C", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+		trenne(0);
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool InformationClient::trenne( bool abmelden )
+bool InformationClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Information Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Information Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Information Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Information Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool InformationClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *InformationClient::getLetzterFehler() const
+const char* InformationClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/InformationClient.h

@@ -5,228 +5,228 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um informationen über Accounts abzufragen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class InformationClient : public InformationServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird verwendet um informationen über Accounts abzufragen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class InformationClient : public InformationServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        InformationClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~InformationClient();
-        // verbindet ich mit dem zugewiesenen Informaion Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // fragt nach dem Informationstext
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
-        //  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
-        bool getInformationText( Framework::Text *txt, int *typ ) override;
-        // fragt, ob das entsprechende Spiel vom Server gesperrt wurde
-        //  spielId: Die Id des Spiels
-        //  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
-        bool istSpielErlaubt( int spielId ) override;
-        // fragt, ob die entsprechende Karte vom Server gesperrt wurde
-        //  karteId: Die Id der Karte
-        //  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
-        bool istKarteErlaubt( int karteId ) override;
-        // Ermittelt die Id einer Karte
-        //  name: Der Name der Karte
-        //  Gibt bei misserfolg 0 zurück
-        int getKarteId( char *name ) override;
-        // Fragt nach der Id eines Spiels
-        //  name: Der Name des Spiels
-        //  Gibt bei misserfolg 0 zurück
-        int getSpielId( char *name ) override;
-        // fragt nach dem Namen eines Accounts
-        //  accountId: Die Id des Accounts
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Text *getSpielerName( int accountId ) override;
-        // fragt nach der Spiel Statistik eines Accounts
-        //  accountId: Die Id des Accounts
-        //  spielId: Die Id des Spiels
-        //  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
-        bool getSpielStatistik( int accountId, int spielId, Framework::Array< int > *werte ) override;
-        // fragt nach dem Namen einer Karte
-        //  karteId: Die id der Karte
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Text *getKarteName( int karteId ) override;
-        // fragt nach dem Namen eines Spiels
-        //  spielId: Die id des Spiels
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Text *getSpielName( int spielId ) override;
-        // fragt nach dem Namen eines Chatrooms
-        //  chatroomId: Die id des Chatrooms
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Text *getChatroomName( int chatroomId ) override;
-        // fragt zu welcher Spielart die Karte gehört
-        //  karteId: Die id der Karte
-        //  Gibt bei misserfolg 0 zurück
-        int getSpielId( int karteId ) override;
-        // gibt die Id eines Accounts zurück
-        //  name: Der Angezeigte Name des Accounts
-        //  Gibt bei misserfolg 0 zurück
-        int getAccountId( char *name ) override;
-        // gibt die Id des Chatrooms zurück
-        //  name: Der name des Chatrooms
-        //  Gibt bei misserfolg 0 zurück
-        int getChatroomId( char *name ) override;
-        // gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
-        //  gruppenId: Die id der Gruppe
-        //  Gibt bei misserfolg 0 zurück
-        int getGruppenKarteId( int gruppenId ) override;
-        // gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
-        //  gruppeId: Die id der Gruppe
-        bool getGruppeSpielerHinzufügen( int gruppeId ) override;
-        // gibt die Account Id des Gruppen Administrators zurück
-        //  gruppeId: Die Id der Gruppe
-        //  Gibt bei misserfolg 0 zurück
-        int getGruppeAdminId( int gruppeId ) override;
-        // gibt die Punkte eines Spielers zurück
-        //  accountId: Die Accont Id des Spielers
-        //  spielId: Die Id des Spiels
-        //  Gibt bei misserfolg 0 zurück
-        int getSpielerPunkte( int accountId, int spielId ) override;
-        // gibt eine Liste mit Ids von gekauften Spielen zurück
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Array< int > *getAccountSpielArtListe() override;
-        // gibt die neuste Version eines Spiels zurück
-        //  spielId: Die Id des Spiels
-        //  Gibt bei misserfolg 0 zurück
-        int getSpielVersion( int spielId ) override;
-        // gibt das Kupfer des Accounts zurück
-        //  Gibt bei misserfolg 0 zurück
-        int getKupfer() override;
-        // Gibt die Dateigruppem Id eines Spieles zurück
-        //  spielId: Die Id des Spiels
-        //  Gibt bei misserfolg 0 zurück
-        int getDateiGruppeIdVonSpiel( int spielId ) override;
-        // Gibt den Dateigruppen Pfad zurück
-        //  dgId: Die Id der Dateigruppe
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Text *getDateiGruppePfad( int dgId ) override;
-        // gibt eine Liste mit gekauften Karten zurück
-        //  spielId: Die Spiel Id zu der die Karten gehören sollen
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Array< int > *getAccountKarteListe( int spielId ) override;
-        // Gibt die Dateigruppen Id eines Pfades zurück
-        //  pfad: Der Pfad der Dateigruppe
-        //  Gibt bei misserfolg 0 zurück
-        int getDateiGruppeIdVonPfad( char *pfad ) override;
-        // gibt die neuste Version einer Dateigruppe zurück
-        //  dg: Die Dateigruppen Id
-        //  Gibt bei misserfolg 0 zurück
-        int getDateiGruppeVersion( int dg ) override;
-        // Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
-        //  suche: Der Text, der in den Namen enthalten sein soll
-        //  seite: Die gewünschte Seite der Tabelle (enthält nach einem Erfolgreichen Aufruf die korrekte Seite)
-        //  maxSeite: Enthält nach erfolgreichem Aufruf die Maximale Seite
-        //  sortSpalte: Die Spalte, nach der Sortiert werden soll
-        //  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
-        //  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
-        //  Gibt die Anzahl der gefundenen Accounts zurück
-        //  Gibt die Anzahl der Spieler zurück, -1 bei fehler
-        int getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo > *accounts ) override;
-        // ermittelt die aktivität eines Spielers
-        //  accId: Die Id des Accounts
-        //  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
-        bool getSpielerAktivität( int accId, Framework::Array< AccountActivityInfo > *info ) override;
-        // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
-        //  account: Die Id des Accounts
-        //  karte: Die Id der Karte
-        int getAccountKarteSpiele( int account, int karte ) override;
-        // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
-        //  account: Die Id des Accounts
-        //  karte: Die Id der Karte
-        int getAccountKarteSpieleGewonnen( int account, int karte ) override;
-        // Gibt zurück, ob ein Spieler die Karte im Besitz hat
-        //  account: Die Id des Accounts
-        //  karte: Die Id der Karte
-        bool hatAccountKarte( int account, int karte ) override;
-        // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
-        //  account: Die Id des Accounts
-        //  spiel: Die Id des Spiels
-        bool hatAccountSpiel( int account, int spiel ) override;
-        // gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
-        //  account: Die Id des Accounts
-        //  spiel: Die Id des Spiels 
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Array< int > *getAccountKarteGespieltListe( int account, int spielId ) override;
-        // gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
-        //  account: Die Id des Accounts
-        //  Gibt bei misserfolg 0 zurück
-        Framework::Array< int > *getAccountSpielGespieltListe( int account ) override;
-        // Gibt eine Liste von Spiel Partnern eines Spielers zurück
-        //  account: Die Id des Accounts
-        //  spieler: Enthält nach erfolgreichem Aufruf eine Liste mit Account Ids der Spiel Partner
-        //  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
-        //  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool getSpielPartnerListe( int account, Framework::Array< int > *spieler, Framework::Array< int > *karten, Framework::Array< int > *anzahl ) override;
-        // Gibt eine Liste mit Spiel Statistiken zurück
-        //  account: Die Id des Accounts zu dem die Statistik ermittelt werden soll
-        //  seite: Die gewünschte Seite. Enthält nach efolgreichem Aufruf die korrekte Seite
-        //  maxSeite: Enthält nach erfolgreichem Aufruf die Macimale Seite
-        //  sortSpalte: Die Spalte, nach der Sortiert werden soll
-        //  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
-        //  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
-        //  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts,
-                                Framework::RCArray< Framework::Array< int > > *werte, Framework::RCArray< Framework::Text > *namen ) override;
-        // Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
-        //  account: Die Id des Accounts
-        //  Gibt bei misserfolg 0 zurück
-        Array< SpielHistorieDaten > *getSpielHistorieDaten( int account ) override;
-        // Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
-        //  spielId: Die id des Spiels
-        //  Gibt bei misserfolg 0 zurück
-        HistorieServerClient *createHistorieServerClient( int spielId ) override; // sucht nach dem Historie Server von einem Spiel
-                                                                                     // Prüft, ob der Account bestimmte Berechtigungen besitzt
-                                                                                     //  recht: Die Id der Berechtigungen
-        bool hatRecht( int recht ) override; // Prüft ob Berechtigung vorhanden
-                                                // Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist
-                                                //  filter: Die Zeichenkette, die im Namen Auftreten soll
-                                                //  sortSpalte: Der Index der Spalte, nach der sortiert werden soll
-                                                //  absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung
-                                                //  kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält
-                                                //  kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält
-                                                //  sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält
-                                                //  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
-                                                //  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
-                                                //  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
-        int 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 ) override;
-        // Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
-        //  karteId: Die Id der Karte
-        //  Gibt bei misserfolg 0 zurück
-        EditorServerClient *createEditorServerClient( int karteId ) override;
-        // Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
-        //  karteId: Die Id der Karte
-        //  Gibt bei misserfolg 0 zurück
-        KartenServerClient *createKartenServerClient( int karteId ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		InformationClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~InformationClient();
+		// verbindet ich mit dem zugewiesenen Informaion Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// fragt nach dem Informationstext
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  txt: Ein Zeiger auf ein Text Objekt, welches bei einem erfolgreichen Aufruf den Informationstext enthält
+		//  typ: ein Zeieger auf ein Integer, welches bei einem erfolgreichen Aufruf den Typ der Information enthält
+		bool getInformationText(Framework::Text* txt, int* typ) override;
+		// fragt, ob das entsprechende Spiel vom Server gesperrt wurde
+		//  spielId: Die Id des Spiels
+		//  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
+		bool istSpielErlaubt(int spielId) override;
+		// fragt, ob die entsprechende Karte vom Server gesperrt wurde
+		//  karteId: Die Id der Karte
+		//  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
+		bool istKarteErlaubt(int karteId) override;
+		// Ermittelt die Id einer Karte
+		//  name: Der Name der Karte
+		//  Gibt bei misserfolg 0 zurück
+		int getKarteId(const char* name) override;
+		// Fragt nach der Id eines Spiels
+		//  name: Der Name des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		int getSpielId(const char* name) override;
+		// fragt nach dem Namen eines Accounts
+		//  accountId: Die Id des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Text* getSpielerName(int accountId) override;
+		// fragt nach der Spiel Statistik eines Accounts
+		//  accountId: Die Id des Accounts
+		//  spielId: Die Id des Spiels
+		//  werte: Nach erfolgreichem Aufruf enthält die Liste die Statistik werte (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+		bool getSpielStatistik(int accountId, int spielId, Framework::Array< int >* werte) override;
+		// fragt nach dem Namen einer Karte
+		//  karteId: Die id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Text* getKarteName(int karteId) override;
+		// fragt nach dem Namen eines Spiels
+		//  spielId: Die id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Text* getSpielName(int spielId) override;
+		// fragt nach dem Namen eines Chatrooms
+		//  chatroomId: Die id des Chatrooms
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Text* getChatroomName(int chatroomId) override;
+		// fragt zu welcher Spielart die Karte gehört
+		//  karteId: Die id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		int getSpielId(int karteId) override;
+		// gibt die Id eines Accounts zurück
+		//  name: Der Angezeigte Name des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		int getAccountId(const char* name) override;
+		// gibt die Id des Chatrooms zurück
+		//  name: Der name des Chatrooms
+		//  Gibt bei misserfolg 0 zurück
+		int getChatroomId(const char* name) override;
+		// gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
+		//  gruppenId: Die id der Gruppe
+		//  Gibt bei misserfolg 0 zurück
+		int getGruppenKarteId(int gruppenId) override;
+		// gibt 1 zurück, wenn zu einer Gruppe Spieler hinzugefügt werden können, 0 sonnst
+		//  gruppeId: Die id der Gruppe
+		bool getGruppeSpielerHinzufügen(int gruppeId) override;
+		// gibt die Account Id des Gruppen Administrators zurück
+		//  gruppeId: Die Id der Gruppe
+		//  Gibt bei misserfolg 0 zurück
+		int getGruppeAdminId(int gruppeId) override;
+		// gibt die Punkte eines Spielers zurück
+		//  accountId: Die Accont Id des Spielers
+		//  spielId: Die Id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		int getSpielerPunkte(int accountId, int spielId) override;
+		// gibt eine Liste mit Ids von gekauften Spielen zurück
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Array< int >* getAccountSpielArtListe() override;
+		// gibt die neuste Version eines Spiels zurück
+		//  spielId: Die Id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		int getSpielVersion(int spielId) override;
+		// gibt das Kupfer des Accounts zurück
+		//  Gibt bei misserfolg 0 zurück
+		int getKupfer() override;
+		// Gibt die Dateigruppem Id eines Spieles zurück
+		//  spielId: Die Id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		int getDateiGruppeIdVonSpiel(int spielId) override;
+		// Gibt den Dateigruppen Pfad zurück
+		//  dgId: Die Id der Dateigruppe
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Text* getDateiGruppePfad(int dgId) override;
+		// gibt eine Liste mit gekauften Karten zurück
+		//  spielId: Die Spiel Id zu der die Karten gehören sollen
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Array< int >* getAccountKarteListe(int spielId) override;
+		// Gibt die Dateigruppen Id eines Pfades zurück
+		//  pfad: Der Pfad der Dateigruppe
+		//  Gibt bei misserfolg 0 zurück
+		int getDateiGruppeIdVonPfad(const char* pfad) override;
+		// gibt die neuste Version einer Dateigruppe zurück
+		//  dg: Die Dateigruppen Id
+		//  Gibt bei misserfolg 0 zurück
+		int getDateiGruppeVersion(int dg) override;
+		// Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
+		//  suche: Der Text, der in den Namen enthalten sein soll
+		//  seite: Die gewünschte Seite der Tabelle (enthält nach einem Erfolgreichen Aufruf die korrekte Seite)
+		//  maxSeite: Enthält nach erfolgreichem Aufruf die Maximale Seite
+		//  sortSpalte: Die Spalte, nach der Sortiert werden soll
+		//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+		//  accounts: Enthält nach erfolgreichem Aufruf die Daten der Accounts
+		//  Gibt die Anzahl der gefundenen Accounts zurück
+		//  Gibt die Anzahl der Spieler zurück, -1 bei fehler
+		int getSpielerListe(const char* suche, int* seite, int* maxSeite, char sortSpalte, char rückwärts, Framework::Array< AccountInfo >* accounts) override;
+		// ermittelt die aktivität eines Spielers
+		//  accId: Die Id des Accounts
+		//  info: Enthält nach erfolgreichem Aufruf die Aktivitätsinformationen der letzten 30 Tage
+		bool getSpielerAktivität(int accId, Framework::Array< AccountActivityInfo >* info) override;
+		// Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
+		//  account: Die Id des Accounts
+		//  karte: Die Id der Karte
+		int getAccountKarteSpiele(int account, int karte) override;
+		// Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
+		//  account: Die Id des Accounts
+		//  karte: Die Id der Karte
+		int getAccountKarteSpieleGewonnen(int account, int karte) override;
+		// Gibt zurück, ob ein Spieler die Karte im Besitz hat
+		//  account: Die Id des Accounts
+		//  karte: Die Id der Karte
+		bool hatAccountKarte(int account, int karte) override;
+		// Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
+		//  account: Die Id des Accounts
+		//  spiel: Die Id des Spiels
+		bool hatAccountSpiel(int account, int spiel) override;
+		// gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
+		//  account: Die Id des Accounts
+		//  spiel: Die Id des Spiels 
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Array< int >* getAccountKarteGespieltListe(int account, int spielId) override;
+		// gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
+		//  account: Die Id des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		Framework::Array< int >* getAccountSpielGespieltListe(int account) override;
+		// Gibt eine Liste von Spiel Partnern eines Spielers zurück
+		//  account: Die Id des Accounts
+		//  spieler: Enthält nach erfolgreichem Aufruf eine Liste mit Account Ids der Spiel Partner
+		//  karten: Enthält nach erfolgreichem Aufruf eine Liste mit den Ids der gespielten Karten
+		//  anzahl: Enthält nach erfolgreichem Aufruf eine Liste mit der Anzahl der Spiele
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool getSpielPartnerListe(int account, Framework::Array< int >* spieler, Framework::Array< int >* karten, Framework::Array< int >* anzahl) override;
+		// Gibt eine Liste mit Spiel Statistiken zurück
+		//  account: Die Id des Accounts zu dem die Statistik ermittelt werden soll
+		//  seite: Die gewünschte Seite. Enthält nach efolgreichem Aufruf die korrekte Seite
+		//  maxSeite: Enthält nach erfolgreichem Aufruf die Macimale Seite
+		//  sortSpalte: Die Spalte, nach der Sortiert werden soll
+		//  rückwärts: 1:=Rückwärtzt Sortierung, 0:=Vorwärts Sortierung
+		//  werte: Enthält nach erfolgreichem Aufruf eine Liste mit Statistik Werten (gespielt, gewonnen, verloren, punkte, bw0, bw1, bw2, bw3, bw4, bw5)
+		//  namen: Enthält nach erfolgreichem Aufruf die Namen der Spiele
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool getStatistikListe(int account, int* seite, int* maxSeite, char sortSpalte, char rückwärts,
+			Framework::RCArray< Framework::Array< int > >* werte, Framework::RCArray< Framework::Text >* namen) override;
+		// Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück
+		//  account: Die Id des Accounts
+		//  Gibt bei misserfolg 0 zurück
+		Array< SpielHistorieDaten >* getSpielHistorieDaten(int account) override;
+		// Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
+		//  spielId: Die id des Spiels
+		//  Gibt bei misserfolg 0 zurück
+		HistorieServerClient* createHistorieServerClient(int spielId) override; // sucht nach dem Historie Server von einem Spiel
+		// Prüft, ob der Account bestimmte Berechtigungen besitzt
+		//  recht: Die Id der Berechtigungen
+		bool hatRecht(int recht) override; // Prüft ob Berechtigung vorhanden
+		// Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist
+		//  filter: Die Zeichenkette, die im Namen Auftreten soll
+		//  sortSpalte: Der Index der Spalte, nach der sortiert werden soll
+		//  absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung
+		//  kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält
+		//  kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält
+		//  sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält
+		//  kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer
+		//  verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält
+		//  maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält
+		int getKartenListe(const char* filter, char sortSpalte, char absteigend, Framework::Array< int >* kId, Framework::RCArray< Framework::Text >* kName, Framework::RCArray< Framework::Text >* sName,
+			Framework::Array< int >* kupfer, Framework::Array< int >* verkauft, Framework::Array< int >* maxSpieler) override;
+		// Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
+		//  karteId: Die Id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		EditorServerClient* createEditorServerClient(int karteId) override;
+		// Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id
+		//  karteId: Die Id der Karte
+		//  Gibt bei misserfolg 0 zurück
+		KartenServerClient* createKartenServerClient(int karteId) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/KSGNetwork.vcxproj

@@ -28,26 +28,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
+    <PlatformToolset>v143</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>

KSGNetwork/KartenClient.cpp

@@ -9,419 +9,419 @@ using namespace KSGClient;
 // Inhalt der KartenClient Klasse
 
 // Konstruktor
-KartenClient::KartenClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+KartenClient::KartenClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 KartenClient::~KartenClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Karten Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool KartenClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::KARTEN, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::KARTEN, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Karten Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Karten Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Karten Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::KARTEN, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::KARTEN, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Karten Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Karten Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Karten Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool KartenClient::downloadKarte( int id )
+bool KartenClient::downloadKarte(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x6", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 2 )
-        { // update
-            err = "Die Karte wird momentan aktualisiert.";
-            cs.unlock();
-            return 0;
-        }
-        else if( ret == 1 )
-        {
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                char län = 0;
-                k->getNachrichtEncrypted( &län, 1 );
-                if( !län )
-                    continue;
-                char *pf = new char[ län + 1 ];
-                pf[ län ] = 0;
-                k->getNachrichtEncrypted( pf, län );
-                __int64 größe = 0;
-                k->getNachrichtEncrypted( (char *)&größe, 8 );
-                char *buffer = new char[ 2048 ];
-                Text pfad = "data/tmp/Karten/";
-                pfad += id;
-                pfad += "/spiel";
-                pfad += pf;
-                delete[] pf;
-                Datei d;
-                d.setDatei( pfad );
-                d.erstellen();
-                d.open( Datei::Style::schreiben );
-                while( größe )
-                {
-                    int l = größe >= 2048 ? 2048 : (int)größe;
-                    k->getNachricht( buffer, l );
-                    d.schreibe( buffer, l );
-                    größe -= l;
-                }
-                d.close();
-                delete[] buffer;
-            }
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x6", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 2)
+		{ // update
+			err = "Die Karte wird momentan aktualisiert.";
+			cs.unlock();
+			return 0;
+		}
+		else if (ret == 1)
+		{
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				char län = 0;
+				k->getNachrichtEncrypted(&län, 1);
+				if (!län)
+					continue;
+				char* pf = new char[län + 1];
+				pf[län] = 0;
+				k->getNachrichtEncrypted(pf, län);
+				__int64 größe = 0;
+				k->getNachrichtEncrypted((char*)&größe, 8);
+				char* buffer = new char[2048];
+				Text pfad = "data/tmp/Karten/";
+				pfad += id;
+				pfad += "/spiel";
+				pfad += pf;
+				delete[] pf;
+				Datei d;
+				d.setDatei(pfad);
+				d.erstellen();
+				d.open(Datei::Style::schreiben);
+				while (größe)
+				{
+					int l = größe >= 2048 ? 2048 : (int)größe;
+					k->getNachricht(buffer, l);
+					d.schreibe(buffer, l);
+					größe -= l;
+				}
+				d.close();
+				delete[] buffer;
+			}
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool KartenClient::downloadKarteTitel( int id )
+bool KartenClient::downloadKarteTitel(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x8", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 2 )
-        { // update
-            err = "Die Karte wird momentan aktualisiert.";
-            cs.unlock();
-            return 0;
-        }
-        else if( ret == 1 )
-        {
-            __int64 größe = 0;
-            k->getNachrichtEncrypted( (char *)&größe, 8 );
-            char *buffer = new char[ 2048 ];
-            Text pfad = "data/tmp/Karten/";
-            pfad += id;
-            pfad += "/titel.ltdb";
-            Datei d;
-            d.setDatei( pfad );
-            d.erstellen();
-            d.open( Datei::Style::schreiben );
-            while( größe )
-            {
-                int l = größe >= 2048 ? 2048 : (int)größe;
-                k->getNachricht( buffer, l );
-                d.schreibe( buffer, l );
-                größe -= l;
-            }
-            d.close();
-            delete[] buffer;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x8", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 2)
+		{ // update
+			err = "Die Karte wird momentan aktualisiert.";
+			cs.unlock();
+			return 0;
+		}
+		else if (ret == 1)
+		{
+			__int64 größe = 0;
+			k->getNachrichtEncrypted((char*)&größe, 8);
+			char* buffer = new char[2048];
+			Text pfad = "data/tmp/Karten/";
+			pfad += id;
+			pfad += "/titel.ltdb";
+			Datei d;
+			d.setDatei(pfad);
+			d.erstellen();
+			d.open(Datei::Style::schreiben);
+			while (größe)
+			{
+				int l = größe >= 2048 ? 2048 : (int)größe;
+				k->getNachricht(buffer, l);
+				d.schreibe(buffer, l);
+				größe -= l;
+			}
+			d.close();
+			delete[] buffer;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool KartenClient::downloadKarteBeschreibung( int id )
+bool KartenClient::downloadKarteBeschreibung(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x9", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 2 )
-        { // update
-            err = "Die Karte wird momentan aktualisiert.";
-            cs.unlock();
-            return 0;
-        }
-        else if( ret == 1 )
-        {
-            __int64 größe = 0;
-            k->getNachrichtEncrypted( (char *)&größe, 8 );
-            char *buffer = new char[ 2048 ];
-            Text pfad = "data/tmp/Karten/";
-            pfad += id;
-            pfad += "/beschreibung.ksgs";
-            Datei d;
-            d.setDatei( pfad );
-            d.erstellen();
-            d.open( Datei::Style::schreiben );
-            while( größe )
-            {
-                int l = größe >= 2048 ? 2048 : (int)größe;
-                k->getNachricht( buffer, l );
-                d.schreibe( buffer, l );
-                größe -= l;
-            }
-            d.close();
-            delete[] buffer;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x9", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 2)
+		{ // update
+			err = "Die Karte wird momentan aktualisiert.";
+			cs.unlock();
+			return 0;
+		}
+		else if (ret == 1)
+		{
+			__int64 größe = 0;
+			k->getNachrichtEncrypted((char*)&größe, 8);
+			char* buffer = new char[2048];
+			Text pfad = "data/tmp/Karten/";
+			pfad += id;
+			pfad += "/beschreibung.ksgs";
+			Datei d;
+			d.setDatei(pfad);
+			d.erstellen();
+			d.open(Datei::Style::schreiben);
+			while (größe)
+			{
+				int l = größe >= 2048 ? 2048 : (int)größe;
+				k->getNachricht(buffer, l);
+				d.schreibe(buffer, l);
+				größe -= l;
+			}
+			d.close();
+			delete[] buffer;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool KartenClient::downloadKarteMinimap( int id )
+bool KartenClient::downloadKarteMinimap(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 2 )
-        { // update
-            err = "Die Karte wird momentan aktualisiert.";
-            cs.unlock();
-            return 0;
-        }
-        else if( ret == 1 )
-        {
-            __int64 größe = 0;
-            k->getNachrichtEncrypted( (char *)&größe, 8 );
-            char *buffer = new char[ 2048 ];
-            Text pfad = "data/tmp/Karten/";
-            pfad += id;
-            pfad += "/minimap.ltdb";
-            Datei d;
-            d.setDatei( pfad );
-            d.erstellen();
-            d.open( Datei::Style::schreiben );
-            while( größe )
-            {
-                int l = größe >= 2048 ? 2048 : (int)größe;
-                k->getNachricht( buffer, l );
-                d.schreibe( buffer, l );
-                größe -= l;
-            }
-            d.close();
-            delete[] buffer;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xA", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 2)
+		{ // update
+			err = "Die Karte wird momentan aktualisiert.";
+			cs.unlock();
+			return 0;
+		}
+		else if (ret == 1)
+		{
+			__int64 größe = 0;
+			k->getNachrichtEncrypted((char*)&größe, 8);
+			char* buffer = new char[2048];
+			Text pfad = "data/tmp/Karten/";
+			pfad += id;
+			pfad += "/minimap.ltdb";
+			Datei d;
+			d.setDatei(pfad);
+			d.erstellen();
+			d.open(Datei::Style::schreiben);
+			while (größe)
+			{
+				int l = größe >= 2048 ? 2048 : (int)größe;
+				k->getNachricht(buffer, l);
+				d.schreibe(buffer, l);
+				größe -= l;
+			}
+			d.close();
+			delete[] buffer;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool KartenClient::downloadKarteLadebild( int id )
+bool KartenClient::downloadKarteLadebild(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xB", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 2 )
-        { // update
-            err = "Die Karte wird momentan aktualisiert.";
-            cs.unlock();
-            return 0;
-        }
-        else if( ret == 1 )
-        {
-            __int64 größe = 0;
-            k->getNachrichtEncrypted( (char *)&größe, 8 );
-            char *buffer = new char[ 2048 ];
-            Text pfad = "data/tmp/Karten/";
-            pfad += id;
-            pfad += "/ladebild.ltdb";
-            Datei d;
-            d.setDatei( pfad );
-            d.erstellen();
-            d.open( Datei::Style::schreiben );
-            while( größe )
-            {
-                int l = größe >= 2048 ? 2048 : (int)größe;
-                k->getNachricht( buffer, l );
-                d.schreibe( buffer, l );
-                größe -= l;
-            }
-            d.close();
-            delete[] buffer;
-        }
-    }
-    if( ret == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = f;
-        delete[] f;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xB", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 2)
+		{ // update
+			err = "Die Karte wird momentan aktualisiert.";
+			cs.unlock();
+			return 0;
+		}
+		else if (ret == 1)
+		{
+			__int64 größe = 0;
+			k->getNachrichtEncrypted((char*)&größe, 8);
+			char* buffer = new char[2048];
+			Text pfad = "data/tmp/Karten/";
+			pfad += id;
+			pfad += "/ladebild.ltdb";
+			Datei d;
+			d.setDatei(pfad);
+			d.erstellen();
+			d.open(Datei::Style::schreiben);
+			while (größe)
+			{
+				int l = größe >= 2048 ? 2048 : (int)größe;
+				k->getNachricht(buffer, l);
+				d.schreibe(buffer, l);
+				größe -= l;
+			}
+			d.close();
+			delete[] buffer;
+		}
+	}
+	if (ret == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = f;
+		delete[] f;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Erhält die Verbindung aufrecht
@@ -429,84 +429,84 @@ bool KartenClient::downloadKarteLadebild( int id )
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool KartenClient::keepAlive()
 {
-    if( !k )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    Framework::logLine( (char *)"Verbindungstest zum Karten Server..." );
-    bool ok = k->sendeEncrypted( "\x5", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-        err = "Verbindung unterbrochen: 'Keep Alive' nicht erfolgreich.";
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	if (!k)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	Framework::logLine((char*)"Verbindungstest zum Karten Server...");
+	bool ok = k->sendeEncrypted("\x5", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+		err = "Verbindung unterbrochen: 'Keep Alive' nicht erfolgreich.";
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool KartenClient::trenne( bool abmelden )
+bool KartenClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Karten Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Karten Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Karten Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Karten Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool KartenClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *KartenClient::getLetzterFehler() const
+const char* KartenClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/KartenClient.h

@@ -5,60 +5,60 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class KartenClient : public KartenServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class KartenClient : public KartenServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        KartenClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~KartenClient();
-        // verbindet sich mit dem zugewiesenen Karten Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // 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
-        bool downloadKarte( int id ) override;
-        // 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
-        bool downloadKarteTitel( int id ) override;
-        // 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
-        bool downloadKarteBeschreibung( int id ) override;
-        // 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
-        bool downloadKarteMinimap( int id ) override;
-        // 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
-        bool downloadKarteLadebild( int id ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		KartenClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~KartenClient();
+		// verbindet sich mit dem zugewiesenen Karten Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// 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
+		bool downloadKarte(int id) override;
+		// 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
+		bool downloadKarteTitel(int id) override;
+		// 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
+		bool downloadKarteBeschreibung(int id) override;
+		// 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
+		bool downloadKarteMinimap(int id) override;
+		// 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
+		bool downloadKarteLadebild(int id) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/Keys.cpp

@@ -1,26 +1,26 @@
 #include "Keys.h"
 
-void Keys::getServerKey( char **key, int &length, Keys::Server sTyp, Keys::Key kTyp )
+void Keys::getServerKey(char** key, int& length, Keys::Server sTyp, Keys::Key kTyp)
 {
-    unsigned char keys[][ 20 ] = {
-        { 199, 164, 172, 55, 246, 16, 155, 8, 151, 176, 250, 181, 227, 133, 30, 41, 200, 26, 7, 151 }, // Main
-    { 158, 10, 37, 155, 117, 58, 28, 197, 132, 76, 252, 83, 84, 222, 11, 125, 240, 218, 25, 201 }, // Anmeldung
-    { 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 }, // Chat
-    { 55, 124, 19, 204, 23, 5, 59, 75, 247, 138, 119, 111, 57, 250, 206, 187, 165, 6, 247, 151 }, // Editor
-    { 207, 30, 72, 46, 30, 50, 56, 213, 82, 107, 14, 201, 149, 58, 110, 138, 228, 241, 52, 54 }, // Historie
-    { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 }, // Information
-    { 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 }, // Karten
-    { 143, 166, 245, 235, 76, 75, 116, 80, 26, 178, 142, 176, 109, 53, 106, 222, 223, 55, 139, 111 }, // Login
-    { 4, 150, 243, 145, 204, 71, 253, 88, 4, 51, 189, 207, 189, 248, 231, 40, 106, 7, 182, 5 }, // News
-    { 186, 186, 179, 126, 216, 207, 123, 154, 168, 149, 51, 221, 6, 193, 160, 141, 164, 126, 44, 242 }, // Register
-    { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 }, // Shop
-    { 253, 234, 211, 132, 121, 230, 95, 145, 201, 13, 43, 77, 153, 223, 253, 69, 234, 43, 52, 99 }, // Spiel
-    { 102, 139, 140, 143, 52, 52, 194, 167, 97, 106, 23, 72, 170, 121, 213, 178, 28, 28, 124, 185 }, // Patch
-    { 207, 242, 142, 161, 148, 107, 131, 33, 172, 68, 91, 169, 81, 106, 69, 131, 207, 56, 166, 248 }, // Erhaltung
-    { 88, 103, 192, 232, 69, 54, 57, 3, 239, 138, 234, 172, 126, 72, 81, 55, 205, 97, 59, 255 } // Minigame
-    };
-    length = 20;
-    *key = new char[ 20 ];
-    for( int i = 0; i < 20; i++ )
-        ( *key )[ i ] = keys[ sTyp ][ i ];
+	unsigned char keys[][20] = {
+		{ 199, 164, 172, 55, 246, 16, 155, 8, 151, 176, 250, 181, 227, 133, 30, 41, 200, 26, 7, 151 }, // Main
+	{ 158, 10, 37, 155, 117, 58, 28, 197, 132, 76, 252, 83, 84, 222, 11, 125, 240, 218, 25, 201 }, // Anmeldung
+	{ 78, 20, 190, 133, 10, 175, 51, 96, 62, 1, 180, 194, 126, 50, 211, 154, 105, 227, 22, 101 }, // Chat
+	{ 55, 124, 19, 204, 23, 5, 59, 75, 247, 138, 119, 111, 57, 250, 206, 187, 165, 6, 247, 151 }, // Editor
+	{ 207, 30, 72, 46, 30, 50, 56, 213, 82, 107, 14, 201, 149, 58, 110, 138, 228, 241, 52, 54 }, // Historie
+	{ 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 }, // Information
+	{ 24, 15, 53, 87, 38, 73, 154, 38, 246, 90, 39, 133, 11, 199, 22, 80, 26, 132, 95, 54 }, // Karten
+	{ 143, 166, 245, 235, 76, 75, 116, 80, 26, 178, 142, 176, 109, 53, 106, 222, 223, 55, 139, 111 }, // Login
+	{ 4, 150, 243, 145, 204, 71, 253, 88, 4, 51, 189, 207, 189, 248, 231, 40, 106, 7, 182, 5 }, // News
+	{ 186, 186, 179, 126, 216, 207, 123, 154, 168, 149, 51, 221, 6, 193, 160, 141, 164, 126, 44, 242 }, // Register
+	{ 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 }, // Shop
+	{ 253, 234, 211, 132, 121, 230, 95, 145, 201, 13, 43, 77, 153, 223, 253, 69, 234, 43, 52, 99 }, // Spiel
+	{ 102, 139, 140, 143, 52, 52, 194, 167, 97, 106, 23, 72, 170, 121, 213, 178, 28, 28, 124, 185 }, // Patch
+	{ 207, 242, 142, 161, 148, 107, 131, 33, 172, 68, 91, 169, 81, 106, 69, 131, 207, 56, 166, 248 }, // Erhaltung
+	{ 88, 103, 192, 232, 69, 54, 57, 3, 239, 138, 234, 172, 126, 72, 81, 55, 205, 97, 59, 255 } // Minigame
+	};
+	length = 20;
+	*key = new char[20];
+	for (int i = 0; i < 20; i++)
+		(*key)[i] = keys[sTyp][i];
 }

KSGNetwork/Keys.h

@@ -3,37 +3,37 @@
 class Keys
 {
 public:
-    // Servertypen
-    enum Server
-    {
-        MAIN = 0,
-        ANMELDUNG = 1,
-        CHAT = 2,
-        EDITOR = 3,
-        HISTORIE = 4,
-        INFORMATION = 5,
-        KARTEN = 6,
-        LOGIN = 7,
-        NEWS = 8,
-        REGISTER = 9,
-        SHOP = 10,
-        SPIEL = 11,
-        PATCH = 12,
-        ERHALTUNG = 13,
-        MINIGAME = 14
-    };
+	// Servertypen
+	enum Server
+	{
+		MAIN = 0,
+		ANMELDUNG = 1,
+		CHAT = 2,
+		EDITOR = 3,
+		HISTORIE = 4,
+		INFORMATION = 5,
+		KARTEN = 6,
+		LOGIN = 7,
+		NEWS = 8,
+		REGISTER = 9,
+		SHOP = 10,
+		SPIEL = 11,
+		PATCH = 12,
+		ERHALTUNG = 13,
+		MINIGAME = 14
+	};
 
-    // Keytypen
-    enum Key
-    {
-        EMPFANGEN = 0,
-        SENDEN = 0
-    };
+	// Keytypen
+	enum Key
+	{
+		EMPFANGEN = 0,
+		SENDEN = 0
+	};
 
-    // Gibt den Schlüssel eines Servers zurück
-    //  key: Ein Zeiger auf ein array von bytes. Wird als ausgabe verwendet. Enthält nach aufruf den gewünschten Key
-    //  length: Enthält nach aufruf die Länge des Schlüssels
-    //  sTyp: Der Servertyp, zu dem der Schlüssel ermittelt werden soll
-    //  kTyp: Die art des Schlüssels der ermittelt werden soll
-    static void getServerKey( char **key, int &length, Server sTyp, Key kTyp );
+	// Gibt den Schlüssel eines Servers zurück
+	//  key: Ein Zeiger auf ein array von bytes. Wird als ausgabe verwendet. Enthält nach aufruf den gewünschten Key
+	//  length: Enthält nach aufruf die Länge des Schlüssels
+	//  sTyp: Der Servertyp, zu dem der Schlüssel ermittelt werden soll
+	//  kTyp: Die art des Schlüssels der ermittelt werden soll
+	static void getServerKey(char** key, int& length, Server sTyp, Key kTyp);
 };

KSGNetwork/LoginClient.cpp

@@ -9,223 +9,223 @@ using namespace KSGClient;
 // Inhalt der LoginClient Klasse
 
 // Konstruktor
-LoginClient::LoginClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+LoginClient::LoginClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
-    accountId = 0;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
+	accountId = 0;
 }
 
 // Destruktor
 LoginClient::~LoginClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Login Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool LoginClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::LOGIN, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::LOGIN, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Login Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Login Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Login Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::LOGIN, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::LOGIN, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Login Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Login Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Login Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-int LoginClient::login( const char *name, const char *pass )
+int LoginClient::login(const char* name, const char* pass)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\5", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char byte = (unsigned char)textLength( name );
-        k->sendeEncrypted( (char *)&byte, 1 );
-        k->sendeEncrypted( name, byte );
-        byte = (unsigned char)textLength( pass );
-        k->sendeEncrypted( (char *)&byte, 1 );
-        k->sendeEncrypted( pass, byte );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            char host[ 255 ] = "";
-            Network::getHostName( host, 255 );
-            Text *addresse = new Text( Network::getHostAddresse() );
-            unsigned char localIp[ 4 ];
-            localIp[ 0 ] = TextZuInt( addresse->getText(), 10 );
-            localIp[ 1 ] = TextZuInt( addresse->getText() + addresse->positionVon( '.', 0 ) + 1, 10 );
-            localIp[ 2 ] = TextZuInt( addresse->getText() + addresse->positionVon( '.', 1 ) + 1, 10 );
-            localIp[ 3 ] = TextZuInt( addresse->getText() + addresse->positionVon( '.', 2 ) + 1, 10 );
-            addresse = (Text *)addresse->release();
-            k->sendeEncrypted( (char *)&localIp, 4 );
-            byte = textLength( host );
-            k->sendeEncrypted( (char *)&byte, 1 );
-            k->sendeEncrypted( host, byte );
-            k->getNachrichtEncrypted( (char *)&accountId, 4 );
-            cs.unlock();
-            return 1;
-        }
-        else if( serverReturn == 2 )
-        {
-            k->sendeEncrypted( "\0", 1 );
-            cs.unlock();
-            return 2;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\5", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char byte = (unsigned char)textLength(name);
+		k->sendeEncrypted((char*)&byte, 1);
+		k->sendeEncrypted(name, byte);
+		byte = (unsigned char)textLength(pass);
+		k->sendeEncrypted((char*)&byte, 1);
+		k->sendeEncrypted(pass, byte);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			char host[255] = "";
+			Network::getHostName(host, 255);
+			Text* addresse = new Text(Network::getHostAddresse());
+			unsigned char localIp[4];
+			localIp[0] = TextZuInt(addresse->getText(), 10);
+			localIp[1] = TextZuInt(addresse->getText() + addresse->positionVon('.', 0) + 1, 10);
+			localIp[2] = TextZuInt(addresse->getText() + addresse->positionVon('.', 1) + 1, 10);
+			localIp[3] = TextZuInt(addresse->getText() + addresse->positionVon('.', 2) + 1, 10);
+			addresse = (Text*)addresse->release();
+			k->sendeEncrypted((char*)&localIp, 4);
+			byte = textLength(host);
+			k->sendeEncrypted((char*)&byte, 1);
+			k->sendeEncrypted(host, byte);
+			k->getNachrichtEncrypted((char*)&accountId, 4);
+			cs.unlock();
+			return 1;
+		}
+		else if (serverReturn == 2)
+		{
+			k->sendeEncrypted("\0", 1);
+			cs.unlock();
+			return 2;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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.
-bool LoginClient::kick( const char *name, const char *pass, const char *geheim )
+bool LoginClient::kick(const char* name, const char* pass, const char* geheim)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\5", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char byte = (unsigned char)textLength( name );
-        k->sendeEncrypted( (char *)&byte, 1 );
-        k->sendeEncrypted( name, byte );
-        byte = (unsigned char)textLength( pass );
-        k->sendeEncrypted( (char *)&byte, 1 );
-        k->sendeEncrypted( pass, byte );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 2 )
-        {
-            unsigned char byte = (unsigned char)textLength( geheim );
-            k->sendeEncrypted( (char *)&byte, 1 );
-            k->sendeEncrypted( geheim, byte );
-            k->getNachrichtEncrypted( (char *)&serverReturn, 1 );
-            if( !serverReturn )
-            {
-                cs.unlock();
-                return 0;
-            }
-        }
-        if( serverReturn == 1 || serverReturn == 2 )
-        {
-            char host[ 255 ];
-            Network::getHostName( host, 255 );
-            Text *addresse = new Text( Network::getHostAddresse() );
-            unsigned char localIp[ 4 ];
-            localIp[ 0 ] = TextZuInt( addresse->getText(), 10 );
-            localIp[ 1 ] = TextZuInt( addresse->getText() + addresse->positionVon( '.', 0 ) + 1, 10 );
-            localIp[ 2 ] = TextZuInt( addresse->getText() + addresse->positionVon( '.', 1 ) + 1, 10 );
-            localIp[ 3 ] = TextZuInt( addresse->getText() + addresse->positionVon( '.', 2 ) + 1, 10 );
-            addresse = (Text *)addresse->release();
-            k->sendeEncrypted( (char *)&localIp, 4 );
-            byte = textLength( host );
-            k->sendeEncrypted( (char *)&byte, 1 );
-            k->sendeEncrypted( host, byte );
-            k->getNachrichtEncrypted( (char *)&accountId, 4 );
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\5", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char byte = (unsigned char)textLength(name);
+		k->sendeEncrypted((char*)&byte, 1);
+		k->sendeEncrypted(name, byte);
+		byte = (unsigned char)textLength(pass);
+		k->sendeEncrypted((char*)&byte, 1);
+		k->sendeEncrypted(pass, byte);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 2)
+		{
+			unsigned char byte = (unsigned char)textLength(geheim);
+			k->sendeEncrypted((char*)&byte, 1);
+			k->sendeEncrypted(geheim, byte);
+			k->getNachrichtEncrypted((char*)&serverReturn, 1);
+			if (!serverReturn)
+			{
+				cs.unlock();
+				return 0;
+			}
+		}
+		if (serverReturn == 1 || serverReturn == 2)
+		{
+			char host[255];
+			Network::getHostName(host, 255);
+			Text* addresse = new Text(Network::getHostAddresse());
+			unsigned char localIp[4];
+			localIp[0] = TextZuInt(addresse->getText(), 10);
+			localIp[1] = TextZuInt(addresse->getText() + addresse->positionVon('.', 0) + 1, 10);
+			localIp[2] = TextZuInt(addresse->getText() + addresse->positionVon('.', 1) + 1, 10);
+			localIp[3] = TextZuInt(addresse->getText() + addresse->positionVon('.', 2) + 1, 10);
+			addresse = (Text*)addresse->release();
+			k->sendeEncrypted((char*)&localIp, 4);
+			byte = textLength(host);
+			k->sendeEncrypted((char*)&byte, 1);
+			k->sendeEncrypted(host, byte);
+			k->getNachrichtEncrypted((char*)&accountId, 4);
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // logt den Account aus
@@ -233,35 +233,35 @@ bool LoginClient::kick( const char *name, const char *pass, const char *geheim )
 //  sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist
 bool LoginClient::logout()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        k->sendeEncrypted( (char *)&accountId, 4 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		k->sendeEncrypted((char*)&accountId, 4);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Erhält die Verbindung aufrecht
@@ -269,94 +269,94 @@ bool LoginClient::logout()
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool LoginClient::keepAlive()
 {
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    Framework::logLine( (char *)"Verbindungstest zum Login Server..." );
-    bool ok = k->sendeEncrypted( "\x7", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	Framework::logLine((char*)"Verbindungstest zum Login Server...");
+	bool ok = k->sendeEncrypted("\x7", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool LoginClient::trenne( bool abmelden )
+bool LoginClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Login Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Login Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Login Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Login Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool LoginClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 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
 int LoginClient::getAccountId() const
 {
-    return accountId;
+	return accountId;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *LoginClient::getLetzterFehler() const
+const char* LoginClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/LoginClient.h

@@ -5,53 +5,53 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um sich einzuloggen oder auszuloggen
-    class LoginClient : public LoginServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
-        int accountId;
+	// Wird verwendet um sich einzuloggen oder auszuloggen
+	class LoginClient : public LoginServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
+		int accountId;
 
-    public:
-        // Konstruktor
-        LoginClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~LoginClient();
-        // verbindet sich mit dem zugewiesenen Login Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // 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
-        int login( const char *name, const char *pass ) override;
-        // 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.
-        bool kick( const char *name, const char *pass, const char *geheim ) override;
-        // 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
-        bool logout() override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // 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
-        int getAccountId() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		LoginClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~LoginClient();
+		// verbindet sich mit dem zugewiesenen Login Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// 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
+		int login(const char* name, const char* pass) override;
+		// 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.
+		bool kick(const char* name, const char* pass, const char* geheim) override;
+		// 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
+		bool logout() override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// 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
+		int getAccountId() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/Main.cpp

@@ -4,20 +4,20 @@ using namespace KSGClient;
 
 extern "C"
 {
-    // Einstiegspunkte in die Bibliothek
+	// Einstiegspunkte in die Bibliothek
 
-    // Erzeugt einen neuen Client beim Serversystem.
-    //  registerSSL Methode muss aufgerufen werden um den Client beim Serversystem anzumelden
-    __declspec( dllexport ) MainServerClient *createMainServerClient()
-    {
-        return new MainClient();
-    }
-    // Erzeugt einen Client, der bereits beim Serversystem angemeldet ist
-    //  ip: Die Ip des Main Servers für angemeldete Clients
-    //  port: Der Port des Main Servers für angemeldete Clients
-    //  klientId: Die Id die der Client durch das Anmelden bekommen hat
-    __declspec( dllexport ) MainServerClient *createRegisterdMainServerClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen )
-    {
-        return new MainClient( ip, port, klientId, key, keyLen );
-    }
+	// Erzeugt einen neuen Client beim Serversystem.
+	//  registerSSL Methode muss aufgerufen werden um den Client beim Serversystem anzumelden
+	__declspec(dllexport) MainServerClient* createMainServerClient()
+	{
+		return new MainClient();
+	}
+	// Erzeugt einen Client, der bereits beim Serversystem angemeldet ist
+	//  ip: Die Ip des Main Servers für angemeldete Clients
+	//  port: Der Port des Main Servers für angemeldete Clients
+	//  klientId: Die Id die der Client durch das Anmelden bekommen hat
+	__declspec(dllexport) MainServerClient* createRegisterdMainServerClient(const char* ip, unsigned short port, int klientId, const char* key, unsigned char keyLen)
+	{
+		return new MainClient(ip, port, klientId, key, keyLen);
+	}
 }

KSGNetwork/MainClient.cpp

@@ -18,754 +18,754 @@ using namespace KSGClient;
 
 // Konstruktor
 MainClient::MainClient()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    port = 0;
-    cId = 0;
-    k = 0;
-    key = 0;
-    keyLen = 0;
+	port = 0;
+	cId = 0;
+	k = 0;
+	key = 0;
+	keyLen = 0;
 }
 
-MainClient::MainClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+MainClient::MainClient(const char* ip, unsigned short port, int klientId, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->keyLen = keyLen;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->keyLen = keyLen;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
 }
 
 // Destruktor
 MainClient::~MainClient()
 {
-    if( k )
-        disconnect();
-    delete[]key;
+	if (k)
+		disconnect();
+	delete[]key;
 }
 
 // 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
-bool MainClient::registerSSL( char *ip, unsigned short port )
+bool MainClient::registerSSL(const char* ip, unsigned short port)
 {
-    cs.lock();
-    if( cId )
-    {
-        cs.unlock();
-        return 0;
-    }
-    Network::SSLKlient *klientSSL = new Network::SSLKlient();
-    int l = 0;
-    if( !klientSSL->verbinde( port, ip ) )
-    {
-        err = "error while trying to connect to Main SSL Server";
-        klientSSL->release();
-        cs.unlock();
-        return 0;
-    }
-    klientSSL->sende( "\1", 5 );
-    char byte = 0;
-    klientSSL->getNachricht( &byte, 1 );
-    if( byte == 3 )
-    {
-        klientSSL->getNachricht( &byte, 1 );
-        char *message = new char[ byte + 1 ];
-        message[ byte ] = 0;
-        klientSSL->getNachricht( message, byte );
-        err = "error while register new client server returned: ";
-        err += message;
-        delete[]message;
-        klientSSL->sende( "\3", 1 );
-        klientSSL->getNachricht( &byte, 1 );
-        klientSSL->trenne();
-        klientSSL->release();
-        cs.unlock();
-        return 0;
-    }
-    if( byte == 1 )
-    {
-        klientSSL->getNachricht( (char *)&this->port, 4 );
-        klientSSL->getNachricht( (char *)&cId, 4 );
-        klientSSL->getNachricht( (char *)&keyLen, 1 );
-        this->ip = ip;
-        if( keyLen )
-        {
-            key = new char[ keyLen ];
-            klientSSL->getNachricht( key, keyLen );
-        }
-    }
-    klientSSL->sende( "\3", 1 );
-    klientSSL->getNachricht( &byte, 1 );
-    klientSSL->trenne();
-    klientSSL->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (cId)
+	{
+		cs.unlock();
+		return 0;
+	}
+	Network::SSLKlient* klientSSL = new Network::SSLKlient();
+	int l = 0;
+	if (!klientSSL->verbinde(port, ip))
+	{
+		err = "error while trying to connect to Main SSL Server";
+		klientSSL->release();
+		cs.unlock();
+		return 0;
+	}
+	klientSSL->sende("\1", 5);
+	char byte = 0;
+	klientSSL->getNachricht(&byte, 1);
+	if (byte == 3)
+	{
+		klientSSL->getNachricht(&byte, 1);
+		char* message = new char[byte + 1];
+		message[byte] = 0;
+		klientSSL->getNachricht(message, byte);
+		err = "error while register new client server returned: ";
+		err += message;
+		delete[]message;
+		klientSSL->sende("\3", 1);
+		klientSSL->getNachricht(&byte, 1);
+		klientSSL->trenne();
+		klientSSL->release();
+		cs.unlock();
+		return 0;
+	}
+	if (byte == 1)
+	{
+		klientSSL->getNachricht((char*)&this->port, 4);
+		klientSSL->getNachricht((char*)&cId, 4);
+		klientSSL->getNachricht((char*)&keyLen, 1);
+		this->ip = ip;
+		if (keyLen)
+		{
+			key = new char[keyLen];
+			klientSSL->getNachricht(key, keyLen);
+		}
+	}
+	klientSSL->sende("\3", 1);
+	klientSSL->getNachricht(&byte, 1);
+	klientSSL->trenne();
+	klientSSL->release();
+	cs.unlock();
+	return 1;
 }
 
 // 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.
 bool MainClient::connect()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::MAIN, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::MAIN, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( !k->verbinde( port, ip ) )
-    {
-        err = "error while trying to connect to Main Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    k->sende( "\0", 1 ); // Verschlüsselung aktivieren
-    k->sendeEncrypted( "\1", 1 );
-    k->sendeEncrypted( (char *)&cId, 4 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        char *message = new char[ serverReturn + 1 ];
-        message[ serverReturn ] = 0;
-        k->getNachrichtEncrypted( message, serverReturn );
-        err = "error while trying to identify registered client server returned: ";
-        err += message;
-        delete[] message;
-        k->sendeEncrypted( "\3", 1 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        k->trenne();
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    else
-    {
-        k->setSendeKey( this->key, keyLen );
-        k->setEmpfangKey( this->key, keyLen );
-        cs.unlock();
-        return 1;
-    }
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::MAIN, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::MAIN, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (!k->verbinde(port, ip))
+	{
+		err = "error while trying to connect to Main Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	k->sende("\0", 1); // Verschlüsselung aktivieren
+	k->sendeEncrypted("\1", 1);
+	k->sendeEncrypted((char*)&cId, 4);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		char* message = new char[serverReturn + 1];
+		message[serverReturn] = 0;
+		k->getNachrichtEncrypted(message, serverReturn);
+		err = "error while trying to identify registered client server returned: ";
+		err += message;
+		delete[] message;
+		k->sendeEncrypted("\3", 1);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		k->trenne();
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	else
+	{
+		k->setSendeKey(this->key, keyLen);
+		k->setEmpfangKey(this->key, keyLen);
+		cs.unlock();
+		return 1;
+	}
 }
 
 // Erzeugt einen Erhaltungs Server Client
 //  Gibt bei misserfolg 0 zurück
-ErhaltungServerClient *MainClient::createErhaltungServerClient()
+ErhaltungServerClient* MainClient::createErhaltungServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\x8", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new ErhaltungClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting ErhaltungServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\x8", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new ErhaltungClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting ErhaltungServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Patch Server Client
 //  Gibt bei misserfolg 0 zurück
-PatchServerClient *MainClient::createPatchServerClient()
+PatchServerClient* MainClient::createPatchServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\2", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new PatchClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting PatchServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\2", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new PatchClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting PatchServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen News Server Client
 //  Gibt bei misserfolg 0 zurück
-NewsServerClient *MainClient::createNewsServerClient()
+NewsServerClient* MainClient::createNewsServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\x9", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new NewsClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting NewsServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\x9", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new NewsClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting NewsServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Register Server Client
 //  Gibt bei misserfolg 0 zurück
-RegisterServerClient *MainClient::createRegisterServerClient()
+RegisterServerClient* MainClient::createRegisterServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\1", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new RegisterClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting RegisterServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\1", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new RegisterClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting RegisterServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Login Server Client
 //  Gibt bei misserfolg 0 zurück
-LoginServerClient *MainClient::createLoginServerClient()
+LoginServerClient* MainClient::createLoginServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\3", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new LoginClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting LoginServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\3", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new LoginClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting LoginServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Information Server Client
 //  Gibt bei misserfolg 0 zurück
-InformationServerClient *MainClient::createInformationServerClient()
+InformationServerClient* MainClient::createInformationServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\4", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new InformationClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting InformationServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\4", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new InformationClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting InformationServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Chat Server Client
 //  Gibt bei misserfolg 0 zurück
-ChatServerClient *MainClient::createChatServerClient()
+ChatServerClient* MainClient::createChatServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\5", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new ChatClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting ChatServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\5", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new ChatClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting ChatServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Shop Server Client
 //  Gibt bei misserfolg 0 zurück
-ShopServerClient *MainClient::createShopServerClient()
+ShopServerClient* MainClient::createShopServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\7", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new ShopClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting ShopServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\7", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new ShopClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting ShopServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Anmeldung Server Client
 //  Gibt bei misserfolg 0 zurück
-AnmeldungServerClient *MainClient::createAnmeldungServerClient()
+AnmeldungServerClient* MainClient::createAnmeldungServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\6", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new AnmeldungClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting AnmeldungServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\6", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new AnmeldungClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting AnmeldungServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Erzeugt einen Minigame Server Client
 //  Gibt bei misserfolg 0 zurück
-MinigameServerClient *MainClient::createMinigameServerClient()
+MinigameServerClient* MainClient::createMinigameServerClient()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6\xA", 2 );
-    char byte = 0;
-    k->getNachrichtEncrypted( &byte, 1 );
-    if( byte == 2 )
-    {
-        unsigned char lsIp[ 4 ];
-        k->getNachrichtEncrypted( (char *)lsIp, 4 );
-        unsigned short lsPort = 0;
-        k->getNachrichtEncrypted( (char *)&lsPort, 2 );
-        Framework::Text ipT;
-        ipT += (int)lsIp[ 0 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 1 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 2 ];
-        ipT += ".";
-        ipT += (int)lsIp[ 3 ];
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return new MinigameClient( cId, lsPort, ipT, key, keyLen );
-    }
-    else if( byte == 3 )
-    {
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *f = new char[ byte + 1 ];
-        f[ byte ] = 0;
-        k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting MinigameServer server returned: ";
-        err += f;
-        delete[]f;
-    }
-    if( !connected )
-        disconnect();
-    cs.unlock();
-    return 0;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6\xA", 2);
+	char byte = 0;
+	k->getNachrichtEncrypted(&byte, 1);
+	if (byte == 2)
+	{
+		unsigned char lsIp[4];
+		k->getNachrichtEncrypted((char*)lsIp, 4);
+		unsigned short lsPort = 0;
+		k->getNachrichtEncrypted((char*)&lsPort, 2);
+		Framework::Text ipT;
+		ipT += (int)lsIp[0];
+		ipT += ".";
+		ipT += (int)lsIp[1];
+		ipT += ".";
+		ipT += (int)lsIp[2];
+		ipT += ".";
+		ipT += (int)lsIp[3];
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return new MinigameClient(cId, lsPort, ipT, key, keyLen);
+	}
+	else if (byte == 3)
+	{
+		k->getNachrichtEncrypted(&byte, 1);
+		char* f = new char[byte + 1];
+		f[byte] = 0;
+		k->getNachrichtEncrypted(f, byte);
+		err = "error while requesting MinigameServer server returned: ";
+		err += f;
+		delete[]f;
+	}
+	if (!connected)
+		disconnect();
+	cs.unlock();
+	return 0;
 }
 
 // Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
 bool MainClient::disconnect()
 {
-    cs.lock();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    char serverReturn = 0;
-    k->sendeEncrypted( "\3", 1 );
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	char serverReturn = 0;
+	k->sendeEncrypted("\3", 1);
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
 bool MainClient::unregister()
 {
-    cs.lock();
-    bool connected = k != 0;
-    if( !connected )
-        connect();
-    if( !k )
-    {
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\7", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 3 )
-    {
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        char *message = new char[ serverReturn + 1 ];
-        message[ serverReturn ] = 0;
-        k->getNachrichtEncrypted( message, serverReturn );
-        err = "error while trying to unregistere client server returned: ";
-        err += message;
-        delete[] message;
-        if( !connected )
-            disconnect();
-        cs.unlock();
-        return 0;
-    }
-    disconnect();
-    cId = 0;
-    delete key;
-    key = 0;
-    keyLen = 0;
-    port = 0;
-    ip = "";
-    cs.unlock();
-    return 1;
+	cs.lock();
+	bool connected = k != 0;
+	if (!connected)
+		connect();
+	if (!k)
+	{
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\7", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 3)
+	{
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		char* message = new char[serverReturn + 1];
+		message[serverReturn] = 0;
+		k->getNachrichtEncrypted(message, serverReturn);
+		err = "error while trying to unregistere client server returned: ";
+		err += message;
+		delete[] message;
+		if (!connected)
+			disconnect();
+		cs.unlock();
+		return 0;
+	}
+	disconnect();
+	cId = 0;
+	delete key;
+	key = 0;
+	keyLen = 0;
+	port = 0;
+	ip = "";
+	cs.unlock();
+	return 1;
 }
 
 // Gibt die dem Client zugewiesene Id zurück.
 //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
 int MainClient::getClientId() const
 {
-    return cId;
+	return cId;
 }
 
 // Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
 //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-char *MainClient::getServerIp() const
+const char* MainClient::getServerIp() const
 {
-    return ip.getText();
+	return ip.getText();
 }
 
 // Gibt den Port des dem Client zugewiesenen Main Servers zurück.
 //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
 unsigned short MainClient::getServerPort() const
 {
-    return port;
+	return port;
 }
 
 // Gibt den Zeiger auf den Schlüssel zurück
 //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-char *MainClient::zKey() const
+const char* MainClient::zKey() const
 {
-    return key;
+	return key;
 }
 
 // Gibt die Länge des Schlüssels zurück
 //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
 unsigned char MainClient::getKeyLen() const
 {
-    return keyLen;
+	return keyLen;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *MainClient::getLetzterFehler() const
+const char* MainClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/MainClient.h

@@ -5,80 +5,80 @@
 
 namespace KSGClient
 {
-    class MainClient : public MainServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	class MainClient : public MainServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        MainClient();
-        MainClient( char *ip, unsigned short port, int klientId, char *key, unsigned char keyLen );
-        // Destruktor
-        ~MainClient();
-        // 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
-        bool registerSSL( char *ip, unsigned short port ) override;
-        // 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.
-        bool connect() override;
-        // Erzeugt einen Erhaltungs Server Client
-        //  Gibt bei misserfolg 0 zurück
-        ErhaltungServerClient *createErhaltungServerClient() override;
-        // Erzeugt einen Patch Server Client
-        //  Gibt bei misserfolg 0 zurück
-        PatchServerClient *createPatchServerClient() override;
-        // Erzeugt einen News Server Client
-        //  Gibt bei misserfolg 0 zurück
-        NewsServerClient *createNewsServerClient() override;
-        // Erzeugt einen Register Server Client
-        //  Gibt bei misserfolg 0 zurück
-        RegisterServerClient *createRegisterServerClient() override;
-        // Erzeugt einen Login Server Client
-        //  Gibt bei misserfolg 0 zurück
-        LoginServerClient *createLoginServerClient() override;
-        // Erzeugt einen Information Server Client
-        //  Gibt bei misserfolg 0 zurück
-        InformationServerClient *createInformationServerClient() override;
-        // Erzeugt einen Chat Server Client
-        //  Gibt bei misserfolg 0 zurück
-        ChatServerClient *createChatServerClient() override;
-        // Erzeugt einen Shop Server Client
-        //  Gibt bei misserfolg 0 zurück
-        ShopServerClient *createShopServerClient() override;
-        // Erzeugt einen Anmeldung Server Client
-        //  Gibt bei misserfolg 0 zurück
-        AnmeldungServerClient *createAnmeldungServerClient() override;
-        // Erzeugt einen Minigame Server Client
-        //  Gibt bei misserfolg 0 zurück
-        MinigameServerClient *createMinigameServerClient() override;
-        // Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
-        bool disconnect() override;
-        // Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
-        bool unregister() override;
-        // Gibt die dem Client zugewiesene Id zurück.
-        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-        int getClientId() const override;
-        // Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
-        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-        char *getServerIp() const override;
-        // Gibt den Port des dem Client zugewiesenen Main Servers zurück.
-        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-        unsigned short getServerPort() const override;
-        // Gibt den Zeiger auf den Schlüssel zurück
-        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-        char *zKey() const override;
-        // Gibt die Länge des Schlüssels zurück
-        //  sollte erst nach dem Aufruf von registerSSL verwendet werden.
-        unsigned char getKeyLen() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		MainClient();
+		MainClient(const char* ip, unsigned short port, int klientId, const char* key, unsigned char keyLen);
+		// Destruktor
+		~MainClient();
+		// 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
+		bool registerSSL(const char* ip, unsigned short port) override;
+		// 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.
+		bool connect() override;
+		// Erzeugt einen Erhaltungs Server Client
+		//  Gibt bei misserfolg 0 zurück
+		ErhaltungServerClient* createErhaltungServerClient() override;
+		// Erzeugt einen Patch Server Client
+		//  Gibt bei misserfolg 0 zurück
+		PatchServerClient* createPatchServerClient() override;
+		// Erzeugt einen News Server Client
+		//  Gibt bei misserfolg 0 zurück
+		NewsServerClient* createNewsServerClient() override;
+		// Erzeugt einen Register Server Client
+		//  Gibt bei misserfolg 0 zurück
+		RegisterServerClient* createRegisterServerClient() override;
+		// Erzeugt einen Login Server Client
+		//  Gibt bei misserfolg 0 zurück
+		LoginServerClient* createLoginServerClient() override;
+		// Erzeugt einen Information Server Client
+		//  Gibt bei misserfolg 0 zurück
+		InformationServerClient* createInformationServerClient() override;
+		// Erzeugt einen Chat Server Client
+		//  Gibt bei misserfolg 0 zurück
+		ChatServerClient* createChatServerClient() override;
+		// Erzeugt einen Shop Server Client
+		//  Gibt bei misserfolg 0 zurück
+		ShopServerClient* createShopServerClient() override;
+		// Erzeugt einen Anmeldung Server Client
+		//  Gibt bei misserfolg 0 zurück
+		AnmeldungServerClient* createAnmeldungServerClient() override;
+		// Erzeugt einen Minigame Server Client
+		//  Gibt bei misserfolg 0 zurück
+		MinigameServerClient* createMinigameServerClient() override;
+		// Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde
+		bool disconnect() override;
+		// Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar
+		bool unregister() override;
+		// Gibt die dem Client zugewiesene Id zurück.
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		int getClientId() const override;
+		// Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück.
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		const char* getServerIp() const override;
+		// Gibt den Port des dem Client zugewiesenen Main Servers zurück.
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		unsigned short getServerPort() const override;
+		// Gibt den Zeiger auf den Schlüssel zurück
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		const char* zKey() const override;
+		// Gibt die Länge des Schlüssels zurück
+		//  sollte erst nach dem Aufruf von registerSSL verwendet werden.
+		unsigned char getKeyLen() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/MinigameClient.cpp

@@ -8,276 +8,276 @@ using namespace KSGClient;
 // Inhalt der MinigameClient Klasse
 
 // Konstruktor
-MinigameClient::MinigameClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+MinigameClient::MinigameClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 MinigameClient::~MinigameClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Minigame Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool MinigameClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::MINIGAME, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::MINIGAME, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Minigame Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Minigame Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Minigame Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::MINIGAME, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::MINIGAME, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Minigame Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Minigame Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Minigame Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Gibt die Id des aktuell spielenden Accounts zurück
 int MinigameClient::getAccountId()
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\xB", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        int acc = 0;
-        k->getNachrichtEncrypted( (char *)&acc, 4 );
-        cs.unlock();
-        return acc;
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\xB", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		int acc = 0;
+		k->getNachrichtEncrypted((char*)&acc, 4);
+		cs.unlock();
+		return acc;
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt den Anzeigenamen eines bestimmten Accounts zurück
 //  id: Die id des Accounts
-Text *MinigameClient::getAccountName( int id )
+Text* MinigameClient::getAccountName(int id)
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\xC", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            char l;
-            k->getNachrichtEncrypted( &l, 1 );
-            char *buff = new char[ l + 1 ];
-            buff[ l ] = 0;
-            k->getNachrichtEncrypted( buff, l );
-            cs.unlock();
-            Text *ret = new Text( buff );
-            delete[] buff;
-            return ret;
-        }
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\xC", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			char l;
+			k->getNachrichtEncrypted(&l, 1);
+			char* buff = new char[l + 1];
+			buff[l] = 0;
+			k->getNachrichtEncrypted(buff, l);
+			cs.unlock();
+			Text* ret = new Text(buff);
+			delete[] buff;
+			return ret;
+		}
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
-Text *MinigameClient::getSecret()
+Text* MinigameClient::getSecret()
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\xD", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        unsigned char l = 0;
-        k->getNachrichtEncrypted( (char *)&l, 1 );
-        char *buff = new char[ l + 1 ];
-        buff[ l ] = 0;
-        k->getNachrichtEncrypted( buff, l );
-        cs.unlock();
-        Text *ret = new Text( buff );
-        delete[] buff;
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\xD", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		unsigned char l = 0;
+		k->getNachrichtEncrypted((char*)&l, 1);
+		char* buff = new char[l + 1];
+		buff[l] = 0;
+		k->getNachrichtEncrypted(buff, l);
+		cs.unlock();
+		Text* ret = new Text(buff);
+		delete[] buff;
+		return ret;
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-int MinigameClient::getMinigameOptionList( char *mName, Framework::RCArray< Framework::Text > *zOptionList )
+int MinigameClient::getMinigameOptionList(const char* mName, Framework::RCArray< Framework::Text >* zOptionList)
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\x6", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char l = (char)textLength( mName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( mName, l );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            k->getNachrichtEncrypted( &l, 1 );
-            char *option = new char[ l + 1 ];
-            option[ l ] = 0;
-            k->getNachrichtEncrypted( option, l );
-            zOptionList->add( new Text( option ) );
-            delete[] option;
-        }
-        cs.unlock();
-        return anz;
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\x6", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char l = (char)textLength(mName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(mName, l);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			k->getNachrichtEncrypted(&l, 1);
+			char* option = new char[l + 1];
+			option[l] = 0;
+			k->getNachrichtEncrypted(option, l);
+			zOptionList->add(new Text(option));
+			delete[] option;
+		}
+		cs.unlock();
+		return anz;
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Ermittelt eine Liste mit den Weltbesten Scores zurück
@@ -286,119 +286,119 @@ int MinigameClient::getMinigameOptionList( char *mName, Framework::RCArray< Fram
 //  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
-int MinigameClient::getMinigameBestscoreList( char *mName, Framework::Array< int > *zScore, Framework::RCArray< Framework::Text > *zPlayerList, Framework::RCArray< Framework::Text > *zOptionList )
+int MinigameClient::getMinigameBestscoreList(const char* mName, Framework::Array< int >* zScore, Framework::RCArray< Framework::Text >* zPlayerList, Framework::RCArray< Framework::Text >* zOptionList)
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\x7", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char l = (char)textLength( mName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( mName, l );
-        int anz = 0;
-        k->getNachrichtEncrypted( (char *)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int score = 0;
-            k->getNachrichtEncrypted( (char *)&score, 4 );
-            zScore->add( score );
-            k->getNachrichtEncrypted( &l, 1 );
-            char *player = new char[ l + 1 ];
-            player[ l ] = 0;
-            k->getNachrichtEncrypted( player, l );
-            zPlayerList->add( new Text( player ) );
-            delete[] player;
-            k->getNachrichtEncrypted( &l, 1 );
-            char *option = new char[ l + 1 ];
-            option[ l ] = 0;
-            k->getNachrichtEncrypted( option, l );
-            zOptionList->add( new Text( option ) );
-            delete[] option;
-        }
-        cs.unlock();
-        return anz;
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\x7", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char l = (char)textLength(mName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(mName, l);
+		int anz = 0;
+		k->getNachrichtEncrypted((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int score = 0;
+			k->getNachrichtEncrypted((char*)&score, 4);
+			zScore->add(score);
+			k->getNachrichtEncrypted(&l, 1);
+			char* player = new char[l + 1];
+			player[l] = 0;
+			k->getNachrichtEncrypted(player, l);
+			zPlayerList->add(new Text(player));
+			delete[] player;
+			k->getNachrichtEncrypted(&l, 1);
+			char* option = new char[l + 1];
+			option[l] = 0;
+			k->getNachrichtEncrypted(option, l);
+			zOptionList->add(new Text(option));
+			delete[] option;
+		}
+		cs.unlock();
+		return anz;
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-int MinigameClient::getMinigameOptionBestscore( char *mName, char *oName, Framework::Text *zPlayer )
+int MinigameClient::getMinigameOptionBestscore(const char* mName, const char* oName, Framework::Text* zPlayer)
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\x8", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char l = (char)textLength( mName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( mName, l );
-        l = (char)textLength( oName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( oName, l );
-        int score = 0;
-        k->getNachrichtEncrypted( (char *)&score, 4 );
-        k->getNachrichtEncrypted( &l, 1 );
-        char *player = new char[ l + 1 ];
-        player[ l ] = 0;
-        k->getNachrichtEncrypted( player, l );
-        zPlayer->setText( player );
-        delete[] player;
-        cs.unlock();
-        return score;
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\x8", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char l = (char)textLength(mName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(mName, l);
+		l = (char)textLength(oName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(oName, l);
+		int score = 0;
+		k->getNachrichtEncrypted((char*)&score, 4);
+		k->getNachrichtEncrypted(&l, 1);
+		char* player = new char[l + 1];
+		player[l] = 0;
+		k->getNachrichtEncrypted(player, l);
+		zPlayer->setText(player);
+		delete[] player;
+		cs.unlock();
+		return score;
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Meldet die Beendigung eines Minigames
@@ -407,141 +407,141 @@ int MinigameClient::getMinigameOptionBestscore( char *mName, char *oName, Framew
 //  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
-bool MinigameClient::reportEndOfGame( char *mName, char *oName, int score, Framework::Datei *zCapture )
+bool MinigameClient::reportEndOfGame(const char* mName, const char* oName, int score, Framework::Datei* zCapture)
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\x9", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char l = (char)textLength( mName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( mName, l );
-        l = (char)textLength( oName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( oName, l );
-        k->sendeEncrypted( (char *)&score, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int size = (int)zCapture->getSize();
-            if( !zCapture->istOffen() )
-                zCapture->open( Datei::Style::lesen );
-            k->sendeEncrypted( (char *)&size, 4 );
-            char *buffer = new char[ 2048 ];
-            while( size > 0 )
-            {
-                int l = size > 2048 ? 2048 : size;
-                zCapture->lese( buffer, l );
-                k->sendeEncrypted( buffer, l );
-                size -= l;
-            }
-            delete[] buffer;
-            zCapture->close();
-            cs.unlock();
-            return 1;
-        }
-        else if( ret == 0 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\x9", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char l = (char)textLength(mName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(mName, l);
+		l = (char)textLength(oName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(oName, l);
+		k->sendeEncrypted((char*)&score, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int size = (int)zCapture->getSize();
+			if (!zCapture->istOffen())
+				zCapture->open(Datei::Style::lesen);
+			k->sendeEncrypted((char*)&size, 4);
+			char* buffer = new char[2048];
+			while (size > 0)
+			{
+				int l = size > 2048 ? 2048 : size;
+				zCapture->lese(buffer, l);
+				k->sendeEncrypted(buffer, l);
+				size -= l;
+			}
+			delete[] buffer;
+			zCapture->close();
+			cs.unlock();
+			return 1;
+		}
+		else if (ret == 0)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-Framework::Datei *MinigameClient::downloadGameCapture( char *mName, char *oName )
+Framework::Datei* MinigameClient::downloadGameCapture(const char* mName, const char* oName)
 {
-    cs.lock();
-    if( !k )
-    {
-        if( !verbinde() )
-        {
-            err = "Der Client ist nicht verbunden.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char l = (char)textLength( mName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( mName, l );
-        l = (char)textLength( oName );
-        k->sendeEncrypted( &l, 1 );
-        k->sendeEncrypted( oName, l );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            Datei *capture = new Datei();
-            capture->setDatei( "data/tmp/minigames/wb.mgc" );
-            capture->erstellen();
-            capture->open( Datei::Style::schreiben );
-            int size = 0;
-            k->getNachrichtEncrypted( (char *)&size, 4 );
-            char *buffer = new char[ 2048 ];
-            while( size > 0 )
-            {
-                int l = size > 2048 ? 2048 : size;
-                k->getNachrichtEncrypted( buffer, l );
-                capture->schreibe( buffer, l );
-                size -= l;
-            }
-            delete[] buffer;
-            capture->close();
-            cs.unlock();
-            return capture;
-        }
-        err = "Unbekannter Fehler";
-        cs.unlock();
-        return 0;
-    }
-    if( ret == 3 )
-    {
-        char l = 0;
-        k->getNachrichtEncrypted( &l, 1 );
-        char *fehler = new char[ l + 1 ];
-        fehler[ l ] = 0;
-        k->getNachrichtEncrypted( fehler, l );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		if (!verbinde())
+		{
+			err = "Der Client ist nicht verbunden.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	k->sendeEncrypted("\xA", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char l = (char)textLength(mName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(mName, l);
+		l = (char)textLength(oName);
+		k->sendeEncrypted(&l, 1);
+		k->sendeEncrypted(oName, l);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			Datei* capture = new Datei();
+			capture->setDatei("data/tmp/minigames/wb.mgc");
+			capture->erstellen();
+			capture->open(Datei::Style::schreiben);
+			int size = 0;
+			k->getNachrichtEncrypted((char*)&size, 4);
+			char* buffer = new char[2048];
+			while (size > 0)
+			{
+				int l = size > 2048 ? 2048 : size;
+				k->getNachrichtEncrypted(buffer, l);
+				capture->schreibe(buffer, l);
+				size -= l;
+			}
+			delete[] buffer;
+			capture->close();
+			cs.unlock();
+			return capture;
+		}
+		err = "Unbekannter Fehler";
+		cs.unlock();
+		return 0;
+	}
+	if (ret == 3)
+	{
+		char l = 0;
+		k->getNachrichtEncrypted(&l, 1);
+		char* fehler = new char[l + 1];
+		fehler[l] = 0;
+		k->getNachrichtEncrypted(fehler, l);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erhält die Verbindung aufrecht
@@ -549,81 +549,81 @@ Framework::Datei *MinigameClient::downloadGameCapture( char *mName, char *oName
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool MinigameClient::keepAlive()
 {
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    bool ok = k->sendeEncrypted( "\x5", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-        trenne( 0 );
-    return res == 1;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	bool ok = k->sendeEncrypted("\x5", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+		trenne(0);
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool MinigameClient::trenne( bool abmelden )
+bool MinigameClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Minigame Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Minigame Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Minigame Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Minigame Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool MinigameClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *MinigameClient::getLetzterFehler() const
+const char* MinigameClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/MinigameClient.h

@@ -5,76 +5,76 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class MinigameClient : public MinigameServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class MinigameClient : public MinigameServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        MinigameClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~MinigameClient();
-        // verbindet sich mit dem zugewiesenen Minigame Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // Gibt die Id des aktuell spielenden Accounts zurück
-        int getAccountId() override;
-        // Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
-        Text *getSecret() override;
-        // Gibt den Anzeigenamen eines bestimmten Accounts zurück
-        //  id: Die id des Accounts
-        Text *getAccountName( int id ) override;
-        // 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
-        int getMinigameOptionList( char *mName, Framework::RCArray< Framework::Text > *zOptionList ) override;
-        // 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
-        int getMinigameBestscoreList( char *mName, Framework::Array< int > *zScore, Framework::RCArray< Framework::Text > *zPlayerList, Framework::RCArray< Framework::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: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
-        int getMinigameOptionBestscore( char *mName, char *oName, Framework::Text *zPlayer ) override;
-        // 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
-        bool reportEndOfGame( char *mName, char *oName, int score, Framework::Datei *zCapture ) override;
-        // 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
-        Framework::Datei *downloadGameCapture( char *mName, char *oName ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		MinigameClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~MinigameClient();
+		// verbindet sich mit dem zugewiesenen Minigame Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// Gibt die Id des aktuell spielenden Accounts zurück
+		int getAccountId() override;
+		// Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
+		Text* getSecret() override;
+		// Gibt den Anzeigenamen eines bestimmten Accounts zurück
+		//  id: Die id des Accounts
+		Text* getAccountName(int id) override;
+		// 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
+		int getMinigameOptionList(const char* mName, Framework::RCArray< Framework::Text >* zOptionList) override;
+		// 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
+		int getMinigameBestscoreList(const char* mName, Framework::Array< int >* zScore, Framework::RCArray< Framework::Text >* zPlayerList, Framework::RCArray< Framework::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: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
+		int getMinigameOptionBestscore(const char* mName, const char* oName, Framework::Text* zPlayer) override;
+		// 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
+		bool reportEndOfGame(const char* mName, const char* oName, int score, Framework::Datei* zCapture) override;
+		// 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
+		Framework::Datei* downloadGameCapture(const char* mName, const char* oName) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/NewsClient.cpp

@@ -9,164 +9,164 @@ using namespace KSGClient;
 // Inhalt der NewsClient Klasse
 
 // Konstruktor
-NewsClient::NewsClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+NewsClient::NewsClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 NewsClient::~NewsClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet ich mit dem News Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool NewsClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::NEWS, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::NEWS, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client News Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Patch Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Patch Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::NEWS, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::NEWS, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client News Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Patch Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Patch Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool NewsClient::ladeSeite( char *name )
+bool NewsClient::ladeSeite(const char* name)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\5", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        char län = (char)textLength( name );
-        k->sendeEncrypted( &län, 1 );
-        k->sendeEncrypted( name, län );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            Text *pfad = new Text( "data/tmp/news/" );
-            pfad->append( name );
-            if( DateiExistiert( pfad->getText() ) )
-                DateiRemove( pfad->getText() );
-            pfad->append( "/" );
-            int dAnz = 0;
-            k->getNachrichtEncrypted( (char *)&dAnz, 4 );
-            for( int i = 0; i < dAnz; i++ )
-            {
-                char nLän = 0;
-                k->getNachrichtEncrypted( &nLän, 1 );
-                char *dName = new char[ nLän + 1 ];
-                dName[ nLän ] = 0;
-                k->getNachrichtEncrypted( dName, nLän );
-                Text *pf = new Text( pfad->getText() );
-                pf->append( dName );
-                delete[] dName;
-                Datei *d = new Datei();
-                d->setDatei( pf );
-                d->erstellen();
-                d->open( Datei::Style::schreiben );
-                __int64 dGr = 0;
-                k->getNachrichtEncrypted( (char *)&dGr, 8 );
-                char buffer[ 2048 ];
-                while( dGr > 0 )
-                {
-                    int län = dGr > 2048 ? 2048 : (int)dGr;
-                    k->getNachricht( buffer, län );
-                    d->schreibe( buffer, län );
-                    dGr -= län;
-                }
-                d->close();
-                d->release();
-            }
-            pfad->release();
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret )
-        {
-            char *tmp = new char[ ret ];
-            k->getNachrichtEncrypted( tmp, ret );
-            err = tmp;
-            delete[] tmp;
-        }
-        else
-            err = "unbekannter Fehler";
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\5", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		char län = (char)textLength(name);
+		k->sendeEncrypted(&län, 1);
+		k->sendeEncrypted(name, län);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			Text* pfad = new Text("data/tmp/news/");
+			pfad->append(name);
+			if (DateiExistiert(pfad->getText()))
+				DateiRemove(pfad->getText());
+			pfad->append("/");
+			int dAnz = 0;
+			k->getNachrichtEncrypted((char*)&dAnz, 4);
+			for (int i = 0; i < dAnz; i++)
+			{
+				char nLän = 0;
+				k->getNachrichtEncrypted(&nLän, 1);
+				char* dName = new char[nLän + 1];
+				dName[nLän] = 0;
+				k->getNachrichtEncrypted(dName, nLän);
+				Text* pf = new Text(pfad->getText());
+				pf->append(dName);
+				delete[] dName;
+				Datei* d = new Datei();
+				d->setDatei(pf);
+				d->erstellen();
+				d->open(Datei::Style::schreiben);
+				__int64 dGr = 0;
+				k->getNachrichtEncrypted((char*)&dGr, 8);
+				char buffer[2048];
+				while (dGr > 0)
+				{
+					int län = dGr > 2048 ? 2048 : (int)dGr;
+					k->getNachricht(buffer, län);
+					d->schreibe(buffer, län);
+					dGr -= län;
+				}
+				d->close();
+				d->release();
+			}
+			pfad->release();
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret)
+		{
+			char* tmp = new char[ret];
+			k->getNachrichtEncrypted(tmp, ret);
+			err = tmp;
+			delete[] tmp;
+		}
+		else
+			err = "unbekannter Fehler";
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Erhält die Verbindung aufrecht
@@ -174,83 +174,83 @@ bool NewsClient::ladeSeite( char *name )
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool NewsClient::keepAlive()
 {
-    if( !k )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    Framework::logLine( (char *)"Verbindungstest zum News Server..." );
-    bool ok = k->sendeEncrypted( "\x6", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	if (!k)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	Framework::logLine((char*)"Verbindungstest zum News Server...");
+	bool ok = k->sendeEncrypted("\x6", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool NewsClient::trenne( bool abmelden )
+bool NewsClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client News Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne News Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client News Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne News Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool NewsClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *NewsClient::getLetzterFehler() const
+const char* NewsClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/NewsClient.h

@@ -5,44 +5,44 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten)
-    class NewsClient : public NewsServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten)
+	class NewsClient : public NewsServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        NewsClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~NewsClient();
-        // verbindet ich mit dem News Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // 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
-        bool ladeSeite( char *name ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		NewsClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~NewsClient();
+		// verbindet ich mit dem News Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// 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
+		bool ladeSeite(const char* name) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 
 };

KSGNetwork/PatchClient.cpp

@@ -11,305 +11,306 @@ using namespace KSGClient;
 // Inhalt der PatchClient Klasse
 
 // Konstruktor
-PatchClient::PatchClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+PatchClient::PatchClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 PatchClient::~PatchClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet ich mit dem Patch Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool PatchClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::PATCH, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::PATCH, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        k->sende( "\0", 1 ); // Verschlüsselung Aktivieren
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::PATCH, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::PATCH, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		k->sende("\0", 1); // Verschlüsselung Aktivieren
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
 #ifdef _X64
-            k->sendeEncrypted( "\2", 1 ); // 64 Bit Client
+			k->sendeEncrypted("\2", 1); // 64 Bit Client
 #else
-            k->sendeEncrypted( "\1", 1 ); // 32 Bit Client
+			k->sendeEncrypted("\1", 1); // 32 Bit Client
 #endif
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Patch Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Patch Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Patch Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Patch Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Patch Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Patch Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Gibt eine Tabelle von Dateigruppen zurück.
 //  Gibt bei misserfolg 0 zurück
-Framework::KSGTDatei *PatchClient::getDateiGruppenListe()
+Framework::KSGTDatei* PatchClient::getDateiGruppenListe()
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xC", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        cs.unlock();
-        return 0;
-    }
-    Framework::KSGTDatei *dgtb = new Framework::KSGTDatei();
-    int id = 0;
-    k->getNachrichtEncrypted( (char *)&id, 4 );
-    while( id )
-    {
-        RCArray< Text > *zeile = new RCArray< Text >();
-        Text *idT = new Text();
-        idT->append( id );
-        zeile->set( idT, 0 );
-        int län = 0;
-        k->getNachrichtEncrypted( (char *)&län, 4 );
-        char *pfad = new char[ län + 1 ];
-        pfad[ län ] = 0;
-        if( län )
-            k->getNachrichtEncrypted( pfad, län );
-        zeile->set( new Text( pfad ), 1 );
-        delete[] pfad;
-        int vs = 0;
-        k->getNachrichtEncrypted( (char *)&vs, 4 );
-        Text *vsT = new Text();
-        vsT->append( vs );
-        zeile->set( vsT, 2 );
-        dgtb->addZeile( 3, zeile );
-        zeile->release();
-        k->getNachrichtEncrypted( (char *)&id, 4 );
-    }
-    k->sendeEncrypted( "\1", 1 );
-    cs.unlock();
-    return dgtb;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xC", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		cs.unlock();
+		return 0;
+	}
+	Framework::KSGTDatei* dgtb = new Framework::KSGTDatei();
+	int id = 0;
+	k->getNachrichtEncrypted((char*)&id, 4);
+	while (id)
+	{
+		RCArray< Text >* zeile = new RCArray< Text >();
+		Text* idT = new Text();
+		idT->append(id);
+		zeile->set(idT, 0);
+		int län = 0;
+		k->getNachrichtEncrypted((char*)&län, 4);
+		char* pfad = new char[län + 1];
+		pfad[län] = 0;
+		if (län)
+			k->getNachrichtEncrypted(pfad, län);
+		zeile->set(new Text(pfad), 1);
+		delete[] pfad;
+		int vs = 0;
+		k->getNachrichtEncrypted((char*)&vs, 4);
+		Text* vsT = new Text();
+		vsT->append(vs);
+		zeile->set(vsT, 2);
+		dgtb->addZeile(3, zeile);
+		zeile->release();
+		k->getNachrichtEncrypted((char*)&id, 4);
+	}
+	k->sendeEncrypted("\1", 1);
+	cs.unlock();
+	return dgtb;
 }
 
 // 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
-Framework::KSGTDatei *PatchClient::getDateiListe( int gruppe )
+Framework::KSGTDatei* PatchClient::getDateiListe(int gruppe)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x9", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&gruppe, 4 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        cs.unlock();
-        return 0;
-    }
-    KSGTDatei *dtb = new KSGTDatei();
-    int län = 0;
-    k->getNachrichtEncrypted( (char *)&län, 4 );
-    while( län )
-    {
-        RCArray< Text > *zeile = new RCArray< Text >();
-        zeile->set( new Text( "1" ), 0 );
-        char *pfad = new char[ län + 1 ];
-        pfad[ län ] = 0;
-        k->getNachrichtEncrypted( pfad, län );
-        zeile->set( new Text( pfad ), 1 );
-        delete[] pfad;
-        int vs = 0;
-        k->getNachrichtEncrypted( (char *)&vs, 4 );
-        Text *vsT = new Text();
-        vsT->append( vs );
-        zeile->set( vsT, 2 );
-        dtb->addZeile( 3, zeile );
-        zeile->release();
-        k->getNachrichtEncrypted( (char *)&län, 4 );
-    }
-    k->getNachrichtEncrypted( (char *)&län, 4 );
-    while( län )
-    {
-        RCArray< Text > *zeile = new RCArray< Text >();
-        zeile->set( new Text( "0" ), 0 );
-        char *pfad = new char[ län + 1 ];
-        pfad[ län ] = 0;
-        k->getNachrichtEncrypted( pfad, län );
-        zeile->set( new Text( pfad ), 1 );
-        delete[] pfad;
-        dtb->addZeile( 2, zeile );
-        zeile->release();
-        k->getNachrichtEncrypted( (char *)&län, 4 );
-    }
-    cs.unlock();
-    return dtb;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x9", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&gruppe, 4);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		cs.unlock();
+		return 0;
+	}
+	KSGTDatei* dtb = new KSGTDatei();
+	int län = 0;
+	k->getNachrichtEncrypted((char*)&län, 4);
+	while (län)
+	{
+		RCArray< Text >* zeile = new RCArray< Text >();
+		zeile->set(new Text("1"), 0);
+		char* pfad = new char[län + 1];
+		pfad[län] = 0;
+		k->getNachrichtEncrypted(pfad, län);
+		zeile->set(new Text(pfad), 1);
+		delete[] pfad;
+		int vs = 0;
+		k->getNachrichtEncrypted((char*)&vs, 4);
+		Text* vsT = new Text();
+		vsT->append(vs);
+		zeile->set(vsT, 2);
+		dtb->addZeile(3, zeile);
+		zeile->release();
+		k->getNachrichtEncrypted((char*)&län, 4);
+	}
+	k->getNachrichtEncrypted((char*)&län, 4);
+	while (län)
+	{
+		RCArray< Text >* zeile = new RCArray< Text >();
+		zeile->set(new Text("0"), 0);
+		char* pfad = new char[län + 1];
+		pfad[län] = 0;
+		k->getNachrichtEncrypted(pfad, län);
+		zeile->set(new Text(pfad), 1);
+		delete[] pfad;
+		dtb->addZeile(2, zeile);
+		zeile->release();
+		k->getNachrichtEncrypted((char*)&län, 4);
+	}
+	cs.unlock();
+	return dtb;
 }
 
 // Gibt die Größe einer Datei in bytes zurück
 //  gruppe: Die Id der Dateigruppe der Datei
 //  pfad: Der Pfad der Datei
-__int64 PatchClient::getDateiGröße( int gruppe, const char *pfad )
+__int64 PatchClient::getDateiGröße(int gruppe, const char* pfad)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&gruppe, 4 );
-    ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        cs.unlock();
-        return 0;
-    }
-    if( ret == 2 )
-    { // verweis auf anderen Server
-        int p = 0;
-        k->getNachrichtEncrypted( (char *)&p, 4 );
-        port = (unsigned short)p;
-        int län = 0;
-        k->getNachrichtEncrypted( (char *)&län, 4 );
-        delete[]ip;
-        ip = new char[ län + 1 ];
-        ip[ län ] = 0;
-        k->getNachrichtEncrypted( ip, län );
-        if( !trenne( 0 ) )
-        {
-            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
-            cs.unlock();
-            return 0;
-        }
-        if( !verbinde() )
-        {
-            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
-            cs.unlock();
-            return 0;
-        }
-        cs.unlock();
-        return getDateiGröße( gruppe, pfad );
-    }
-    int län = textLength( pfad );
-    k->sendeEncrypted( (char *)&län, 4 );
-    k->sendeEncrypted( pfad, län );
-    __int64 größe = 0;
-    k->getNachrichtEncrypted( (char *)&größe, 8 );
-    cs.unlock();
-    return größe;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xA", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&gruppe, 4);
+	ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		cs.unlock();
+		return 0;
+	}
+	if (ret == 2)
+	{ // verweis auf anderen Server
+		int p = 0;
+		k->getNachrichtEncrypted((char*)&p, 4);
+		port = (unsigned short)p;
+		int län = 0;
+		k->getNachrichtEncrypted((char*)&län, 4);
+		char* ip = new char[län + 1];
+		ip[län] = 0;
+		k->getNachrichtEncrypted(ip, län);
+		this->ip = ip;
+		delete[]ip;
+		if (!trenne(0))
+		{
+			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
+			cs.unlock();
+			return 0;
+		}
+		if (!verbinde())
+		{
+			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
+			cs.unlock();
+			return 0;
+		}
+		cs.unlock();
+		return getDateiGröße(gruppe, pfad);
+	}
+	int län = textLength(pfad);
+	k->sendeEncrypted((char*)&län, 4);
+	k->sendeEncrypted(pfad, län);
+	__int64 größe = 0;
+	k->getNachrichtEncrypted((char*)&größe, 8);
+	cs.unlock();
+	return größe;
 }
 
 // Lädt eine Datei herunter
@@ -320,236 +321,237 @@ __int64 PatchClient::getDateiGr
 //  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
-bool PatchClient::downloadDatei( int gruppe, __int64 *start, const char *pfad, const char *zielPfad, Framework::FBalken *zFb, bool *abbruch, int maxbps )
+bool PatchClient::downloadDatei(int gruppe, __int64* start, const char* pfad, const char* zielPfad, Framework::FBalken* zFb, bool* abbruch, int maxbps)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    Datei *zielD = new Datei();
-    zielD->setDatei( zielPfad );
-    if( !zielD->existiert() )
-        zielD->erstellen();
-    bool ok = 0;
-    if( !( *start ) ) // datei neu erstellen
-        ok = zielD->open( Datei::Style::schreiben );
-    else // datei weiterschreiben
-        ok = zielD->open( Datei::Style::schreiben | Datei::Style::lesen );
-    if( !ok )
-    {
-        zielD->release();
-        err = "Die Datei konnte nicht zum schreiben geöffnet werden.";
-        cs.unlock();
-        return 0;
-    }
-    zielD->setSPosition( *start, 0 );
-    k->sendeEncrypted( "\xB", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        zielD->close();
-        zielD->release();
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( (char *)&gruppe, 4 );
-    ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = msg;
-        delete[] msg;
-        zielD->close();
-        zielD->release();
-        cs.unlock();
-        return 0;
-    }
-    if( ret == 2 )
-    { // verweis auf anderen Server
-        int p = 0;
-        k->getNachrichtEncrypted( (char *)&p, 4 );
-        port = (unsigned short)p;
-        int län = 0;
-        k->getNachrichtEncrypted( (char *)&län, 4 );
-        delete[] ip;
-        ip = new char[ län + 1 ];
-        ip[ län ] = 0;
-        k->getNachrichtEncrypted( ip, län );
-        if( !trenne( 0 ) )
-        {
-            zielD->close();
-            zielD->release();
-            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
-            cs.unlock();
-            return 0;
-        }
-        if( !verbinde() )
-        {
-            zielD->close();
-            zielD->release();
-            err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
-            cs.unlock();
-            return 0;
-        }
-        zielD->close();
-        zielD->release();
-        cs.unlock();
-        return downloadDatei( gruppe, start, pfad, zielPfad, zFb, abbruch, maxbps );
-    }
-    int län = textLength( pfad );
-    k->sendeEncrypted( (char *)&län, 4 );
-    k->sendeEncrypted( pfad, län );
-    k->sendeEncrypted( (char *)start, 8 );
-    char *bytes = new char[ 2048 ];
-    unsigned short byteLän = 0;
-    k->getNachricht( (char *)&byteLän, 2 );
-    ZeitMesser *zMess = new ZeitMesser();
-    zMess->messungStart();
-    if( byteLän )
-    {
-        int bps = 0;
-        double sec = 0;
-        while( 1 )
-        {
-            k->getNachricht( bytes, byteLän );
-            zielD->schreibe( bytes, byteLän );
-            if( zFb )
-                zFb->aktionPlus( byteLän );
-            ( *start ) += byteLän;
-            bps += byteLän;
-            if( byteLän == 2048 )
-            {
-                if( ( *abbruch ) )
-                {
-                    zielD->close();
-                    zielD->release();
-                    k->trenne();
-                    k = (Network::Klient *)k->release();
-                    delete[] bytes;
-                    zMess->release();
-                    cs.unlock();
-                    return 1;
-                }
-                k->getNachricht( (char *)&byteLän, 2 ); // sendelänge empfangen
-                if( !byteLän )
-                    break;
-            }
-            else
-                break;
-            if( maxbps )
-            {
-                zMess->messungEnde();
-                sec += zMess->getSekunden();
-                zMess->messungStart();
-                if( sec >= 1 )
-                {
-                    sec = 0;
-                    bps = 0;
-                }
-                while( bps >= maxbps )
-                {
-                    Sleep( 10 );
-                    zMess->messungEnde();
-                    sec += zMess->getSekunden();
-                    zMess->messungStart();
-                    if( sec >= 1 )
-                    {
-                        sec = 0;
-                        bps = 0;
-                    }
-                }
-            }
-        }
-    }
-    zMess->release();
-    delete[] bytes;
-    k->sendeEncrypted( "\1", 1 );
-    zielD->close();
-    zielD->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	Datei* zielD = new Datei();
+	zielD->setDatei(zielPfad);
+	if (!zielD->existiert())
+		zielD->erstellen();
+	bool ok = 0;
+	if (!(*start)) // datei neu erstellen
+		ok = zielD->open(Datei::Style::schreiben);
+	else // datei weiterschreiben
+		ok = zielD->open(Datei::Style::schreiben | Datei::Style::lesen);
+	if (!ok)
+	{
+		zielD->release();
+		err = "Die Datei konnte nicht zum schreiben geöffnet werden.";
+		cs.unlock();
+		return 0;
+	}
+	zielD->setSPosition(*start, 0);
+	k->sendeEncrypted("\xB", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		zielD->close();
+		zielD->release();
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted((char*)&gruppe, 4);
+	ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = msg;
+		delete[] msg;
+		zielD->close();
+		zielD->release();
+		cs.unlock();
+		return 0;
+	}
+	if (ret == 2)
+	{ // verweis auf anderen Server
+		int p = 0;
+		k->getNachrichtEncrypted((char*)&p, 4);
+		port = (unsigned short)p;
+		int län = 0;
+		k->getNachrichtEncrypted((char*)&län, 4);
+		char* ip = new char[län + 1];
+		ip[län] = 0;
+		k->getNachrichtEncrypted(ip, län);
+		this->ip = ip;
+		delete[] ip;
+		if (!trenne(0))
+		{
+			zielD->close();
+			zielD->release();
+			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht getrennt werden.";
+			cs.unlock();
+			return 0;
+		}
+		if (!verbinde())
+		{
+			zielD->close();
+			zielD->release();
+			err = "Fehler beim wechseln des Servers: Die Verbindung konnte nicht hergestellt werden.";
+			cs.unlock();
+			return 0;
+		}
+		zielD->close();
+		zielD->release();
+		cs.unlock();
+		return downloadDatei(gruppe, start, pfad, zielPfad, zFb, abbruch, maxbps);
+	}
+	int län = textLength(pfad);
+	k->sendeEncrypted((char*)&län, 4);
+	k->sendeEncrypted(pfad, län);
+	k->sendeEncrypted((char*)start, 8);
+	char* bytes = new char[2048];
+	unsigned short byteLän = 0;
+	k->getNachricht((char*)&byteLän, 2);
+	ZeitMesser* zMess = new ZeitMesser();
+	zMess->messungStart();
+	if (byteLän)
+	{
+		int bps = 0;
+		double sec = 0;
+		while (1)
+		{
+			k->getNachricht(bytes, byteLän);
+			zielD->schreibe(bytes, byteLän);
+			if (zFb)
+				zFb->aktionPlus(byteLän);
+			(*start) += byteLän;
+			bps += byteLän;
+			if (byteLän == 2048)
+			{
+				if ((*abbruch))
+				{
+					zielD->close();
+					zielD->release();
+					k->trenne();
+					k = (Network::Klient*)k->release();
+					delete[] bytes;
+					zMess->release();
+					cs.unlock();
+					return 1;
+				}
+				k->getNachricht((char*)&byteLän, 2); // sendelänge empfangen
+				if (!byteLän)
+					break;
+			}
+			else
+				break;
+			if (maxbps)
+			{
+				zMess->messungEnde();
+				sec += zMess->getSekunden();
+				zMess->messungStart();
+				if (sec >= 1)
+				{
+					sec = 0;
+					bps = 0;
+				}
+				while (bps >= maxbps)
+				{
+					Sleep(10);
+					zMess->messungEnde();
+					sec += zMess->getSekunden();
+					zMess->messungStart();
+					if (sec >= 1)
+					{
+						sec = 0;
+						bps = 0;
+					}
+				}
+			}
+		}
+	}
+	zMess->release();
+	delete[] bytes;
+	k->sendeEncrypted("\1", 1);
+	zielD->close();
+	zielD->release();
+	cs.unlock();
+	return 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool PatchClient::trenne( bool abmelden )
+bool PatchClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Patch Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Patch Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Patch Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Patch Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool PatchClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
 int PatchClient::getDownload() const
 {
-    return k ? k->getDownloadBytes( 1 ) : 0;
+	return k ? k->getDownloadBytes(1) : 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *PatchClient::getLetzterFehler() const
+const char* PatchClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/PatchClient.h

@@ -5,56 +5,56 @@
 
 namespace KSGClient
 {
-    class PatchClient : public PatchServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	class PatchClient : public PatchServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        PatchClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~PatchClient();
-        // verbindet ich mit dem Patch Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // Gibt eine Tabelle von Dateigruppen zurück.
-        //  Gibt bei misserfolg 0 zurück
-        Framework::KSGTDatei *getDateiGruppenListe() override;
-        // 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
-        Framework::KSGTDatei *getDateiListe( int gruppe ) override;
-        // Gibt die Größe einer Datei in bytes zurück
-        //  gruppe: Die Id der Dateigruppe der Datei
-        //  pfad: Der Pfad der Datei
-        __int64 getDateiGröße( int gruppe, const char *pfad ) override;
-        // 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
-        bool downloadDatei( int gruppe, __int64 *start, const char *pfad, const char *zielPfad, Framework::FBalken *zFb, bool *abbruch, int maxbps ) override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
-        int getDownload() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		PatchClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~PatchClient();
+		// verbindet ich mit dem Patch Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// Gibt eine Tabelle von Dateigruppen zurück.
+		//  Gibt bei misserfolg 0 zurück
+		Framework::KSGTDatei* getDateiGruppenListe() override;
+		// 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
+		Framework::KSGTDatei* getDateiListe(int gruppe) override;
+		// Gibt die Größe einer Datei in bytes zurück
+		//  gruppe: Die Id der Dateigruppe der Datei
+		//  pfad: Der Pfad der Datei
+		__int64 getDateiGröße(int gruppe, const char* pfad) override;
+		// 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
+		bool downloadDatei(int gruppe, __int64* start, const char* pfad, const char* zielPfad, Framework::FBalken* zFb, bool* abbruch, int maxbps) override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// Gibt die Anzahl von übertragenen Bytes seit dem letzten Aufruf zurück
+		int getDownload() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/RegisterClient.cpp

@@ -10,85 +10,85 @@ using namespace KSGClient;
 
 
 // Konstruktor
-RegisterClient::RegisterClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+RegisterClient::RegisterClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 RegisterClient::~RegisterClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet ich mit dem Register Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool RegisterClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::REGISTER, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::REGISTER, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Register Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Register Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Patch Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::REGISTER, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::REGISTER, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Register Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Register Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Patch Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde.
@@ -100,56 +100,56 @@ bool RegisterClient::verbinde()
 //  jahr: Das Jahr des Geburtsdatums
 //  monat: Der Monat des Geburtstages
 //  tag: Der Tag des Geburtstages
-bool RegisterClient::accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag )
+bool RegisterClient::accountErstellen(const char* name, const char* pass, const char* geheim, const char* eMail, unsigned short jahr, char monat, char tag)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\5", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 4 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( geheim ),
-            (unsigned char)textLength( eMail )
-        };
-        k->sendeEncrypted( (char *)län, 4 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->sendeEncrypted( geheim, län[ 2 ] );
-        k->sendeEncrypted( eMail, län[ 3 ] );
-        k->sendeEncrypted( (char *)&jahr, 2 );
-        k->sendeEncrypted( &monat, 1 );
-        k->sendeEncrypted( &tag, 1 );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\5", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[4] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(geheim),
+			(unsigned char)textLength(eMail)
+		};
+		k->sendeEncrypted((char*)län, 4);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->sendeEncrypted(geheim, län[2]);
+		k->sendeEncrypted(eMail, län[3]);
+		k->sendeEncrypted((char*)&jahr, 2);
+		k->sendeEncrypted(&monat, 1);
+		k->sendeEncrypted(&tag, 1);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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.
@@ -157,51 +157,51 @@ bool RegisterClient::accountErstellen( const char *name, const char *pass, const
 //  name: Der Login Name des Accounts
 //  pass: Das Login Passwort des Accounts
 //  geheim: Das Geheimnis des Accounts
-bool RegisterClient::accountLöschen( const char *name, const char *pass, const char *geheim )
+bool RegisterClient::accountLöschen(const char* name, const char* pass, const char* geheim)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 3 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( geheim )
-        };
-        k->sendeEncrypted( (char *)län, 3 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->sendeEncrypted( geheim, län[ 2 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[3] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(geheim)
+		};
+		k->sendeEncrypted((char*)län, 3);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->sendeEncrypted(geheim, län[2]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Ändert das Passwort eines Accounts
@@ -210,53 +210,53 @@ bool RegisterClient::accountL
 //  pass: Das Login Passwort des Accounts
 //  geheim: Das Geheimnis des Accounts
 //  nPass: Das neue Passwort des Accounts
-bool RegisterClient::passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass )
+bool RegisterClient::passwortÄndern(const char* name, const char* pass, const char* geheim, const char* nPass)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\7", 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 4 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( nPass ),
-            (unsigned char)textLength( geheim )
-        };
-        k->sendeEncrypted( (char *)län, 4 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->sendeEncrypted( nPass, län[ 2 ] );
-        k->sendeEncrypted( geheim, län[ 3 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\7", 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[4] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(nPass),
+			(unsigned char)textLength(geheim)
+		};
+		k->sendeEncrypted((char*)län, 4);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->sendeEncrypted(nPass, län[2]);
+		k->sendeEncrypted(geheim, län[3]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Ändert die EMail Adresse eines Accounts
@@ -265,54 +265,54 @@ bool RegisterClient::passwort
 //  pass: Das Login Passwort des Accounts
 //  geheim: Das Geheimnis des Accounts
 //  nEMail: Die neue EMail Adresse
-bool RegisterClient::eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail )
+bool RegisterClient::eMailÄndern(const char* name, const char* pass, const char* geheim, const char* nEMail)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char byte = 8;
-    k->sendeEncrypted( &byte, 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 4 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( geheim ),
-            (unsigned char)textLength( nEMail )
-        };
-        k->sendeEncrypted( (char *)län, 4 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->sendeEncrypted( geheim, län[ 2 ] );
-        k->sendeEncrypted( nEMail, län[ 3 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char byte = 8;
+	k->sendeEncrypted(&byte, 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[4] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(geheim),
+			(unsigned char)textLength(nEMail)
+		};
+		k->sendeEncrypted((char*)län, 4);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->sendeEncrypted(geheim, län[2]);
+		k->sendeEncrypted(nEMail, län[3]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Ändert das Geheimnis eines Accounts
@@ -321,204 +321,204 @@ bool RegisterClient::eMail
 //  pass: Das Login Passwort des Accounts
 //  geheim: Das Geheimnis des Accounts
 //  nGeheim: Das neue Geheimnis
-bool RegisterClient::geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim )
+bool RegisterClient::geheimnisÄndern(const char* name, const char* pass, const char* geheim, const char* nGeheim)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char byte = 9;
-    k->sendeEncrypted( &byte, 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 4 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( geheim ),
-            (unsigned char)textLength( nGeheim )
-        };
-        k->sendeEncrypted( (char *)län, 4 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->sendeEncrypted( geheim, län[ 2 ] );
-        k->sendeEncrypted( nGeheim, län[ 3 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char byte = 9;
+	k->sendeEncrypted(&byte, 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[4] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(geheim),
+			(unsigned char)textLength(nGeheim)
+		};
+		k->sendeEncrypted((char*)län, 4);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->sendeEncrypted(geheim, län[2]);
+		k->sendeEncrypted(nGeheim, län[3]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool RegisterClient::nameVergessen( const char *pass, const char *geheim )
+bool RegisterClient::nameVergessen(const char* pass, const char* geheim)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char byte = 0xA;
-    k->sendeEncrypted( &byte, 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 2 ] = {
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( geheim )
-        };
-        k->sendeEncrypted( (char *)län, 2 );
-        k->sendeEncrypted( pass, län[ 0 ] );
-        k->sendeEncrypted( geheim, län[ 1 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char byte = 0xA;
+	k->sendeEncrypted(&byte, 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[2] = {
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(geheim)
+		};
+		k->sendeEncrypted((char*)län, 2);
+		k->sendeEncrypted(pass, län[0]);
+		k->sendeEncrypted(geheim, län[1]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool RegisterClient::passwortVergessen( const char *name, const char *geheim )
+bool RegisterClient::passwortVergessen(const char* name, const char* geheim)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char byte = 0xB;
-    k->sendeEncrypted( &byte, 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 2 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( geheim )
-        };
-        k->sendeEncrypted( (char *)län, 2 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( geheim, län[ 1 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char byte = 0xB;
+	k->sendeEncrypted(&byte, 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[2] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(geheim)
+		};
+		k->sendeEncrypted((char*)län, 2);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(geheim, län[1]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool RegisterClient::geheimnisVergessen( const char *name, const char *pass )
+bool RegisterClient::geheimnisVergessen(const char* name, const char* pass)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char byte = 0xC;
-    k->sendeEncrypted( &byte, 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 2 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass )
-        };
-        k->sendeEncrypted( (char *)län, 2 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char byte = 0xC;
+	k->sendeEncrypted(&byte, 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[2] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass)
+		};
+		k->sendeEncrypted((char*)län, 2);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben
@@ -527,58 +527,58 @@ bool RegisterClient::geheimnisVergessen( const char *name, const char *pass )
 //  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
-bool RegisterClient::eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail )
+bool RegisterClient::eMailVergessen(const char* name, const char* pass, const char* geheim, char** eMail)
 {
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char byte2 = 0xD;
-    k->sendeEncrypted( &byte2, 1 );
-    char serverReturn = 0;
-    k->getNachrichtEncrypted( &serverReturn, 1 );
-    if( serverReturn == 1 )
-    {
-        unsigned char län[ 3 ] = {
-            (unsigned char)textLength( name ),
-            (unsigned char)textLength( pass ),
-            (unsigned char)textLength( geheim )
-        };
-        k->sendeEncrypted( (char *)län, 3 );
-        k->sendeEncrypted( name, län[ 0 ] );
-        k->sendeEncrypted( pass, län[ 1 ] );
-        k->sendeEncrypted( geheim, län[ 2 ] );
-        k->getNachrichtEncrypted( &serverReturn, 1 );
-        if( serverReturn == 1 )
-        {
-            unsigned char len = 0;
-            k->getNachrichtEncrypted( (char *)&len, 1 );
-            char *mail = new char[ len + 1 ];
-            mail[ len ] = 0;
-            k->getNachrichtEncrypted( mail, len );
-            *eMail = mail;
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( serverReturn == 3 )
-    {
-        char byte = 0;
-        k->getNachrichtEncrypted( &byte, 1 );
-        char *fehler = new char[ byte + 1 ];
-        fehler[ byte ] = 0;
-        k->getNachrichtEncrypted( fehler, byte );
-        err = fehler;
-        delete[]fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char byte2 = 0xD;
+	k->sendeEncrypted(&byte2, 1);
+	char serverReturn = 0;
+	k->getNachrichtEncrypted(&serverReturn, 1);
+	if (serverReturn == 1)
+	{
+		unsigned char län[3] = {
+			(unsigned char)textLength(name),
+			(unsigned char)textLength(pass),
+			(unsigned char)textLength(geheim)
+		};
+		k->sendeEncrypted((char*)län, 3);
+		k->sendeEncrypted(name, län[0]);
+		k->sendeEncrypted(pass, län[1]);
+		k->sendeEncrypted(geheim, län[2]);
+		k->getNachrichtEncrypted(&serverReturn, 1);
+		if (serverReturn == 1)
+		{
+			unsigned char len = 0;
+			k->getNachrichtEncrypted((char*)&len, 1);
+			char* mail = new char[len + 1];
+			mail[len] = 0;
+			k->getNachrichtEncrypted(mail, len);
+			*eMail = mail;
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (serverReturn == 3)
+	{
+		char byte = 0;
+		k->getNachrichtEncrypted(&byte, 1);
+		char* fehler = new char[byte + 1];
+		fehler[byte] = 0;
+		k->getNachrichtEncrypted(fehler, byte);
+		err = fehler;
+		delete[]fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erhält die Verbindung aufrecht
@@ -586,83 +586,83 @@ bool RegisterClient::eMailVergessen( const char *name, const char *pass, const c
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool RegisterClient::keepAlive()
 {
-    if( !k )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    Framework::logLine( (char *)"Verbindungstest zum Register Server..." );
-    bool ok = k->sendeEncrypted( "\xF", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	if (!k)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	Framework::logLine((char*)"Verbindungstest zum Register Server...");
+	bool ok = k->sendeEncrypted("\xF", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool RegisterClient::trenne( bool abmelden )
+bool RegisterClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Register Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Register Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Register Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Register Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool RegisterClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *RegisterClient::getLetzterFehler() const
+const char* RegisterClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/RegisterServer.h

@@ -5,98 +5,98 @@
 
 namespace KSGClient
 {
-    // Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
-    class RegisterClient : public RegisterServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen
+	class RegisterClient : public RegisterServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        RegisterClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~RegisterClient();
-        // verbindet ich mit dem Register Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // 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
-        bool accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag ) override;
-        // 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
-        bool accountLöschen( const char *name, const char *pass, const char *geheim ) override;
-        // Ä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
-        bool passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass ) override;
-        // Ä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
-        bool eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail ) override;
-        // Ä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
-        bool geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim ) override;
-        // 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
-        bool nameVergessen( const char *pass, const char *geheim ) override;
-        // 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
-        bool passwortVergessen( const char *name, const char *geheim ) override;
-        // 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
-        bool geheimnisVergessen( const char *name, const char *pass ) override;
-        // 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
-        bool eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		RegisterClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~RegisterClient();
+		// verbindet ich mit dem Register Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// 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
+		bool accountErstellen(const char* name, const char* pass, const char* geheim, const char* eMail, unsigned short jahr, char monat, char tag) override;
+		// 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
+		bool accountLöschen(const char* name, const char* pass, const char* geheim) override;
+		// Ä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
+		bool passwortÄndern(const char* name, const char* pass, const char* geheim, const char* nPass) override;
+		// Ä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
+		bool eMailÄndern(const char* name, const char* pass, const char* geheim, const char* nEMail) override;
+		// Ä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
+		bool geheimnisÄndern(const char* name, const char* pass, const char* geheim, const char* nGeheim) override;
+		// 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
+		bool nameVergessen(const char* pass, const char* geheim) override;
+		// 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
+		bool passwortVergessen(const char* name, const char* geheim) override;
+		// 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
+		bool geheimnisVergessen(const char* name, const char* pass) override;
+		// 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
+		bool eMailVergessen(const char* name, const char* pass, const char* geheim, char** eMail) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/ShopClient.cpp

@@ -9,937 +9,941 @@ using namespace KSGClient;
 // Inhalt der ShopClient Klasse
 
 // Konstruktor
-ShopClient::ShopClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+ShopClient::ShopClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    k = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	k = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 ShopClient::~ShopClient()
 {
-    trenne( 1 );
-    delete[] key;
+	trenne(1);
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Shop Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool ShopClient::verbinde()
 {
-    cs.lock();
-    if( k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    k = new Network::Klient();
-    int l = 0;
-    char *key;
-    Keys::getServerKey( &key, l, Keys::SHOP, Keys::SENDEN );
-    k->setSendeKey( key, l );
-    delete[] key;
-    Keys::getServerKey( &key, l, Keys::SHOP, Keys::EMPFANGEN );
-    k->setEmpfangKey( key, l );
-    delete[] key;
-    if( k->verbinde( port, ip ) )
-    {
-        if( k->sendeEncrypted( "\1", 1 ) )
-        {
-            k->sendeEncrypted( (char *)&cId, 4 );
-            char serverReturn = 0;
-            k->getNachrichtEncrypted( &serverReturn, 1 );
-            if( serverReturn == 3 )
-            {
-                char byte = 0;
-                k->getNachrichtEncrypted( &byte, 1 );
-                char *f = new char[ byte + 1 ];
-                f[ byte ] = 0;
-                k->getNachrichtEncrypted( f, byte );
-                err = "error while identifying client Shop Server returned: ";
-                err += f;
-                delete[]f;
-                trenne( 0 );
-                cs.unlock();
-                return 0;
-            }
-            k->setSendeKey( this->key, this->keyLen );
-            k->setEmpfangKey( this->key, this->keyLen );
-        }
-        else
-        {
-            err = "network error while sending to Shop Server";
-            k = (Network::Klient *)k->release();
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "network error while connecting to Shop Server";
-        k = (Network::Klient *)k->release();
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	k = new Network::Klient();
+	int l = 0;
+	char* key;
+	Keys::getServerKey(&key, l, Keys::SHOP, Keys::SENDEN);
+	k->setSendeKey(key, l);
+	delete[] key;
+	Keys::getServerKey(&key, l, Keys::SHOP, Keys::EMPFANGEN);
+	k->setEmpfangKey(key, l);
+	delete[] key;
+	if (k->verbinde(port, ip))
+	{
+		if (k->sendeEncrypted("\1", 1))
+		{
+			k->sendeEncrypted((char*)&cId, 4);
+			char serverReturn = 0;
+			k->getNachrichtEncrypted(&serverReturn, 1);
+			if (serverReturn == 3)
+			{
+				char byte = 0;
+				k->getNachrichtEncrypted(&byte, 1);
+				char* f = new char[byte + 1];
+				f[byte] = 0;
+				k->getNachrichtEncrypted(f, byte);
+				err = "error while identifying client Shop Server returned: ";
+				err += f;
+				delete[]f;
+				trenne(0);
+				cs.unlock();
+				return 0;
+			}
+			k->setSendeKey(this->key, this->keyLen);
+			k->setEmpfangKey(this->key, this->keyLen);
+		}
+		else
+		{
+			err = "network error while sending to Shop Server";
+			k = (Network::Klient*)k->release();
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "network error while connecting to Shop Server";
+		k = (Network::Klient*)k->release();
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-Framework::Array< int > *ShopClient::suchSpiele( const char *suche )
+Framework::Array< int >* ShopClient::suchSpiele(const char* suche)
 {
-    char län = (char)textLength( suche );
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\5", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( &län, 1 );
-        if( län )
-            k->sendeEncrypted( suche, län );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            Array< int > *ret = new Array< int >();
-            for( int i = 0; i < anz; i++ )
-            {
-                int w = 0;
-                k->getNachrichtEncrypted( (char *)&w, 4 );
-                ret->add( w );
-            }
-            cs.unlock();
-            return ret;
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &län, 1 );
-        char *fehler = new char[ län + 1 ];
-        fehler[ län ] = 0;
-        if( län )
-            k->getNachrichtEncrypted( fehler, län );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char län = (char)textLength(suche);
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\5", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted(&län, 1);
+		if (län)
+			k->sendeEncrypted(suche, län);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			Array< int >* ret = new Array< int >();
+			for (int i = 0; i < anz; i++)
+			{
+				int w = 0;
+				k->getNachrichtEncrypted((char*)&w, 4);
+				ret->add(w);
+			}
+			cs.unlock();
+			return ret;
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&län, 1);
+		char* fehler = new char[län + 1];
+		fehler[län] = 0;
+		if (län)
+			k->getNachrichtEncrypted(fehler, län);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool ShopClient::ladeSpielTitel( int id )
+bool ShopClient::ladeSpielTitel(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\6", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            Text *pf = new Text( "data/tmp/shop/kaufen/spiele/" );
-            pf->append( id );
-            pf->append( "/titelbg.ltdb" );
-            Datei *dat = new Datei();
-            dat->setDatei( pf );
-            dat->erstellen();
-            dat->open( Datei::Style::schreiben );
-            __int64 gr = 0;
-            k->getNachrichtEncrypted( (char *)&gr, 8 );
-            char bytes[ 2048 ];
-            while( gr > 0 )
-            {
-                int län = gr > 2048 ? 2048 : (int)gr;
-                k->getNachricht( bytes, län );
-                dat->schreibe( bytes, län );
-                gr -= län;
-            }
-            dat->close();
-            dat->release();
-        }
-        if( ret == 2 )
-        { // Verweis auf anderen ShopServer
-            char län = 0;
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            k->getNachrichtEncrypted( &län, 1 );
-            delete[] ip;
-            ip = new char[ län + 1 ];
-            k->getNachrichtEncrypted( ip, län );
-            ip[ län ] = 0;
-            k->trenne();
-            k = (Network::Klient *)k->release();
-            if( !verbinde() )
-            {
-                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
-                cs.unlock();
-                return 0;
-            }
-            cs.unlock();
-            return ladeSpielTitel( id );
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\6", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			Text* pf = new Text("data/tmp/shop/kaufen/spiele/");
+			pf->append(id);
+			pf->append("/titelbg.ltdb");
+			Datei* dat = new Datei();
+			dat->setDatei(pf);
+			dat->erstellen();
+			dat->open(Datei::Style::schreiben);
+			__int64 gr = 0;
+			k->getNachrichtEncrypted((char*)&gr, 8);
+			char bytes[2048];
+			while (gr > 0)
+			{
+				int län = gr > 2048 ? 2048 : (int)gr;
+				k->getNachricht(bytes, län);
+				dat->schreibe(bytes, län);
+				gr -= län;
+			}
+			dat->close();
+			dat->release();
+		}
+		if (ret == 2)
+		{ // Verweis auf anderen ShopServer
+			char län = 0;
+			k->getNachrichtEncrypted((char*)&port, 4);
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			k->getNachrichtEncrypted(ip, län);
+			ip[län] = 0;
+			this->ip = ip;
+			delete[] ip;
+			k->trenne();
+			k = (Network::Klient*)k->release();
+			if (!verbinde())
+			{
+				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
+				cs.unlock();
+				return 0;
+			}
+			cs.unlock();
+			return ladeSpielTitel(id);
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool ShopClient::ladeSpielSeite( int id )
+bool ShopClient::ladeSpielSeite(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\7", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            Text *pf = new Text( "data/tmp/shop/kaufen/spiele/" );
-            pf->append( id );
-            pf->append( "/" );
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                char län = 0;
-                k->getNachrichtEncrypted( &län, 1 );
-                char *name = new char[ län + 1 ];
-                name[ län ] = 0;
-                k->getNachrichtEncrypted( name, län );
-                Text *pfad = new Text( pf->getText() );
-                pfad->append( name );
-                delete[] name;
-                Datei *d = new Datei();
-                d->setDatei( pfad );
-                d->erstellen();
-                d->open( Datei::Style::schreiben );
-                __int64 gr = 0;
-                k->getNachrichtEncrypted( (char *)&gr, 8 );
-                char bytes[ 2048 ];
-                while( gr > 0 )
-                {
-                    int län = gr > 2048 ? 2048 : (int)gr;
-                    k->getNachricht( bytes, län );
-                    d->schreibe( bytes, län );
-                    gr -= län;
-                }
-                d->close();
-                d->release();
-            }
-            pf->release();
-        }
-        if( ret == 2 )
-        { // Verweis auf anderen ShopServer
-            char län = 0;
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            k->getNachrichtEncrypted( &län, 1 );
-            delete[] ip;
-            ip = new char[ län + 1 ];
-            k->getNachrichtEncrypted( ip, län );
-            ip[ län ] = 0;
-            k->trenne();
-            k = (Network::Klient *)k->release();
-            if( !verbinde() )
-            {
-                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
-                cs.unlock();
-                return 0;
-            }
-            cs.unlock();
-            return ladeSpielSeite( id );
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\7", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			Text* pf = new Text("data/tmp/shop/kaufen/spiele/");
+			pf->append(id);
+			pf->append("/");
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				char län = 0;
+				k->getNachrichtEncrypted(&län, 1);
+				char* name = new char[län + 1];
+				name[län] = 0;
+				k->getNachrichtEncrypted(name, län);
+				Text* pfad = new Text(pf->getText());
+				pfad->append(name);
+				delete[] name;
+				Datei* d = new Datei();
+				d->setDatei(pfad);
+				d->erstellen();
+				d->open(Datei::Style::schreiben);
+				__int64 gr = 0;
+				k->getNachrichtEncrypted((char*)&gr, 8);
+				char bytes[2048];
+				while (gr > 0)
+				{
+					int län = gr > 2048 ? 2048 : (int)gr;
+					k->getNachricht(bytes, län);
+					d->schreibe(bytes, län);
+					gr -= län;
+				}
+				d->close();
+				d->release();
+			}
+			pf->release();
+		}
+		if (ret == 2)
+		{ // Verweis auf anderen ShopServer
+			char län = 0;
+			k->getNachrichtEncrypted((char*)&port, 4);
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			k->getNachrichtEncrypted(ip, län);
+			ip[län] = 0;
+			this->ip = ip;
+			delete[] ip;
+			k->trenne();
+			k = (Network::Klient*)k->release();
+			if (!verbinde())
+			{
+				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
+				cs.unlock();
+				return 0;
+			}
+			cs.unlock();
+			return ladeSpielSeite(id);
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
 //  id: Die Id des Spiels
-int ShopClient::getSpielBesitzStatus( int id )
+int ShopClient::getSpielBesitzStatus(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x8", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x8", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt die Anzahl der verbleibenden Spiele der Testversion zurück
 //  id: Die Id des Spiels
-int ShopClient::getSpielTestversion( int id )
+int ShopClient::getSpielTestversion(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x9", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x9", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
 //  id: Die Id des Spiels
-int ShopClient::istSpielErwerbbar( int id )
+int ShopClient::istSpielErwerbbar(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xA", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xA", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-int ShopClient::getSpielPreis( int id, bool testVersion )
+int ShopClient::getSpielPreis(int id, bool testVersion)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xB", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->sendeEncrypted( (char *)&testVersion, 1 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xB", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->sendeEncrypted((char*)&testVersion, 1);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Kauft ein Spiel
 //  id: Die Id des Spiels
 //  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
-bool ShopClient::spielErwerben( int spielId, bool testVersion )
+bool ShopClient::spielErwerben(int spielId, bool testVersion)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xC", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&spielId, 4 );
-        k->sendeEncrypted( (char *)&testVersion, 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xC", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&spielId, 4);
+		k->sendeEncrypted((char*)&testVersion, 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-Framework::Array< int > *ShopClient::suchKarten( const char *suche, int spielId )
+Framework::Array< int >* ShopClient::suchKarten(const char* suche, int spielId)
 {
-    char län = (char)textLength( suche );
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xD", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&spielId, 4 );
-        k->sendeEncrypted( &län, 1 );
-        if( län )
-            k->sendeEncrypted( suche, län );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            Array< int > *ret = new Array< int >();
-            for( int i = 0; i < anz; i++ )
-            {
-                int w = 0;
-                k->getNachrichtEncrypted( (char *)&w, 4 );
-                ret->add( w );
-            }
-            cs.unlock();
-            return ret;
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &län, 1 );
-        char *fehler = new char[ län + 1 ];
-        fehler[ län ] = 0;
-        if( län )
-            k->getNachrichtEncrypted( fehler, län );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char län = (char)textLength(suche);
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xD", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&spielId, 4);
+		k->sendeEncrypted(&län, 1);
+		if (län)
+			k->sendeEncrypted(suche, län);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			Array< int >* ret = new Array< int >();
+			for (int i = 0; i < anz; i++)
+			{
+				int w = 0;
+				k->getNachrichtEncrypted((char*)&w, 4);
+				ret->add(w);
+			}
+			cs.unlock();
+			return ret;
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&län, 1);
+		char* fehler = new char[län + 1];
+		fehler[län] = 0;
+		if (län)
+			k->getNachrichtEncrypted(fehler, län);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-bool ShopClient::ladeKarteTitel( int id )
+bool ShopClient::ladeKarteTitel(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xE", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            Text *pf = new Text( "data/tmp/shop/kaufen/karten/" );
-            pf->append( id );
-            pf->append( "/titelbg.ltdb" );
-            Datei *dat = new Datei();
-            dat->setDatei( pf );
-            dat->erstellen();
-            dat->open( Datei::Style::schreiben );
-            __int64 gr = 0;
-            k->getNachrichtEncrypted( (char *)&gr, 8 );
-            char bytes[ 2048 ];
-            while( gr > 0 )
-            {
-                int län = gr > 2048 ? 2048 : (int)gr;
-                k->getNachricht( bytes, län );
-                dat->schreibe( bytes, län );
-                gr -= län;
-            }
-            dat->close();
-            dat->release();
-        }
-        if( ret == 2 )
-        { // Verweis auf anderen ShopServer
-            char län = 0;
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            k->getNachrichtEncrypted( &län, 1 );
-            delete[] ip;
-            ip = new char[ län + 1 ];
-            k->getNachrichtEncrypted( ip, län );
-            ip[ län ] = 0;
-            k->trenne();
-            k = (Network::Klient *)k->release();
-            if( !verbinde() )
-            {
-                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
-                cs.unlock();
-                return 0;
-            }
-            cs.unlock();
-            return ladeKarteTitel( id );
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xE", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			Text* pf = new Text("data/tmp/shop/kaufen/karten/");
+			pf->append(id);
+			pf->append("/titelbg.ltdb");
+			Datei* dat = new Datei();
+			dat->setDatei(pf);
+			dat->erstellen();
+			dat->open(Datei::Style::schreiben);
+			__int64 gr = 0;
+			k->getNachrichtEncrypted((char*)&gr, 8);
+			char bytes[2048];
+			while (gr > 0)
+			{
+				int län = gr > 2048 ? 2048 : (int)gr;
+				k->getNachricht(bytes, län);
+				dat->schreibe(bytes, län);
+				gr -= län;
+			}
+			dat->close();
+			dat->release();
+		}
+		if (ret == 2)
+		{ // Verweis auf anderen ShopServer
+			char län = 0;
+			k->getNachrichtEncrypted((char*)&port, 4);
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			k->getNachrichtEncrypted(ip, län);
+			ip[län] = 0;
+			this->ip = ip;
+			delete[] ip;
+			k->trenne();
+			k = (Network::Klient*)k->release();
+			if (!verbinde())
+			{
+				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
+				cs.unlock();
+				return 0;
+			}
+			cs.unlock();
+			return ladeKarteTitel(id);
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool ShopClient::ladeKarteSeite( int id )
+bool ShopClient::ladeKarteSeite(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\xF", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            Text *pf = new Text( "data/tmp/shop/kaufen/karten/" );
-            pf->append( id );
-            pf->append( "/" );
-            int anz = 0;
-            k->getNachrichtEncrypted( (char *)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                char län = 0;
-                k->getNachrichtEncrypted( &län, 1 );
-                char *name = new char[ län + 1 ];
-                name[ län ] = 0;
-                k->getNachrichtEncrypted( name, län );
-                Text *pfad = new Text( pf->getText() );
-                pfad->append( name );
-                delete[] name;
-                Datei *d = new Datei();
-                d->setDatei( pfad );
-                d->erstellen();
-                d->open( Datei::Style::schreiben );
-                __int64 gr = 0;
-                k->getNachrichtEncrypted( (char *)&gr, 8 );
-                char bytes[ 2048 ];
-                while( gr > 0 )
-                {
-                    int län = gr > 2048 ? 2048 : (int)gr;
-                    k->getNachricht( bytes, län );
-                    d->schreibe( bytes, län );
-                    gr -= län;
-                }
-                d->close();
-                d->release();
-            }
-            pf->release();
-        }
-        if( ret == 2 )
-        { // Verweis auf anderen ShopServer
-            char län = 0;
-            k->getNachrichtEncrypted( (char *)&port, 4 );
-            k->getNachrichtEncrypted( &län, 1 );
-            delete[] ip;
-            ip = new char[ län + 1 ];
-            k->getNachrichtEncrypted( ip, län );
-            ip[ län ] = 0;
-            k->trenne();
-            k = (Network::Klient *)k->release();
-            if( !verbinde() )
-            {
-                err = "Fehler beim Verbinden mit zuständigen Shop Server.";
-                cs.unlock();
-                return 0;
-            }
-            cs.unlock();
-            return ladeKarteSeite( id );
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    cs.unlock();
-    return 1;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\xF", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			Text* pf = new Text("data/tmp/shop/kaufen/karten/");
+			pf->append(id);
+			pf->append("/");
+			int anz = 0;
+			k->getNachrichtEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				char län = 0;
+				k->getNachrichtEncrypted(&län, 1);
+				char* name = new char[län + 1];
+				name[län] = 0;
+				k->getNachrichtEncrypted(name, län);
+				Text* pfad = new Text(pf->getText());
+				pfad->append(name);
+				delete[] name;
+				Datei* d = new Datei();
+				d->setDatei(pfad);
+				d->erstellen();
+				d->open(Datei::Style::schreiben);
+				__int64 gr = 0;
+				k->getNachrichtEncrypted((char*)&gr, 8);
+				char bytes[2048];
+				while (gr > 0)
+				{
+					int län = gr > 2048 ? 2048 : (int)gr;
+					k->getNachricht(bytes, län);
+					d->schreibe(bytes, län);
+					gr -= län;
+				}
+				d->close();
+				d->release();
+			}
+			pf->release();
+		}
+		if (ret == 2)
+		{ // Verweis auf anderen ShopServer
+			char län = 0;
+			k->getNachrichtEncrypted((char*)&port, 4);
+			k->getNachrichtEncrypted(&län, 1);
+			char* ip = new char[län + 1];
+			k->getNachrichtEncrypted(ip, län);
+			ip[län] = 0;
+			this->ip = ip;
+			delete[] ip;
+			k->trenne();
+			k = (Network::Klient*)k->release();
+			if (!verbinde())
+			{
+				err = "Fehler beim Verbinden mit zuständigen Shop Server.";
+				cs.unlock();
+				return 0;
+			}
+			cs.unlock();
+			return ladeKarteSeite(id);
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	cs.unlock();
+	return 1;
 }
 
 // Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
 //  id: Die Id der Karte
-int ShopClient::getKarteBesitzStatus( int id )
+int ShopClient::getKarteBesitzStatus(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x10", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x10", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // gibt die Anzahl der verbleibenden Spiele der Testversion zurück
 //  id: Die Id der Karte
-int ShopClient::getKarteTestversion( int id )
+int ShopClient::getKarteTestversion(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x11", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x11", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
 //  id: Die Id der Karte
-int ShopClient::istKarteErwerbbar( int id )
+int ShopClient::istKarteErwerbbar(int id)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x12", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x12", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 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
-int ShopClient::getKartePreis( int id, bool testVersion )
+int ShopClient::getKartePreis(int id, bool testVersion)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x13", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&id, 4 );
-        k->sendeEncrypted( (char *)&testVersion, 1 );
-        int ret = 0;
-        k->getNachrichtEncrypted( (char *)&ret, 4 );
-        cs.unlock();
-        return ret;
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x13", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&id, 4);
+		k->sendeEncrypted((char*)&testVersion, 1);
+		int ret = 0;
+		k->getNachrichtEncrypted((char*)&ret, 4);
+		cs.unlock();
+		return ret;
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Kauft eine Karte
 //  id: Die Id der Karte
 //  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
-bool ShopClient::karteErwerben( int karteId, bool testVersion )
+bool ShopClient::karteErwerben(int karteId, bool testVersion)
 {
-    char ret = 0;
-    cs.lock();
-    if( !k )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    k->sendeEncrypted( "\x14", 1 );
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 1 )
-    {
-        k->sendeEncrypted( (char *)&karteId, 4 );
-        k->sendeEncrypted( (char *)&testVersion, 1 );
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 1 )
-        {
-            cs.unlock();
-            return 1;
-        }
-    }
-    if( ret == 3 )
-    {
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *fehler = new char[ ret + 1 ];
-        fehler[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( fehler, ret );
-        err = fehler;
-        delete[] fehler;
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	char ret = 0;
+	cs.lock();
+	if (!k)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	k->sendeEncrypted("\x14", 1);
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 1)
+	{
+		k->sendeEncrypted((char*)&karteId, 4);
+		k->sendeEncrypted((char*)&testVersion, 1);
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 1)
+		{
+			cs.unlock();
+			return 1;
+		}
+	}
+	if (ret == 3)
+	{
+		k->getNachrichtEncrypted(&ret, 1);
+		char* fehler = new char[ret + 1];
+		fehler[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(fehler, ret);
+		err = fehler;
+		delete[] fehler;
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Erhält die Verbindung aufrecht
@@ -947,83 +951,83 @@ bool ShopClient::karteErwerben( int karteId, bool testVersion )
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool ShopClient::keepAlive()
 {
-    if( !k )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    Framework::logLine( (char *)"Verbindungstest zum Shop Server..." );
-    bool ok = k->sendeEncrypted( "\x15", 1 );
-    ok &= k->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        Framework::logLine( (char *)"Verbindungsabbruch." );
-        trenne( 0 );
-    }
-    else
-        Framework::logLine( (char *)"Verbindung besteht." );
-    return res == 1;
+	if (!k)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	Framework::logLine((char*)"Verbindungstest zum Shop Server...");
+	bool ok = k->sendeEncrypted("\x15", 1);
+	ok &= k->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		Framework::logLine((char*)"Verbindungsabbruch.");
+		trenne(0);
+	}
+	else
+		Framework::logLine((char*)"Verbindung besteht.");
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-bool ShopClient::trenne( bool abmelden )
+bool ShopClient::trenne(bool abmelden)
 {
-    cs.lock();
-    verbinde();
-    if( !k )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( abmelden )
-    {
-        k->sendeEncrypted( "\4", 1 );
-        char ret = 0;
-        k->getNachrichtEncrypted( &ret, 1 );
-        if( ret == 3 )
-        { // error
-            k->getNachrichtEncrypted( &ret, 1 );
-            char *msg = new char[ ret + 1 ];
-            msg[ ret ] = 0;
-            if( ret )
-                k->getNachrichtEncrypted( msg, ret );
-            err = "error while unregister Client Login Server returned: ";
-            err += msg;
-            delete[] msg;
-        }
-    }
-    k->sendeEncrypted( "\3", 1 );
-    char ret = 0;
-    k->getNachrichtEncrypted( &ret, 1 );
-    if( ret == 3 )
-    { // error
-        k->getNachrichtEncrypted( &ret, 1 );
-        char *msg = new char[ ret + 1 ];
-        msg[ ret ] = 0;
-        if( ret )
-            k->getNachrichtEncrypted( msg, ret );
-        err = "error while trenne Login Server returned: ";
-        err += msg;
-        delete[] msg;
-    }
-    k->trenne();
-    k = (Network::Klient *)k->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	verbinde();
+	if (!k)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (abmelden)
+	{
+		k->sendeEncrypted("\4", 1);
+		char ret = 0;
+		k->getNachrichtEncrypted(&ret, 1);
+		if (ret == 3)
+		{ // error
+			k->getNachrichtEncrypted(&ret, 1);
+			char* msg = new char[ret + 1];
+			msg[ret] = 0;
+			if (ret)
+				k->getNachrichtEncrypted(msg, ret);
+			err = "error while unregister Client Login Server returned: ";
+			err += msg;
+			delete[] msg;
+		}
+	}
+	k->sendeEncrypted("\3", 1);
+	char ret = 0;
+	k->getNachrichtEncrypted(&ret, 1);
+	if (ret == 3)
+	{ // error
+		k->getNachrichtEncrypted(&ret, 1);
+		char* msg = new char[ret + 1];
+		msg[ret] = 0;
+		if (ret)
+			k->getNachrichtEncrypted(msg, ret);
+		err = "error while trenne Login Server returned: ";
+		err += msg;
+		delete[] msg;
+	}
+	k->trenne();
+	k = (Network::Klient*)k->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool ShopClient::istVerbunden() const
 {
-    return k != 0;
+	return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *ShopClient::getLetzterFehler() const
+const char* ShopClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/ShopClient.h

@@ -5,99 +5,99 @@
 
 namespace KSGClient
 {
-    // Wird verwendet um Spiele oder Karten zu kaufen
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class ShopClient : public ShopServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *k;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird verwendet um Spiele oder Karten zu kaufen
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class ShopClient : public ShopServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* k;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        ShopClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~ShopClient();
-        // verbindet sich mit dem zugewiesenen Shop Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // 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
-        Framework::Array< int > *suchSpiele( const char *suche ) override;
-        // 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
-        bool ladeSpielTitel( int id ) override;
-        // 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
-        bool ladeSpielSeite( int id ) override;
-        // Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
-        //  id: Die Id des Spiels
-        int getSpielBesitzStatus( int id ) override;
-        // gibt die Anzahl der verbleibenden Spiele der Testversion zurück
-        //  id: Die Id des Spiels
-        int getSpielTestversion( int id ) override;
-        // Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
-        //  id: Die Id des Spiels
-        int istSpielErwerbbar( int id ) override;
-        // 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
-        int getSpielPreis( int id, bool testVersion ) override;
-        // Kauft ein Spiel
-        //  id: Die Id des Spiels
-        //  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
-        bool spielErwerben( int spielId, bool testVersion ) override;
-        // 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
-        Framework::Array< int > *suchKarten( const char *suche, int spielId ) override;
-        // 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
-        bool ladeKarteTitel( int id ) override;
-        // 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
-        bool ladeKarteSeite( int id ) override;
-        // Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
-        //  id: Die Id der Karte
-        int getKarteBesitzStatus( int id ) override;
-        // gibt die Anzahl der verbleibenden Spiele der Testversion zurück
-        //  id: Die Id der Karte
-        int getKarteTestversion( int id ) override;
-        // Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
-        //  id: Die Id der Karte
-        int istKarteErwerbbar( int id ) override;
-        // 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
-        int getKartePreis( int id, bool testVersion ) override;
-        // Kauft eine Karte
-        //  id: Die Id der Karte
-        //  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
-        bool karteErwerben( int karteId, bool testVersion ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne( bool abmelden ) override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		ShopClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~ShopClient();
+		// verbindet sich mit dem zugewiesenen Shop Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// 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
+		Framework::Array< int >* suchSpiele(const char* suche) override;
+		// 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
+		bool ladeSpielTitel(int id) override;
+		// 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
+		bool ladeSpielSeite(int id) override;
+		// Gibt den Besitz Status eines Spiels zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
+		//  id: Die Id des Spiels
+		int getSpielBesitzStatus(int id) override;
+		// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
+		//  id: Die Id des Spiels
+		int getSpielTestversion(int id) override;
+		// Gibt den Erwerbbarkeits Status eines Spiels zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+		//  id: Die Id des Spiels
+		int istSpielErwerbbar(int id) override;
+		// 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
+		int getSpielPreis(int id, bool testVersion) override;
+		// Kauft ein Spiel
+		//  id: Die Id des Spiels
+		//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
+		bool spielErwerben(int spielId, bool testVersion) override;
+		// 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
+		Framework::Array< int >* suchKarten(const char* suche, int spielId) override;
+		// 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
+		bool ladeKarteTitel(int id) override;
+		// 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
+		bool ladeKarteSeite(int id) override;
+		// Gibt den Besitz Status einer Karte zurück (0 = nicht im Besitz, 1 = Testversion, 2 = gekauft)
+		//  id: Die Id der Karte
+		int getKarteBesitzStatus(int id) override;
+		// gibt die Anzahl der verbleibenden Spiele der Testversion zurück
+		//  id: Die Id der Karte
+		int getKarteTestversion(int id) override;
+		// Gibt den Erwerbbarkeits Status einer Karte zurück (0 = nichts, 1 = nur Testversion, 2 = nur Vollversion, 3 = beides)
+		//  id: Die Id der Karte
+		int istKarteErwerbbar(int id) override;
+		// 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
+		int getKartePreis(int id, bool testVersion) override;
+		// Kauft eine Karte
+		//  id: Die Id der Karte
+		//  testVersion: 1:=Es wird die Testversion erworben, 0:=Es wird die Vollversion erworben
+		bool karteErwerben(int karteId, bool testVersion) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne(bool abmelden) override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }

KSGNetwork/SpielClient.cpp

@@ -7,531 +7,531 @@ using namespace KSGClient;
 // Inhalt der SpielClient Klasse
 
 // Konstruktor
-SpielClient::SpielClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
-    : ReferenceCounter()
+SpielClient::SpielClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen)
+	: ReferenceCounter()
 {
-    this->ip = ip;
-    this->port = port;
-    cId = klientId;
-    senden = 0;
-    empfangen = 0;
-    this->key = new char[ keyLen ];
-    memcpy( this->key, key, keyLen );
-    this->keyLen = keyLen;
+	this->ip = ip;
+	this->port = port;
+	cId = klientId;
+	senden = 0;
+	empfangen = 0;
+	this->key = new char[keyLen];
+	memcpy(this->key, key, keyLen);
+	this->keyLen = keyLen;
 }
 
 // Destruktor
 SpielClient::~SpielClient()
 {
-    trenne();
-    delete[] key;
+	trenne();
+	delete[] key;
 }
 
 // verbindet sich mit dem zugewiesenen Karten Server
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool SpielClient::verbinde()
 {
-    cs.lock();
-    if( senden )
-    {
-        cs.unlock();
-        return 1;
-    }
-    if( !senden )
-        senden = new Network::Klient();
-    int keyLen = 0;
-    char *key = 0;
-    Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::SENDEN );
-    senden->setSendeKey( key, keyLen );
-    delete[] key;
-    Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::EMPFANGEN );
-    senden->setEmpfangKey( key, keyLen );
-    delete[] key;
-    if( senden->verbinde( port, ip ) )
-    {
-        if( senden->sendeEncrypted( "\1", 1 ) )
-        {
-            char serverReturn = 0;
-            senden->sendeEncrypted( (char *)&cId, 4 );
-            char ret = 0;
-            senden->getNachrichtEncrypted( &ret, 1 );
-            if( ret != 1 )
-            {
-                if( ret == 3 )
-                {
-                    char byte = 0;
-                    senden->getNachrichtEncrypted( &byte, 1 );
-                    char *f = new char[ byte + 1 ];
-                    f[ byte ] = 0;
-                    senden->getNachrichtEncrypted( f, byte );
-                    err = f;
-                    delete[]f;
-                }
-                senden->sendeEncrypted( "\3", 1 );
-                senden->getNachrichtEncrypted( &serverReturn, 1 );
-                senden->trenne();
-                senden = (Network::Klient *)senden->release();
-                err = "Server akzeptiert den Klient nicht.";
-                cs.unlock();
-                return 0;
-            }
-            senden->setSendeKey( this->key, this->keyLen );
-            senden->setEmpfangKey( this->key, this->keyLen );
-            if( !empfangen )
-                empfangen = new Network::Klient();
-            int keyLen = 0;
-            char *key = 0;
-            Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::SENDEN );
-            empfangen->setSendeKey( key, keyLen );
-            delete[] key;
-            Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::EMPFANGEN );
-            empfangen->setEmpfangKey( key, keyLen );
-            delete[] key;
-            if( empfangen->verbinde( senden->getServerPort(), senden->getServerIp() ) )
-            {
-                empfangen->sendeEncrypted( "\1", 1 );
-                empfangen->sendeEncrypted( (char *)&cId, 4 );
-                char res = 0;
-                empfangen->getNachrichtEncrypted( &res, 1 );
-                if( res == 3 )
-                {
-                    char län = 0;
-                    empfangen->getNachrichtEncrypted( &län, 1 );
-                    char *nachricht = new char[ län + 1 ];
-                    nachricht[ län ] = 0;
-                    empfangen->getNachrichtEncrypted( nachricht, län );
-                    err = nachricht;
-                    delete[] nachricht;
-                }
-                if( res == 1 )
-                {
-                    empfangen->setSendeKey( this->key, this->keyLen );
-                    empfangen->setEmpfangKey( this->key, this->keyLen );
-                }
-                else if( res != 0 )
-                {
-                    err = "Fehler beim Verbinden mit dem Spiel Server.";
-                    senden->sendeEncrypted( "\3", 1 );
-                    char serverReturn = 0;
-                    senden->getNachrichtEncrypted( &serverReturn, 1 );
-                    senden->trenne();
-                    senden = (Network::Klient *)senden->release();
-                    empfangen->trenne();
-                    empfangen = (Network::Klient *)empfangen->release();
-                    return 0;
-                }
-                cs.unlock();
-                return 1;
-            }
-            else
-            {
-                empfangen = (Network::Klient *)empfangen->release();
-                senden->sendeEncrypted( "\3", 1 );
-                char serverReturn = 0;
-                senden->getNachrichtEncrypted( &serverReturn, 1 );
-                senden->trenne();
-                senden = (Network::Klient *)senden->release();
-                err = "Der dir zugewiesene Spiel Server kann dir keine Nachrichten senden.";
-                cs.unlock();
-                return 0;
-            }
-        }
-        else
-        {
-            senden->trenne();
-            senden = (Network::Klient *)senden->release();
-            err = "Der dir zugewiesene Spiel Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
-            cs.unlock();
-            return 0;
-        }
-    }
-    else
-    {
-        err = "Der dir zugewiesene Spiel Server antwortet nicht. Bitte versuche es Später erneut.";
-        senden = (Network::Klient *)senden->release();
-        cs.unlock();
-        return 0;
-    }
-    err = "Unbekannter Fehler";
-    cs.unlock();
-    return 0;
+	cs.lock();
+	if (senden)
+	{
+		cs.unlock();
+		return 1;
+	}
+	if (!senden)
+		senden = new Network::Klient();
+	int keyLen = 0;
+	char* key = 0;
+	Keys::getServerKey(&key, keyLen, Keys::SPIEL, Keys::SENDEN);
+	senden->setSendeKey(key, keyLen);
+	delete[] key;
+	Keys::getServerKey(&key, keyLen, Keys::SPIEL, Keys::EMPFANGEN);
+	senden->setEmpfangKey(key, keyLen);
+	delete[] key;
+	if (senden->verbinde(port, ip))
+	{
+		if (senden->sendeEncrypted("\1", 1))
+		{
+			char serverReturn = 0;
+			senden->sendeEncrypted((char*)&cId, 4);
+			char ret = 0;
+			senden->getNachrichtEncrypted(&ret, 1);
+			if (ret != 1)
+			{
+				if (ret == 3)
+				{
+					char byte = 0;
+					senden->getNachrichtEncrypted(&byte, 1);
+					char* f = new char[byte + 1];
+					f[byte] = 0;
+					senden->getNachrichtEncrypted(f, byte);
+					err = f;
+					delete[]f;
+				}
+				senden->sendeEncrypted("\3", 1);
+				senden->getNachrichtEncrypted(&serverReturn, 1);
+				senden->trenne();
+				senden = (Network::Klient*)senden->release();
+				err = "Server akzeptiert den Klient nicht.";
+				cs.unlock();
+				return 0;
+			}
+			senden->setSendeKey(this->key, this->keyLen);
+			senden->setEmpfangKey(this->key, this->keyLen);
+			if (!empfangen)
+				empfangen = new Network::Klient();
+			int keyLen = 0;
+			char* key = 0;
+			Keys::getServerKey(&key, keyLen, Keys::SPIEL, Keys::SENDEN);
+			empfangen->setSendeKey(key, keyLen);
+			delete[] key;
+			Keys::getServerKey(&key, keyLen, Keys::SPIEL, Keys::EMPFANGEN);
+			empfangen->setEmpfangKey(key, keyLen);
+			delete[] key;
+			if (empfangen->verbinde(senden->getServerPort(), senden->getServerIp()))
+			{
+				empfangen->sendeEncrypted("\1", 1);
+				empfangen->sendeEncrypted((char*)&cId, 4);
+				char res = 0;
+				empfangen->getNachrichtEncrypted(&res, 1);
+				if (res == 3)
+				{
+					char län = 0;
+					empfangen->getNachrichtEncrypted(&län, 1);
+					char* nachricht = new char[län + 1];
+					nachricht[län] = 0;
+					empfangen->getNachrichtEncrypted(nachricht, län);
+					err = nachricht;
+					delete[] nachricht;
+				}
+				if (res == 1)
+				{
+					empfangen->setSendeKey(this->key, this->keyLen);
+					empfangen->setEmpfangKey(this->key, this->keyLen);
+				}
+				else if (res != 0)
+				{
+					err = "Fehler beim Verbinden mit dem Spiel Server.";
+					senden->sendeEncrypted("\3", 1);
+					char serverReturn = 0;
+					senden->getNachrichtEncrypted(&serverReturn, 1);
+					senden->trenne();
+					senden = (Network::Klient*)senden->release();
+					empfangen->trenne();
+					empfangen = (Network::Klient*)empfangen->release();
+					return 0;
+				}
+				cs.unlock();
+				return 1;
+			}
+			else
+			{
+				empfangen = (Network::Klient*)empfangen->release();
+				senden->sendeEncrypted("\3", 1);
+				char serverReturn = 0;
+				senden->getNachrichtEncrypted(&serverReturn, 1);
+				senden->trenne();
+				senden = (Network::Klient*)senden->release();
+				err = "Der dir zugewiesene Spiel Server kann dir keine Nachrichten senden.";
+				cs.unlock();
+				return 0;
+			}
+		}
+		else
+		{
+			senden->trenne();
+			senden = (Network::Klient*)senden->release();
+			err = "Der dir zugewiesene Spiel Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
+			cs.unlock();
+			return 0;
+		}
+	}
+	else
+	{
+		err = "Der dir zugewiesene Spiel Server antwortet nicht. Bitte versuche es Später erneut.";
+		senden = (Network::Klient*)senden->release();
+		cs.unlock();
+		return 0;
+	}
+	err = "Unbekannter Fehler";
+	cs.unlock();
+	return 0;
 }
 
 // Betritt das Vorgeschlagene Spiel
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool SpielClient::spielErstelltAnnehmen()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\4", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim annehmen des Spiels.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\4", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim annehmen des Spiels.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Lehnt das Vorgeschlagene Spiel ab
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool SpielClient::spielErstelltAblehnen()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\5", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim ablehnen des Spiels.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\5", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim ablehnen des Spiels.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Wechselt zu einem bestimmten Team
 //  team: Die Id des teams
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool SpielClient::spielErstelltTeamWechseln( int team )
+bool SpielClient::spielErstelltTeamWechseln(int team)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\6", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( !ret )
-    {
-        err = "Fehler beim wechseln des Teams.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( (char *)&team, 4 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim wechseln des Teams.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\6", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (!ret)
+	{
+		err = "Fehler beim wechseln des Teams.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted((char*)&team, 4);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim wechseln des Teams.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool SpielClient::spielErstelltTeamFertig()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\xE", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim setzen der Bereitschaft.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\xE", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim setzen der Bereitschaft.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
 //  nachricht: Die Nachricht
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-bool SpielClient::spielErstelltChatNachricht( char *nachricht )
+bool SpielClient::spielErstelltChatNachricht(const char* nachricht)
 {
-    char län = textLength( nachricht );
-    if( !län )
-        return 1;
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\7", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( !ret )
-    {
-        err = "Fehler beim senden der Chat Nachricht.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( &län, 1 );
-    senden->sendeEncrypted( nachricht, län );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim senden der Chat Nachricht.";
-    cs.unlock();
-    return ret == 1;
+	char län = textLength(nachricht);
+	if (!län)
+		return 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\7", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (!ret)
+	{
+		err = "Fehler beim senden der Chat Nachricht.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted(&län, 1);
+	senden->sendeEncrypted(nachricht, län);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim senden der Chat Nachricht.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Teilt dem Server mit, dass der Client bereit ist das Spiel zu laden
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool SpielClient::bereitZumLaden()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\x9", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim setzen der Bereitschaft.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\x9", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim setzen der Bereitschaft.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool SpielClient::setLadenProzent( int prozent )
+bool SpielClient::setLadenProzent(int prozent)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\xC", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret )
-    {
-        senden->sendeEncrypted( (char *)&prozent, 4 );
-        senden->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret != 1 )
-        err = "Fehler beim setzen des Fortschritts.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\xC", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret)
+	{
+		senden->sendeEncrypted((char*)&prozent, 4);
+		senden->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret != 1)
+		err = "Fehler beim setzen des Fortschritts.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // Teilt dem Server mit, dass das Spiel fertig geladen wurde
 //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
 bool SpielClient::bereitZumSpiel()
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\xA", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret != 1 )
-        err = "Fehler beim setzen der Bereitschaft.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\xA", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret != 1)
+		err = "Fehler beim setzen der Bereitschaft.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool SpielClient::spielNachricht( short län, char *bytes )
+bool SpielClient::spielNachricht(short län, const char* bytes)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    senden->sendeEncrypted( "\xB", 1 );
-    senden->sende( (char *)&län, 2 );
-    senden->sende( bytes, län );
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	senden->sendeEncrypted("\xB", 1);
+	senden->sende((char*)&län, 2);
+	senden->sende(bytes, län);
+	cs.unlock();
+	return 1;
 }
 
 // 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
-bool SpielClient::statistikNachricht( short län, char *bytes )
+bool SpielClient::statistikNachricht(short län, const char* bytes)
 {
-    cs.lock();
-    if( !senden )
-    {
-        err = "Der Client ist nicht verbunden.";
-        cs.unlock();
-        return 0;
-    }
-    char ret = 0;
-    senden->sendeEncrypted( "\xD", 1 );
-    senden->getNachrichtEncrypted( &ret, 1 );
-    if( ret )
-    {
-        senden->sendeEncrypted( (char *)&län, 2 );
-        senden->sendeEncrypted( bytes, län );
-        senden->getNachrichtEncrypted( &ret, 1 );
-    }
-    if( ret != 1 )
-        err = "Fehler beim setzen der Statistik Nachricht.";
-    cs.unlock();
-    return ret == 1;
+	cs.lock();
+	if (!senden)
+	{
+		err = "Der Client ist nicht verbunden.";
+		cs.unlock();
+		return 0;
+	}
+	char ret = 0;
+	senden->sendeEncrypted("\xD", 1);
+	senden->getNachrichtEncrypted(&ret, 1);
+	if (ret)
+	{
+		senden->sendeEncrypted((char*)&län, 2);
+		senden->sendeEncrypted(bytes, län);
+		senden->getNachrichtEncrypted(&ret, 1);
+	}
+	if (ret != 1)
+		err = "Fehler beim setzen der Statistik Nachricht.";
+	cs.unlock();
+	return ret == 1;
 }
 
 // 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
-bool SpielClient::getNextMessage( SpielServerNachricht &nachricht )
+bool SpielClient::getNextMessage(SpielServerNachricht& nachricht)
 {
-    do
-    {
-        if( !empfangen->getNachrichtEncrypted( &nachricht.type, 1 ) )
-        {
-            err = "Es ist ein Fehler beim Empfangen aufgetreten";
-            return 0;
-        }
-        switch( nachricht.type )
-        {
-        case 0: // verbindung getrennt
-            trenne();
-            break;
-        case 1: // verbleibende Zeit
-            empfangen->getNachrichtEncrypted( &nachricht.sekunden, 1 );
-            break;
-        case 2: // SpielErstellt abbruch
-            if( 1 )
-            {
-                char län = 0;
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                char *grund = new char[ län + 1 ];
-                grund[ län ] = 0;
-                empfangen->getNachrichtEncrypted( grund, län );
-                nachricht.message = grund;
-                delete[] grund;
-            }
-            break;
-        case 3: // Fehler
-            if( 1 )
-            {
-                unsigned char länge = 0;
-                empfangen->getNachrichtEncrypted( (char *)&länge, 1 );
-                char *txt = new char[ länge + 1 ];
-                txt[ länge ] = 0;
-                empfangen->getNachrichtEncrypted( txt, länge );
-                nachricht.message = txt;
-                delete[]txt;
-            }
-            break;
-        case 4: // zurück in Warteschlange
-            empfangen->getNachrichtEncrypted( &nachricht.stunden, 1 );
-            empfangen->getNachrichtEncrypted( &nachricht.minuten, 1 );
-            empfangen->getNachrichtEncrypted( &nachricht.sekunden, 1 );
-            break;
-        case 6: // SpielErstellt Initialisierung
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.sts->spielerAnzahl, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.sts->teamAnzahl, 4 );
-            for( int i = 0; i < nachricht.sts->spielerAnzahl; i++ )
-            {
-                int farbe = 0;
-                empfangen->getNachrichtEncrypted( (char *)&farbe, 4 );
-                nachricht.sts->spielerFarbe->set( farbe, i );
-            }
-            for( int i = 0; i < nachricht.sts->teamAnzahl; i++ )
-            {
-                int farbe = 0;
-                empfangen->getNachrichtEncrypted( (char *)&farbe, 4 );
-                nachricht.sts->teamFarbe->set( farbe, i );
-            }
-            for( int i = 0; i < nachricht.sts->teamAnzahl; i++ )
-            {
-                char län = 0;
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                char *name = new char[ län + 1 ];
-                name[ län ] = 0;
-                if( län )
-                    empfangen->getNachrichtEncrypted( name, län );
-                Text *tmp = new Text( name );
-                delete[] name;
-                nachricht.sts->teamName->set( tmp, i );
-            }
-            for( int i = 0; i < nachricht.sts->teamAnzahl; i++ )
-            {
-                int größe = 0;
-                empfangen->getNachrichtEncrypted( (char *)&größe, 4 );
-                nachricht.sts->teamSize->set( größe, i );
-            }
-            break;
-        case 7: // SpielErstellt Spieler hinzugefügt
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.accountId, 4 );
-            break;
-        case 8: // SpielErstellt Spieler entfernt
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.accountId, 4 );
-            break;
-        case 9: // SpielErstellt Spieler wechselt Team
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.accountId, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.spielerNummer, 4 );
-            break;
-        case 0xA: // SpielErstellt Chat Nachricht
-            if( 1 )
-            {
-                char län = 0;
-                empfangen->getNachrichtEncrypted( &län, 1 );
-                char *txt = new char[ län + 1 ];
-                txt[ län ] = 0;
-                if( län )
-                    empfangen->getNachrichtEncrypted( txt, län );
-                nachricht.message = txt;
-                delete[] txt;
-            }
-            break;
-        case 0xB: // Spiel gefunden
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.karteId, 4 );
-            break;
-        case 0xD: // Spiel Laden Spieler hinzufügen
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.accountId, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.spielerNummer, 4 );
-            break;
-        case 0xE: // Spiel Laden Spieler Prozent
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.accountId, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.prozent, 4 );
-            break;
-        case 0xF: // Spiel Laden Spieler Ping
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.accountId, 4 );
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.ping, 4 );
-            break;
-        case 0x10: // ping
-            empfangen->sendeEncrypted( "\1", 1 );
-            break;
-        case 0x12: // Spiel Nachricht
-            empfangen->getNachricht( (char *)&nachricht.län, 2 );
-            nachricht.data = new char[ nachricht.län ];
-            empfangen->getNachricht( nachricht.data, nachricht.län );
-            break;
-        case 0x13: // Statistik Nachricht
-            empfangen->getNachrichtEncrypted( (char *)&nachricht.län, 2 );
-            nachricht.data = new char[ nachricht.län ];
-            empfangen->getNachrichtEncrypted( nachricht.data, nachricht.län );
-            break;
-        case 0x14: // ping
-            empfangen->sendeEncrypted( "\1", 1 );
-            break;
-        }
-    } while( nachricht.type == 0x10 || nachricht.type == 0x14 );
-    return 1;
+	do
+	{
+		if (!empfangen->getNachrichtEncrypted(&nachricht.type, 1))
+		{
+			err = "Es ist ein Fehler beim Empfangen aufgetreten";
+			return 0;
+		}
+		switch (nachricht.type)
+		{
+		case 0: // verbindung getrennt
+			trenne();
+			break;
+		case 1: // verbleibende Zeit
+			empfangen->getNachrichtEncrypted(&nachricht.sekunden, 1);
+			break;
+		case 2: // SpielErstellt abbruch
+			if (1)
+			{
+				char län = 0;
+				empfangen->getNachrichtEncrypted(&län, 1);
+				char* grund = new char[län + 1];
+				grund[län] = 0;
+				empfangen->getNachrichtEncrypted(grund, län);
+				nachricht.message = grund;
+				delete[] grund;
+			}
+			break;
+		case 3: // Fehler
+			if (1)
+			{
+				unsigned char länge = 0;
+				empfangen->getNachrichtEncrypted((char*)&länge, 1);
+				char* txt = new char[länge + 1];
+				txt[länge] = 0;
+				empfangen->getNachrichtEncrypted(txt, länge);
+				nachricht.message = txt;
+				delete[]txt;
+			}
+			break;
+		case 4: // zurück in Warteschlange
+			empfangen->getNachrichtEncrypted(&nachricht.stunden, 1);
+			empfangen->getNachrichtEncrypted(&nachricht.minuten, 1);
+			empfangen->getNachrichtEncrypted(&nachricht.sekunden, 1);
+			break;
+		case 6: // SpielErstellt Initialisierung
+			empfangen->getNachrichtEncrypted((char*)&nachricht.sts->spielerAnzahl, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.sts->teamAnzahl, 4);
+			for (int i = 0; i < nachricht.sts->spielerAnzahl; i++)
+			{
+				int farbe = 0;
+				empfangen->getNachrichtEncrypted((char*)&farbe, 4);
+				nachricht.sts->spielerFarbe->set(farbe, i);
+			}
+			for (int i = 0; i < nachricht.sts->teamAnzahl; i++)
+			{
+				int farbe = 0;
+				empfangen->getNachrichtEncrypted((char*)&farbe, 4);
+				nachricht.sts->teamFarbe->set(farbe, i);
+			}
+			for (int i = 0; i < nachricht.sts->teamAnzahl; i++)
+			{
+				char län = 0;
+				empfangen->getNachrichtEncrypted(&län, 1);
+				char* name = new char[län + 1];
+				name[län] = 0;
+				if (län)
+					empfangen->getNachrichtEncrypted(name, län);
+				Text* tmp = new Text(name);
+				delete[] name;
+				nachricht.sts->teamName->set(tmp, i);
+			}
+			for (int i = 0; i < nachricht.sts->teamAnzahl; i++)
+			{
+				int größe = 0;
+				empfangen->getNachrichtEncrypted((char*)&größe, 4);
+				nachricht.sts->teamSize->set(größe, i);
+			}
+			break;
+		case 7: // SpielErstellt Spieler hinzugefügt
+			empfangen->getNachrichtEncrypted((char*)&nachricht.accountId, 4);
+			break;
+		case 8: // SpielErstellt Spieler entfernt
+			empfangen->getNachrichtEncrypted((char*)&nachricht.accountId, 4);
+			break;
+		case 9: // SpielErstellt Spieler wechselt Team
+			empfangen->getNachrichtEncrypted((char*)&nachricht.accountId, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.spielerNummer, 4);
+			break;
+		case 0xA: // SpielErstellt Chat Nachricht
+			if (1)
+			{
+				char län = 0;
+				empfangen->getNachrichtEncrypted(&län, 1);
+				char* txt = new char[län + 1];
+				txt[län] = 0;
+				if (län)
+					empfangen->getNachrichtEncrypted(txt, län);
+				nachricht.message = txt;
+				delete[] txt;
+			}
+			break;
+		case 0xB: // Spiel gefunden
+			empfangen->getNachrichtEncrypted((char*)&nachricht.karteId, 4);
+			break;
+		case 0xD: // Spiel Laden Spieler hinzufügen
+			empfangen->getNachrichtEncrypted((char*)&nachricht.accountId, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.spielerNummer, 4);
+			break;
+		case 0xE: // Spiel Laden Spieler Prozent
+			empfangen->getNachrichtEncrypted((char*)&nachricht.accountId, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.prozent, 4);
+			break;
+		case 0xF: // Spiel Laden Spieler Ping
+			empfangen->getNachrichtEncrypted((char*)&nachricht.accountId, 4);
+			empfangen->getNachrichtEncrypted((char*)&nachricht.ping, 4);
+			break;
+		case 0x10: // ping
+			empfangen->sendeEncrypted("\1", 1);
+			break;
+		case 0x12: // Spiel Nachricht
+			empfangen->getNachricht((char*)&nachricht.län, 2);
+			nachricht.data = new char[nachricht.län];
+			empfangen->getNachricht(nachricht.data, nachricht.län);
+			break;
+		case 0x13: // Statistik Nachricht
+			empfangen->getNachrichtEncrypted((char*)&nachricht.län, 2);
+			nachricht.data = new char[nachricht.län];
+			empfangen->getNachrichtEncrypted(nachricht.data, nachricht.län);
+			break;
+		case 0x14: // ping
+			empfangen->sendeEncrypted("\1", 1);
+			break;
+		}
+	} while (nachricht.type == 0x10 || nachricht.type == 0x14);
+	return 1;
 }
 
 // Erhält die Verbindung aufrecht
@@ -539,21 +539,21 @@ bool SpielClient::getNextMessage( SpielServerNachricht &nachricht )
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool SpielClient::keepAlive()
 {
-    if( !senden )
-        return 0;
-    char res = 0;
-    if( !cs.tryLock() )
-        return 1;
-    bool ok = senden->sendeEncrypted( "\xF", 1 );
-    ok &= senden->getNachrichtEncrypted( &res, 1 );
-    cs.unlock();
-    if( res != 1 || !ok )
-    {
-        err = "Die Verbindung zum Spiel Server ist abgebrochen.";
-        trenne();
-        return 0;
-    }
-    return res == 1;
+	if (!senden)
+		return 0;
+	char res = 0;
+	if (!cs.tryLock())
+		return 1;
+	bool ok = senden->sendeEncrypted("\xF", 1);
+	ok &= senden->getNachrichtEncrypted(&res, 1);
+	cs.unlock();
+	if (res != 1 || !ok)
+	{
+		err = "Die Verbindung zum Spiel Server ist abgebrochen.";
+		trenne();
+		return 0;
+	}
+	return res == 1;
 }
 
 // Trennt die Verbindung zum Server
@@ -561,32 +561,32 @@ bool SpielClient::keepAlive()
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
 bool SpielClient::trenne()
 {
-    cs.lock();
-    if( !senden )
-    {
-        cs.unlock();
-        return 1;
-    }
-    senden->sendeEncrypted( "\3", 1 );
-    char serverReturn = 0;
-    senden->getNachrichtEncrypted( &serverReturn, 1 );
-    senden->trenne();
-    senden = (Network::Klient *)senden->release();
-    empfangen->trenne();
-    empfangen = (Network::Klient *)empfangen->release();
-    cs.unlock();
-    return 1;
+	cs.lock();
+	if (!senden)
+	{
+		cs.unlock();
+		return 1;
+	}
+	senden->sendeEncrypted("\3", 1);
+	char serverReturn = 0;
+	senden->getNachrichtEncrypted(&serverReturn, 1);
+	senden->trenne();
+	senden = (Network::Klient*)senden->release();
+	empfangen->trenne();
+	empfangen = (Network::Klient*)empfangen->release();
+	cs.unlock();
+	return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool SpielClient::istVerbunden() const
 {
-    return senden != 0;
+	return senden != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-char *SpielClient::getLetzterFehler() const
+const char* SpielClient::getLetzterFehler() const
 {
-    return err;
+	return err;
 }

KSGNetwork/SpielClient.h

@@ -5,81 +5,81 @@
 
 namespace KSGClient
 {
-    // Wird zum Online Spielen verwendet
-    //  Kann nur von eingeloggten Clients verwendet werden
-    class SpielClient : public SpielServerClient
-    {
-    private:
-        Framework::Text ip;
-        unsigned short port;
-        int cId;
-        Network::Klient *senden;
-        Network::Klient *empfangen;
-        char *key;
-        unsigned char keyLen;
-        Framework::Critical cs;
-        Framework::Text err;
+	// Wird zum Online Spielen verwendet
+	//  Kann nur von eingeloggten Clients verwendet werden
+	class SpielClient : public SpielServerClient
+	{
+	private:
+		Framework::Text ip;
+		unsigned short port;
+		int cId;
+		Network::Klient* senden;
+		Network::Klient* empfangen;
+		char* key;
+		unsigned char keyLen;
+		Framework::Critical cs;
+		Framework::Text err;
 
-    public:
-        // Konstruktor
-        SpielClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
-        // Destruktor
-        ~SpielClient();
-        // verbindet sich mit dem zugewiesenen Karten Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool verbinde() override;
-        // Betritt das Vorgeschlagene Spiel
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool spielErstelltAnnehmen() override;
-        // Lehnt das Vorgeschlagene Spiel ab
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool spielErstelltAblehnen() override;
-        // Wechselt zu einem bestimmten Team
-        //  team: Die Id des teams
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool spielErstelltTeamWechseln( int team ) override;
-        // Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool spielErstelltTeamFertig() override;
-        // sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
-        //  nachricht: Die Nachricht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool spielErstelltChatNachricht( char *nachricht ) override;
-        // Teilt dem Server mit, dass der Client bereit ist das Spiel zu laden
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool bereitZumLaden() override;
-        // 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
-        bool setLadenProzent( int prozent ) override;
-        // Teilt dem Server mit, dass das Spiel fertig geladen wurde
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        bool bereitZumSpiel() override;
-        // 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
-        bool spielNachricht( short län, char *bytes ) override;
-        // 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
-        bool statistikNachricht( short län, char *bytes ) override;
-        // 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
-        bool getNextMessage( SpielServerNachricht &nachricht ) override;
-        // Erhält die Verbindung aufrecht
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
-        bool keepAlive() override;
-        // Trennt die Verbindung zum Server
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
-        bool trenne() override;
-        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
-        bool istVerbunden() const override;
-        // gibt den Letzten Fehlertext zuück
-        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
-        char *getLetzterFehler() const override;
-    };
+	public:
+		// Konstruktor
+		SpielClient(int klientId, unsigned short port, const char* ip, const char* key, unsigned char keyLen);
+		// Destruktor
+		~SpielClient();
+		// verbindet sich mit dem zugewiesenen Karten Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool verbinde() override;
+		// Betritt das Vorgeschlagene Spiel
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool spielErstelltAnnehmen() override;
+		// Lehnt das Vorgeschlagene Spiel ab
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool spielErstelltAblehnen() override;
+		// Wechselt zu einem bestimmten Team
+		//  team: Die Id des teams
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool spielErstelltTeamWechseln(int team) override;
+		// Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool spielErstelltTeamFertig() override;
+		// sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
+		//  nachricht: Die Nachricht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool spielErstelltChatNachricht(const char* nachricht) override;
+		// Teilt dem Server mit, dass der Client bereit ist das Spiel zu laden
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool bereitZumLaden() override;
+		// 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
+		bool setLadenProzent(int prozent) override;
+		// Teilt dem Server mit, dass das Spiel fertig geladen wurde
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		bool bereitZumSpiel() override;
+		// 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
+		bool spielNachricht(short län, const char* bytes) override;
+		// 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
+		bool statistikNachricht(short län, const char* bytes) override;
+		// 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
+		bool getNextMessage(SpielServerNachricht& nachricht) override;
+		// Erhält die Verbindung aufrecht
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+		bool keepAlive() override;
+		// Trennt die Verbindung zum Server
+		//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+		//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+		bool trenne() override;
+		// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+		bool istVerbunden() const override;
+		// gibt den Letzten Fehlertext zuück
+		//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+		const char* getLetzterFehler() const override;
+	};
 }