Alle Clients fertig

Include/KSGNetwork.h

@@ -29,119 +29,59 @@ namespace Network
 namespace KSGClient
 {
     // Enthält die Daten eines Spielers zu einem vergangenen Spiel
-    class SpielHistorieSpielerDaten
+    struct SpielHistorieSpielerDaten
     {
-    protected:
-        int ref; // Reference Counter
-
-    public:
-        Framework::Text *name; // Der Sichtabe Name des Spielers
+        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)
+        Framework::Text status; // Der Status des Spielers in dem Spiel (verloren, gewonnen, nicht anwesend, beobachter, unentschieden)
         int farbe; // Die Farbe des Spielers
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual SpielHistorieSpielerDaten *getThis() = 0;
-        // Verringert den Reference Counter um 1 und gibt 0 zurück.
-        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
-        virtual SpielHistorieSpielerDaten *release() = 0;
     };
 
     // Enthält die Datein eines Teams zu einem vergangenen Spiel
-    class SpielHistorieTeamDaten
+    struct SpielHistorieTeamDaten
     {
-    protected:
-        int ref; // Reference Counter
-
-    public:
-        Framework::Text *name; // Der Sichtabe Name des Teams
+        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)
+        Framework::Text status; // Der Status des Teams (verloren, gewonnen, beobachter, unentschieden)
         int farbe; // Die Farbe des Teams
-        Framework::RCArray< SpielHistorieSpielerDaten > *spieler; // Eine Liste mit den Spielerdaten zu den Spielern aus dem Team
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual SpielHistorieTeamDaten *getThis() = 0;
-        // Verringert den Reference Counter um 1 und gibt 0 zurück.
-        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
-        virtual SpielHistorieTeamDaten *release() = 0;
+        Framework::Array< SpielHistorieSpielerDaten > spieler; // Eine Liste mit den Spielerdaten zu den Spielern aus dem Team
     };
 
     // Enthält Daten zu einem vergangenen Spiel
-    class SpielHistorieDaten
+    struct SpielHistorieDaten
     {
-    protected:
-        int ref; // Reference Counter
-
-    public:
         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
+        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::RCArray< SpielHistorieTeamDaten > *teams; // Die Daten der Teams des Spiels
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual SpielHistorieDaten *getThis() = 0;
-        // Verringert den Reference Counter um 1 und gibt 0 zurück.
-        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
-        virtual SpielHistorieDaten *release() = 0;
-    };
-
-    // Enthält eine Liste von Spiel Daten aus vergangenen Spielen
-    class SpielHistorieListe
-    {
-    protected:
-        int ref; // Reference Counter
-
-    public:
-        Framework::RCArray< SpielHistorieDaten > *spiele; // Eine Liste mit den Daten zu vergangenen Spielen
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual SpielHistorieListe *getThis() = 0;
-        // Verringert den Reference Counter um 1 und gibt 0 zurück.
-        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
-        virtual SpielHistorieListe *release() = 0;
+        Framework::Array< SpielHistorieTeamDaten > teams; // Die Daten der Teams des Spiels
     };
 
     // Enthält Informationen zu einem Account
-    class AccountInfo
+    struct AccountInfo
     {
-    protected:
-        int ref; // Reference Counter
-
-    public:
         int id; // Die Id des Accounts
-        Framework::Text *name; // Der angezeigte Name 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
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual AccountInfo *getThis() = 0;
-        // Verringert den Reference Counter um 1 und gibt 0 zurück.
-        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
-        virtual AccountInfo *release() = 0;
     };
 
     // Enthält Informationen zur Aktivität eines Accounts an einem bestimmten Tag
-    class AccountActivityInfo
+    struct AccountActivityInfo
     {
-    protected:
-        int ref; // Reference Counter
-
-    public:
         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
-        // Erhöht den Reference Counter um 1 un gibt this zurück
-        virtual AccountActivityInfo *getThis() = 0;
-        // Verringert den Reference Counter um 1 und gibt 0 zurück.
-        //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
-        virtual AccountActivityInfo *release() = 0;
     };
 
     class SpielServerClient;
