KSGNetwork/KSGNetwork/InformationClient.cpp

#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 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 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 = k->release();
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "network error while connecting to Information Server";
        k = 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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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 )
{
    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
//  gruppeId: Die Id der Gruppe
//  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
//  accountId: Die Accont Id des Spielers
//  spielId: Die Id des Spiels
//  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
//  spielId: Die Id des Spiels
//  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
//  spielId: Die Id des Spiels
//  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
//  dgId: Die Id der Dateigruppe
//  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
//  spielId: Die Spiel Id zu der die Karten gehören sollen
//  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
//  pfad: Der Pfad der Dateigruppe
//  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
//  dg: Die Dateigruppen Id
//  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
//  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 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::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
//  account: Die Id des Accounts
//  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
//  account: Die Id des Accounts
//  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
//  account: Die Id des Accounts
//  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
//  account: Die Id des Accounts
//  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
//  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 )
{
    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 )
{
    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
//  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 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
//  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 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;
}

// 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 )
{
    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 )
{
    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 )
{
    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
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 )
{
    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 )
{
    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 )
{
    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
//  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 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
//  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 )
{
    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;
}