@@ -524,12 +464,12 @@ namespace KSGClient
         //  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 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual int getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::RCArray< AccountInfo > *accounts ) = 0;
+        //  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::RCArray< AccountActivityInfo > *info ) = 0;
+        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
@@ -576,7 +516,7 @@ namespace KSGClient
         // 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 SpielHistorieListe *getSpielHistorieDaten( int account ) = 0;
+        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

KSGNetwork/ChatClient.cpp

@@ -880,6 +880,7 @@ bool ChatClient::getNextMessage( ChatServerNachricht &nachricht )
             break;
         }
     } while( nachricht.type == 0x23 );
+    return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst

KSGNetwork/EditorClient.cpp

@@ -1821,7 +1821,7 @@ bool EditorClient::ladeTeamDaten( SpielerTeamStrukturV *sts )
                 {
                     int g = 0;
                     k->getNachrichtEncrypted( (char*)&g, 4 );
-                    sts->teamGröße->set( g, i );
+                    sts->teamSize->set( g, i );
                 }
                 cs.unlock();
                 return 1;
@@ -1890,7 +1890,7 @@ bool EditorClient::speicherTeamDaten( SpielerTeamStrukturV *sts )
                 }
                 for( int i = 0; i < sts->teamAnzahl; i++ )
                 {
-                    int g = sts->teamGröße->get( i );
+                    int g = sts->teamSize->get( i );
                     k->sendeEncrypted( (char*)&g, 4 );
                 }
                 cs.unlock();

KSGNetwork/InformationClient.cpp

@@ -1,26 +1,94 @@
 #include "InformationClient.h"
+#include "Keys.h"
+#include <Klient.h>
+#include "EditorClient.h"
+#include "KartenClient.h"
+#include "HistorieClient.h"
 
 using namespace KSGClient;
 
 // Inhalt der InformationClient Klasse
 
 // Konstruktor
-InformationClient::InformationClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
+InformationClient::InformationClient( int kId, unsigned short port, char *ip, char *key, unsigned char keyLen )
 {
-
+    ref = 1;
+    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;
 }
 
 // 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 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 = k->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "network error while connecting to Patch Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
 }
 
 // fragt nach dem Informationstext
@@ -29,7 +97,44 @@ bool InformationClient::verbinde()
 //  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 )
 {
-
+    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
@@ -37,7 +142,35 @@ bool InformationClient::getInformationText( Framework::Text *txt, int *typ )
 //  Gibt 1 zurück, falls das Spiel gespielt werden darf, 0 sonnst
 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;
 }
 
 // fragt, ob die entsprechende Karte vom Server gesperrt wurde
@@ -45,7 +178,35 @@ bool InformationClient::istSpielErlaubt( int spielId )
 //  Gibt 1 zurück, falls die Karte gespielt werden darf, 0 sonnst
 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;
 }
 
 // Ermittelt die Id einer Karte
@@ -53,7 +214,35 @@ bool InformationClient::istKarteErlaubt( int karteId )
 //  Gibt bei misserfolg 0 zurück
 int InformationClient::getKarteId( 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;
 }
 
 // Fragt nach der Id eines Spiels
@@ -61,7 +250,35 @@ int InformationClient::getKarteId( char *name )
 //  Gibt bei misserfolg 0 zurück
 int InformationClient::getSpielId( 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;
 }
 
 // fragt nach dem Namen eines Accounts
@@ -69,7 +286,39 @@ int InformationClient::getSpielId( char *name )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // fragt nach der Spiel Statistik eines Accounts
@@ -78,7 +327,41 @@ Framework::Text *InformationClient::getSpielerName( int accountId )
 //  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 )
 {
-
+    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
@@ -86,7 +369,39 @@ bool InformationClient::getSpielStatistik( int accountId, int spielId, Framework
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // fragt nach dem Namen eines Spiels
@@ -94,7 +409,39 @@ Framework::Text *InformationClient::getKarteName( int karteId )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // fragt nach dem Namen eines Chatrooms
@@ -102,7 +449,39 @@ Framework::Text *InformationClient::getSpielName( int spielId )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // fragt zu welcher Spielart die Karte gehört
@@ -110,7 +489,35 @@ Framework::Text *InformationClient::getChatroomName( int chatroomId )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // gibt die Id eines Accounts zurück
@@ -118,7 +525,42 @@ int InformationClient::getSpielId( int karteId )
 //  Gibt bei misserfolg 0 zurück
 int InformationClient::getAccountId( 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;
 }
 
 // gibt die Id des Chatrooms zurück
@@ -126,7 +568,42 @@ int InformationClient::getAccountId( char *name )
 //  Gibt bei misserfolg 0 zurück
 int InformationClient::getChatroomId( 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;
 }
 
 // gibt die karten Id zurück, zu dem eine Gruppe erstellt wurde
@@ -134,14 +611,68 @@ int InformationClient::getChatroomId( char *name )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // 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 )
 {
-
+    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
@@ -149,7 +680,35 @@ bool InformationClient::getGruppeSpielerHinzuf
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // gibt die Punkte eines Spielers zurück
@@ -158,14 +717,79 @@ int InformationClient::getGruppeAdminId( int gruppeId )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // gibt eine Liste mit Ids von gekauften Spielen zurück
 //  Gibt bei misserfolg 0 zurück
 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( ref == 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
@@ -173,14 +797,65 @@ Framework::Array< int > *InformationClient::getAccountSpielArtListe()
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // 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;
 }
 
 // Gibt die Dateigruppem Id eines Spieles zurück
@@ -188,7 +863,33 @@ int InformationClient::getKupfer()
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // Gibt den Dateigruppen Pfad zurück
@@ -196,7 +897,49 @@ int InformationClient::getDateiGruppeIdVonSpiel( int spielId )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // gibt eine Liste mit gekauften Karten zurück
@@ -204,7 +947,46 @@ Framework::Text *InformationClient::getDateiGruppePfad( int dgId )
 //  Gibt bei misserfolg 0 zurück
 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( ref == 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
@@ -212,7 +994,37 @@ Framework::Array< int > *InformationClient::getAccountKarteListe( int spielId )
 //  Gibt bei misserfolg 0 zurück
 int InformationClient::getDateiGruppeIdVonPfad( 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;
 }
 
 // gibt die neuste Version einer Dateigruppe zurück
@@ -220,7 +1032,33 @@ int InformationClient::getDateiGruppeIdVonPfad( char *pfad )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // Gibt eine Liste Mit Accounts zurück, die einen bestimmten Text im Namen haben und bestimmt Sortiert ist
@@ -231,18 +1069,142 @@ int InformationClient::getDateiGruppeVersion( int dg )
 //  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 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-int InformationClient::getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::RCArray< AccountInfo > *accounts )
+//  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 )
 {
-
+    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::RCArray< 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;
 }
 
 // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
@@ -250,7 +1212,40 @@ bool InformationClient::getSpielerAktivit
 //  karte: Die Id der 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;
 }
 
 // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
@@ -258,7 +1253,40 @@ int InformationClient::getAccountKarteSpiele( int account, int karte )
 //  karte: Die Id der 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;
 }
 
 // Gibt zurück, ob ein Spieler die Karte im Besitz hat
@@ -266,7 +1294,40 @@ int InformationClient::getAccountKarteSpieleGewonnen( int account, int karte )
 //  karte: Die Id der 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;
 }
 
 // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
@@ -274,7 +1335,40 @@ bool InformationClient::hatAccountKarte( int account, int karte )
 //  spiel: Die Id des Spiels
 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;
 }
 
 // gibt eine Liste mit Ids von Karten zurück, die von einem Spieler bereits gespielt wurden
@@ -283,7 +1377,47 @@ bool InformationClient::hatAccountSpiel( int account, int spiel )
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // gibt eine Liste mit Ids von Spielen zurück, die von einem Spieler bereits gespielt wurden
@@ -291,7 +1425,46 @@ Framework::Array< int > *InformationClient::getAccountKarteGespieltListe( int ac
 //  Gibt bei misserfolg 0 zurück
 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;
 }
 
 // Gibt eine Liste von Spiel Partnern eines Spielers zurück
@@ -302,7 +1475,49 @@ Framework::Array< int > *InformationClient::getAccountSpielGespieltListe( int ac
 //  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 )
 {
-
+    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
@@ -315,17 +1530,219 @@ bool InformationClient::getSpielPartnerListe( int account, Framework::Array< int
 //  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 )
+                                           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;
 }
 
 // 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
-SpielHistorieListe *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;
 }
 
 // Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet
@@ -333,30 +1750,155 @@ SpielHistorieListe *InformationClient::getSpielHistorieDaten( int account )
 //  Gibt bei misserfolg 0 zurück
 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;
+    }
+    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
+
+// 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 )
 {
-
+    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
-                                     // 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
+
+// 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 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 )
+                                       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;
 }
 
 // Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id
@@ -364,7 +1906,50 @@ int InformationClient::getKartenListe( char *filter, char sortSpalte, char abste
 //  Gibt bei misserfolg 0 zurück
 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 - 1 ] = 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
@@ -372,7 +1957,50 @@ EditorServerClient *InformationClient::createEditorServerClient( int karteId )
 //  Gibt bei misserfolg 0 zurück
 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 - 1 ] = 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
@@ -380,7 +2008,21 @@ 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;
 }
 
 // Trennt die Verbindung zum Server
@@ -388,31 +2030,75 @@ bool InformationClient::keepAlive()
 //  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
 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 = k->release();
+    cs.unlock();
+    return 1;
 }
 
 // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
 bool InformationClient::istVerbunden() const
 {
-
+    return k != 0;
 }
 
 // gibt den Letzten Fehlertext zuück
 //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
 char *InformationClient::getLetzterFehler() const
 {
-
+    return err;
 }
 
 // Erhöht den Reference Counter um 1 un gibt this zurück
 InformationServerClient *InformationClient::getThis()
 {
-
+    ref++;
+    return this;
 }
 
 // Verringert den Reference Counter um 1 und gibt 0 zurück.
 //  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
 InformationServerClient *InformationClient::release()
 {
-
+    if( !--ref )
+        delete this;
+    return 0;
 }

KSGNetwork/InformationClient.h

@@ -136,12 +136,12 @@ namespace KSGClient
         //  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 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        int getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts, Framework::RCArray< AccountInfo > *accounts ) override;
+        //  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::RCArray< AccountActivityInfo > *info ) override;
+        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
@@ -188,7 +188,7 @@ namespace KSGClient
         // 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
-        SpielHistorieListe *getSpielHistorieDaten( int account ) override;
+        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

KSGNetwork/KSGNetwork.vcxproj

@@ -32,20 +32,20 @@
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
     <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
     <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
@@ -71,15 +71,15 @@
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <IncludePath>..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;..\..\..\..\Allgemein\GSL\GSL\Include;$(IncludePath)</IncludePath>
-    <LibraryPath>..\..\..\..\Allgemein\Framework\x64\Debug;..\..\..\..\Allgemein\Network\x64\Debug;$(LibraryPath)</LibraryPath>
+    <LibraryPath>..\..\..\..\Allgemein\Framework\x64\Debug;..\..\..\..\Allgemein\Network\x64\Debug;..\..\..\..\Allgemein\GSL\x64\Debug;$(LibraryPath)</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <IncludePath>..\..\..\..\Allgemein\GSL\GSL\Include;..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
-    <LibraryPath>..\..\..\..\Allgemein\Framework\x64\Release;..\..\..\..\Allgemein\Network\x64\Release;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64</LibraryPath>
+    <LibraryPath>..\..\..\..\Allgemein\Framework\x64\Release;..\..\..\..\Allgemein\Network\x64\Release;$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(NETFXKitsDir)Lib\um\x64;..\..\..\..\Allgemein\GSL\x64\Release</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <IncludePath>..\..\..\..\Allgemein\GSL\GSL\Include;..\..\..\..\Allgemein\Framework;..\..\..\..\Allgemein\Network\Network;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
-    <LibraryPath>..\..\..\..\Allgemein\Framework\x32\Release;..\..\..\..\Allgemein\Network\x32\Release;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86</LibraryPath>
+    <LibraryPath>..\..\..\..\Allgemein\Framework\x32\Release;..\..\..\..\Allgemein\Network\x32\Release;$(VC_LibraryPath_x86);$(WindowsSDK_LibraryPath_x86);$(NETFXKitsDir)Lib\um\x86;..\..\..\..\Allgemein\GSL\x32\Release</LibraryPath>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -105,6 +105,9 @@
       <Outputs>
       </Outputs>
     </CustomBuildStep>
+    <Link>
+      <AdditionalDependencies>Framework.lib;Network.lib;GSL.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
@@ -118,7 +121,7 @@
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
-      <AdditionalDependencies>Framework.lib;Network.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>Framework.lib;Network.lib;GSL.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <CustomBuildStep>
       <Command>copy "..\x32\Release\KSGNetwork.dll" "..\..\Fertig\x32\data\bin\KSGNetwork.dll"</Command>
@@ -138,6 +141,7 @@
     <Link>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>Framework.lib;Network.lib;GSL.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
     <CustomBuildStep>
       <Command>copy "..\x64\Release\KSGNetwork.dll" "..\..\Fertig\x64\data\bin\KSGNetwork.dll"</Command>

KSGNetwork/LoginClient.cpp

@@ -280,7 +280,6 @@ bool LoginClient::keepAlive()
     }
     Framework::logLine( (char*)"Verbindungstest zum Login Server..." );
     bool ok = k->sendeEncrypted( "\x7", 1 );
-    char res = 0;
     ok &= k->getNachrichtEncrypted( &res, 1 );
     cs.unlock();
     if( res != 1 || !ok )

KSGNetwork/MainClient.cpp

@@ -10,6 +10,7 @@
 #include "ChatClient.h"
 #include "AnmeldungClient.h"
 #include "MinigameClient.h"
+#include "InformationClient.h"
 
 using namespace KSGClient;
 
@@ -423,7 +424,52 @@ LoginServerClient *MainClient::createLoginServerClient()
 //  Gibt bei misserfolg 0 zurück
 InformationServerClient *MainClient::createInformationServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to Main Server";
+        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
@@ -572,7 +618,7 @@ AnmeldungServerClient *MainClient::createAnmeldungServerClient()
         char *f = new char[ byte + 1 ];
         f[ byte ] = 0;
         k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting ShopServer server returned: ";
+        err = "error while requesting AnmeldungServer server returned: ";
         err += f;
         delete[]f;
     }
@@ -624,7 +670,7 @@ MinigameServerClient *MainClient::createMinigameServerClient()
         char *f = new char[ byte + 1 ];
         f[ byte ] = 0;
         k->getNachrichtEncrypted( f, byte );
-        err = "error while requesting ShopServer server returned: ";
+        err = "error while requesting MinigameServer server returned: ";
         err += f;
         delete[]f;
     }

KSGNetwork/SpielClient.cpp

@@ -401,6 +401,7 @@ bool SpielClient::getNextMessage( SpielServerNachricht &nachricht )
     {
         if( !empfangen->getNachrichtEncrypted( &nachricht.type, 1 ) )
         {
+            err = "Es ist ein Fehler beim Empfangen aufgetreten";
             return 0;
         }
         switch( nachricht.type )
@@ -471,7 +472,7 @@ bool SpielClient::getNextMessage( SpielServerNachricht &nachricht )
             {
                 int größe = 0;
                 empfangen->getNachrichtEncrypted( (char*)&größe, 4 );
-                nachricht.sts->teamGröße->set( größe, i );
+                nachricht.sts->teamSize->set( größe, i );
             }
             break;
         case 7: // SpielErstellt Spieler hinzugefügt
@@ -530,6 +531,7 @@ bool SpielClient::getNextMessage( SpielServerNachricht &nachricht )
             break;
         }
     } while( nachricht.type == 0x10 || nachricht.type == 0x14 );
+    return 1;
 }
 
 // Erhält die Verbindung aufrecht