3DTest/3DTest/Netzwerk/Klients/InformationK.cpp

#include "../KSGKlient.h"
#include "../KSGServer.h"
#include "../../NachLogin/Account/Historie/AccountHistorieDaten.h"

// Inhalt der InformationKlient Klasse aus KSGKlient.h
// Konstruktor
InformationKlient::InformationKlient()
{
    verbunden = 0;
    klient = 0;
    fehler = new Text( "" );
    klientId = getKlientId();
    ref = 1;
    InitializeCriticalSection( &cs );
}

// Destruktor
InformationKlient::~InformationKlient() // wenn verbunden, dann trennen
{
    LOCK( &cs );
    if( klient )
    {
        char serverReturn = 0;
        if( verbunden )
        {
            klient->sendeVerschlüsselt( "\4", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char län = 0;
                klient->getNachrichtVerschlüsselt( &län, 1 );
                char *nachricht = new char[ län + 1 ];
                nachricht[ län ] = 0;
                klient->getNachrichtVerschlüsselt( nachricht, län );
                delete[]nachricht;
            }
            klient->sendeVerschlüsselt( "\3", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            klient->trenne();
        }
        else
        {
            unsigned char schlüssel[ 20 ] = { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 };
            klient->setSendeSchlüssel( (char*)schlüssel, 20 );
            klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
            klient->verbinde( klient->getServerPort(), klient->getServerIp() );
            klient->sendeVerschlüsselt( "\1", 1 );
            klient->sendeVerschlüsselt( (char*)&klientId, 4 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char län = 0;
                klient->getNachrichtVerschlüsselt( &län, 1 );
                char *nachricht = new char[ län + 1 ];
                nachricht[ län ] = 0;
                klient->getNachrichtVerschlüsselt( nachricht, län );
                delete[]nachricht;
            }
            else
            {
                char *sl = 0;
                char slLän = getSchlüssel( &sl );
                klient->setSendeSchlüssel( sl, slLän );
                klient->setEmpfangSchlüssel( sl, slLän );
                delete[] sl;
                klient->sendeVerschlüsselt( "\4", 1 );
                klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
                if( serverReturn == 3 )
                {
                    char län = 0;
                    klient->getNachrichtVerschlüsselt( &län, 1 );
                    char *nachricht = new char[ län + 1 ];
                    nachricht[ län ] = 0;
                    klient->getNachrichtVerschlüsselt( nachricht, län );
                    delete[]nachricht;
                }
            }
            klient->sendeVerschlüsselt( "\3", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            klient->trenne();
        }
        klient = klient->release();
    }
    fehler = fehler->release();
    UNLOCK( &cs );
    DeleteCriticalSection( &cs );
}

// nicht constant
bool InformationKlient::verbinde() // verbindet ich mit dem Informaion Server
{
    LOCK( &cs );
    if( verbunden )
    {
        UNLOCK( &cs );
        return 1;
    }
    if( !klient )
    {
        char *msIp = getMainServerIp();
        unsigned short msPort = getMainServerPort();
        klient = new Klient();
        unsigned char schlüssel[ 20 ] = { 199, 164, 172, 55, 246, 16, 155, 8, 151, 176, 250, 181, 227, 133, 30, 41, 200, 26, 7, 151 };
        klient->setSendeSchlüssel( (char*)schlüssel, 20 );
        klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
        if( !klient->verbinde( msPort, msIp ) )
        {
            fehler->setText( "Fehler beim verbinden mit dem Main Server. Bitte versuche es Später erneut." );
            klient = klient->release();
            delete[]msIp;
            UNLOCK( &cs );
            return 0;
        }
        delete[]msIp;
        klient->sende( "\0", 1 ); // Verschlüsselung aktivieren
        klient->sendeVerschlüsselt( "\1", 1 );
        klient->sendeVerschlüsselt( (char*)&klientId, 4 );
        char serverReturn = 0;
        klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
        if( serverReturn == 3 )
        {
            char län = 0;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *nachricht = new char[ län + 1 ];
            nachricht[ län ] = 0;
            klient->getNachrichtVerschlüsselt( nachricht, län );
            fehler->setText( nachricht );
            delete[]nachricht;
            klient->sendeVerschlüsselt( "\3", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            klient->trenne();
            klient = klient->release();
            UNLOCK( &cs );
            return 0;
        }
        char *sl = 0;
        char slLän = getSchlüssel( &sl );
        klient->setSendeSchlüssel( sl, slLän );
        klient->setEmpfangSchlüssel( sl, slLän );
        delete[] sl;
        klient->sendeVerschlüsselt( "\6\4", 2 );
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        if( byte == 2 )
        {
            unsigned char lsIp[ 4 ];
            klient->getNachrichtVerschlüsselt( (char *)lsIp, 4 );
            unsigned short lsPort = 0;
            klient->getNachrichtVerschlüsselt( (char*)&lsPort, 2 );
            klient->sendeVerschlüsselt( "\3", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            klient->trenne();
            Text *lsIpT = new Text( "" );
            lsIpT->anhängen( (int)lsIp[ 0 ] );
            lsIpT->anhängen( "." );
            lsIpT->anhängen( (int)lsIp[ 1 ] );
            lsIpT->anhängen( "." );
            lsIpT->anhängen( (int)lsIp[ 2 ] );
            lsIpT->anhängen( "." );
            lsIpT->anhängen( (int)lsIp[ 3 ] );
            unsigned char schlüssel[ 20 ] = { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 };
            klient->setSendeSchlüssel( (char*)schlüssel, 20 );
            klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
            klient->verbinde( lsPort, lsIpT->getText() );
            lsIpT = lsIpT->release();
            klient->sendeVerschlüsselt( "\3", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            klient->trenne();
        }
        if( byte == 3 )
        {
            klient->getNachrichtVerschlüsselt( &byte, 1 );
            char *f = new char[ byte + 1 ];
            f[ byte ] = 0;
            klient->getNachrichtVerschlüsselt( f, byte );
            fehler->setText( f );
            delete[]f;
            klient->sendeVerschlüsselt( "\3", 1 );
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            klient->trenne();
            klient = klient->release();
            UNLOCK( &cs );
            return 0;
        }
    }
    unsigned char schlüssel[ 20 ] = { 231, 246, 125, 32, 88, 172, 229, 223, 246, 138, 74, 64, 142, 245, 217, 218, 162, 62, 103, 50 };
    klient->setSendeSchlüssel( (char*)schlüssel, 20 );
    klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
    if( klient->verbinde( klient->getServerPort(), klient->getServerIp() ) )
    {
        if( klient->sendeVerschlüsselt( "\1", 1 ) )
        {
            klient->sendeVerschlüsselt( (char*)&klientId, 4 );
            char serverReturn = 0;
            klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
            if( serverReturn == 3 )
            {
                char byte = 0;
                klient->getNachrichtVerschlüsselt( &byte, 1 );
                char *f = new char[ byte + 1 ];
                f[ byte ] = 0;
                klient->getNachrichtVerschlüsselt( f, byte );
                fehler->setText( f );
                delete[]f;
                klient->sendeVerschlüsselt( "\3", 1 );
                klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
                klient->trenne();
                UNLOCK( &cs );
                return 0;
            }
            char *sl = 0;
            char slLän = getSchlüssel( &sl );
            klient->setSendeSchlüssel( sl, slLän );
            klient->setEmpfangSchlüssel( sl, slLän );
            delete[] sl;
            verbunden = 1;
            UNLOCK( &cs );
            return 1;
        }
        else
        {
            fehler->setText( "Der dir zugewiesene Informations Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut." );
            klient = klient->release();
        }
    }
    else
    {
        fehler->setText( "Der dir zugewiesene Informations Server antwortet nicht. Bitte versuche es Später erneut." );
        klient = klient->release();
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::getInformationText( Text *txt, int *typ ) // fragt nach Informationstext
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    bool ret = 1;
    ret = ret & klient->sendeVerschlüsselt( "\5", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    short län = 0;
    ret = ret & klient->getNachrichtVerschlüsselt( (char*)&län, 2 );
    char *text = new char[ län + 1 ];
    text[ län ] = 0;
    if( län )
        ret = ret & klient->getNachrichtVerschlüsselt( text, län );
    txt->setText( text );
    delete[]text;
    char type = 0;
    ret = ret & klient->getNachrichtVerschlüsselt( &type, 1 );
    *typ = type;
    if( !ret )
        fehler->setText( "Verbindungsfehler" );
    UNLOCK( &cs );
    return ret;
}

bool InformationKlient::istSpielErlaubt( int spielId ) // fragt, ob das entsprechende Spiel vom Server gesperrt wurde
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\6", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&spielId, 4 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    UNLOCK( &cs );
    return ret != 0;
}

bool InformationKlient::istKarteErlaubt( int karteId ) // fragt, ob die entsprechende Karte vom Server gesperrt wurde
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\7", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&karteId, 4 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    UNLOCK( &cs );
    return ret != 0;
}

int InformationKlient::getKarteId( char *name ) // fragt nach der Id einer Karte
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x9", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    char län = textLänge( name );
    klient->sendeVerschlüsselt( &län, 1 );
    klient->sendeVerschlüsselt( name, län );
    int id = 0;
    klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
    UNLOCK( &cs );
    return id;
}

int InformationKlient::getSpielId( char *name ) // fragt nach der id eines Spiels
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x8", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    char län = textLänge( name );
    klient->sendeVerschlüsselt( &län, 1 );
    klient->sendeVerschlüsselt( name, län );
    int id = 0;
    klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
    UNLOCK( &cs );
    return id;
}

Text *InformationKlient::getSpielerName( int accountId ) // fragt nach dem Namen eines Accounts
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xA", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&accountId, 4 );
    char län = 0;
    klient->getNachrichtVerschlüsselt( &län, 1 );
    char *name = new char[ län + 1 ];
    name[ län ] = 0;
    if( län )
        klient->getNachrichtVerschlüsselt( name, län );
    Text *ret = new Text( name );
    delete[]name;
    UNLOCK( &cs );
    return ret;
}

bool InformationKlient::getSpielStatistik( int accountId, int spielId, Array< int > *werte ) // fragt nach der Spiel Statistik eines Accounts
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    bool ret = 1;
    ret = ret & klient->sendeVerschlüsselt( "\xB", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    ret = ret & klient->sendeVerschlüsselt( (char*)&accountId, 4 );
    ret = ret & klient->sendeVerschlüsselt( (char*)&spielId, 4 );
    for( int i = 0; i < 10; i++ )
    {
        int tmp = 0;
        ret = ret & klient->getNachrichtVerschlüsselt( (char*)&tmp, 4 );
        werte->add( tmp, i );
    }
    if( !ret )
        fehler->setText( "Verbindungsfehler" );
    UNLOCK( &cs );
    return ret;
}

Text *InformationKlient::getKarteName( int karteId ) // fragt nach dem Namen einer Karte
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xE", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&karteId, 4 );
    char län = 0;
    klient->getNachrichtVerschlüsselt( &län, 1 );
    char *name = new char[ län + 1 ];
    name[ län ] = 0;
    if( län )
        klient->getNachrichtVerschlüsselt( name, län );
    Text *ret = new Text( name );
    delete[]name;
    UNLOCK( &cs );
    return ret;
}

Text *InformationKlient::getSpielName( int spielId ) // fragt nach dem Namen einer Spielart
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xF", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&spielId, 4 );
    char län = 0;
    klient->getNachrichtVerschlüsselt( &län, 1 );
    char *name = new char[ län + 1 ];
    name[ län ] = 0;
    if( län )
        klient->getNachrichtVerschlüsselt( name, län );
    Text *ret = new Text( name );
    delete[]name;
    UNLOCK( &cs );
    return ret;
}

Text *InformationKlient::getChatroomName( int chatroomId ) // fragt nach dem Namen eines Chatrooms
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x10", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&chatroomId, 4 );
    char län = 0;
    klient->getNachrichtVerschlüsselt( &län, 1 );
    char *name = new char[ län + 1 ];
    name[ län ] = 0;
    if( län )
        klient->getNachrichtVerschlüsselt( name, län );
    Text *ret = new Text( name );
    delete[]name;
    UNLOCK( &cs );
    return ret;
}

int InformationKlient::getSpielId( int karteId ) // fragt zu welcher Spielart die Karte gehört
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x11", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&karteId, 4 );
    int ret = 0;
    klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
    UNLOCK( &cs );
    return ret;
}

int InformationKlient::getAccountId( char *name ) // gibt die Id des Accounts zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char län = textLänge( name );
    if( !län )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x12", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( &län, 1 );
    klient->sendeVerschlüsselt( name, län );
    int ret = 0;
    klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
    UNLOCK( &cs );
    return ret;
}

int InformationKlient::getChatroomId( char *name ) // gibt die Id des Chatrooms zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char län = textLänge( name );
    if( !län )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x13", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( &län, 1 );
    klient->sendeVerschlüsselt( name, län );
    int ret = 0;
    klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
    UNLOCK( &cs );
    return ret;
}

int InformationKlient::getGruppenKarteId( int gruppenId ) // gibt die karten Id der gruppe zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xD", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&gruppenId, 4 );
    int id = 0;
    klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
    UNLOCK( &cs );
    return id;
}

bool InformationKlient::getGruppeSpielerHinzufügen( int gruppeId ) // gibt die Spieler hinzufügen Funktion der Gruppe zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x1E", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&gruppeId, 4 );
    char sh = 0;
    klient->getNachrichtVerschlüsselt( (char*)&sh, 1 );
    UNLOCK( &cs );
    return sh == 1;
}

int InformationKlient::getGruppeAdminId( int gruppeId ) // gibt den Gruppen Administrator zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x15", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&gruppeId, 4 );
    int id = 0;
    klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
    UNLOCK( &cs );
    return id;
}

int InformationKlient::getSpielerPunkte( int accountId, int spielId ) // gibt die Punkte eines Spielers zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x14", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[]f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&spielId, 4 );
    klient->sendeVerschlüsselt( (char*)&accountId, 4 );
    int punkte = 0;
    klient->getNachrichtVerschlüsselt( (char*)&punkte, 4 );
    UNLOCK( &cs );
    return punkte;
}

Array< int > *InformationKlient::getAccountSpielArtListe() // gibt eine Liste mit gekauften Spielen zurück
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x16", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        Array< int > *list = new Array< int >();
        for( int i = 0; i < anz; i++ )
        {
            int id = 0;
            klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
            list->add( id );
        }
        UNLOCK( &cs );
        return list;
    }
    if( ref == 3 )
    {
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        char *err = new char[ ret + 1 ];
        err[ ret ] = 0;
        if( ret )
            klient->getNachrichtVerschlüsselt( err, ret );
        fehler->setText( err );
        delete[] err;
    }
    UNLOCK( &cs );
    return 0;
}

int InformationKlient::getSpielVersion( int spielId ) // gibt die neuste Version eines Spiels zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x17", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&spielId, 4 );
    int version = 0;
    klient->getNachrichtVerschlüsselt( (char*)&version, 4 );
    UNLOCK( &cs );
    return version;
}

int InformationKlient::getKupfer() // gibt das Kupfer des Accounts zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x18", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    int kupfer = 0;
    klient->getNachrichtVerschlüsselt( (char*)&kupfer, 4 );
    UNLOCK( &cs );
    return kupfer;
}

int InformationKlient::getDateiGruppeIdVonSpiel( int spielId ) // Gibt die Dateigruppe eines Spieles zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x19", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&spielId, 4 );
    int dgId = 0;
    klient->getNachrichtVerschlüsselt( (char*)&dgId, 4 );
    UNLOCK( &cs );
    return dgId;
}

Text *InformationKlient::getDateiGruppePfad( int dgId ) // Gibt den Dateigruppen Pfad zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x1A", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&dgId, 4 );
        klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
        if( serverReturn == 1 )
        {
            char län = 0;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *pf = new char[ län + 1 ];
            pf[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( pf, län );
            Text *pfad = new Text( pf );
            delete[] pf;
            UNLOCK( &cs );
            return pfad;
        }
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Array< int > *InformationKlient::getAccountKarteListe( int spielId ) // gibt eine Liste mit gekauften Karten zurück
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x1B", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&spielId, 4 );
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        Array< int > *list = new Array< int >();
        for( int i = 0; i < anz; i++ )
        {
            int id = 0;
            klient->getNachrichtVerschlüsselt( (char*)&id, 4 );
            list->add( id );
        }
        UNLOCK( &cs );
        return list;
    }
    if( ref == 3 )
    {
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        char *err = new char[ ret + 1 ];
        err[ ret ] = 0;
        if( ret )
            klient->getNachrichtVerschlüsselt( err, ret );
        fehler->setText( err );
        delete[] err;
    }
    UNLOCK( &cs );
    return 0;
}

int InformationKlient::getDateiGruppeIdVonPfad( char *pfad ) // Gibt die Dateigruppe eines Pfades zurück
{
    char län = textLänge( pfad );
    if( !län )
        return 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x2A", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&län, 1 );
    klient->sendeVerschlüsselt( (char*)pfad, län );
    int dgId = 0;
    klient->getNachrichtVerschlüsselt( (char*)&dgId, 4 );
    UNLOCK( &cs );
    return dgId;
}

int InformationKlient::getDateiGruppeVersion( int dg ) // gibt die neuste Version einer Dateigruppe zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x2B", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( (char*)&dg, 4 );
    int version = 0;
    klient->getNachrichtVerschlüsselt( (char*)&version, 4 );
    UNLOCK( &cs );
    return version;
}

int InformationKlient::getSpielerListe( char *suche, int *seite, int *maxSeite, char sortSpalte, char rückwärts,
                                        Array< int > *accounts, RCArray< Text > *name, RCArray< Text > *zuletztOnline,
                                        RCArray< Text > *letztesSpiel, RCArray< Text > *letzteKarte, RCArray< Text > *punkte ) // sucht nach Spielern
{
    char län = textLänge( suche );
    if( !län )
        return -1;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return -1;
    }
    char serverReturn = 0;
    klient->sendeVerschlüsselt( "\xC", 1 );
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        klient->sendeVerschlüsselt( &län, 1 );
        klient->sendeVerschlüsselt( suche, län );
        klient->sendeVerschlüsselt( (char*)seite, 4 );
        klient->sendeVerschlüsselt( &sortSpalte, 1 );
        klient->sendeVerschlüsselt( &rückwärts, 1 );
        klient->getNachrichtVerschlüsselt( (char*)seite, 4 );
        klient->getNachrichtVerschlüsselt( (char*)maxSeite, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        for( int i = 0; i < ret; i++ )
        {
            int accId = 0;
            klient->getNachrichtVerschlüsselt( (char*)&accId, 4 );
            accounts->set( accId, i );
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *txt = new char[ län + 1 ];
            txt[ län ] = 0;
            klient->getNachrichtVerschlüsselt( txt, län );
            name->set( new Text( txt ), i );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            klient->getNachrichtVerschlüsselt( txt, län );
            zuletztOnline->set( new Text( txt ), i );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            klient->getNachrichtVerschlüsselt( txt, län );
            letztesSpiel->set( new Text( txt ), i );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            klient->getNachrichtVerschlüsselt( txt, län );
            letzteKarte->set( new Text( txt ), i );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            klient->getNachrichtVerschlüsselt( txt, län );
            punkte->set( new Text( txt ), i );
            delete[] txt;
        }
        UNLOCK( &cs );
        return ret;
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return -1;
}

bool InformationKlient::getSpielerAktivität( int accId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt,
                                             Array< int > *anzSpiele, Array< int > *anzGewonnen ) // ermittelt die aktivität eines Spielers
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char ret = 0;
    klient->sendeVerschlüsselt( "\x1F", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&accId, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            klient->getNachrichtVerschlüsselt( &ret, 1 );
            for( int i = 0; ret; i++ )
            {
                char *txt = new char[ ret + 1 ];
                txt[ ret ] = 0;
                klient->getNachrichtVerschlüsselt( txt, ret );
                datum->set( new Text( txt ), i );
                delete[] txt;
                double sto = 0;
                klient->getNachrichtVerschlüsselt( (char*)&sto, 8 );
                stOnline->set( sto, i );
                double sts = 0;
                klient->getNachrichtVerschlüsselt( (char*)&sts, 8 );
                stGespielt->set( sts, i );
                int anzs = 0;
                klient->getNachrichtVerschlüsselt( (char*)&anzs, 4 );
                anzSpiele->set( anzs, i );
                int anzg = 0;
                klient->getNachrichtVerschlüsselt( (char*)&anzg, 4 );
                anzGewonnen->set( anzg, i );
                klient->getNachrichtVerschlüsselt( &ret, 1 );
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 1;
}

int InformationKlient::getAccountKarteSpiele( int account, int karte ) // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char ret = 0;
    klient->sendeVerschlüsselt( "\x20", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        klient->sendeVerschlüsselt( (char*)&karte, 4 );
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        UNLOCK( &cs );
        return anz;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

int InformationKlient::getAccountKarteSpieleGewonnen( int account, int karte ) // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char ret = 0;
    klient->sendeVerschlüsselt( "\x21", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        klient->sendeVerschlüsselt( (char*)&karte, 4 );
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        UNLOCK( &cs );
        return anz;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::hatAccountKarte( int account, int karte ) // Gibt zurück, ob ein Spieler die Karte im Besitz hat
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char ret = 0;
    klient->sendeVerschlüsselt( "\x22", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        klient->sendeVerschlüsselt( (char*)&karte, 4 );
        char status = 0;
        klient->getNachrichtVerschlüsselt( &status, 1 );
        UNLOCK( &cs );
        return status != 0;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::hatAccountSpiel( int account, int spiel ) // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char ret = 0;
    klient->sendeVerschlüsselt( "\x23", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        klient->sendeVerschlüsselt( (char*)&spiel, 4 );
        char status = 0;
        klient->getNachrichtVerschlüsselt( &status, 1 );
        UNLOCK( &cs );
        return status != 0;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Array< int > *InformationKlient::getAccountKarteGespieltListe( int account, int spielId ) // gibt eine Liste mit Karten zurück, die von einem Spieler bereits gespielt wurden
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x24", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        klient->sendeVerschlüsselt( (char*)&spielId, 4 );
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        Array< int > *ret = new Array< int >();
        for( int i = 0; i < anz; i++ )
        {
            int val = 0;
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            ret->set( val, i );
        }
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

Array< int > *InformationKlient::getAccountSpielGespieltListe( int account ) // gibt eine Liste mit Spielen zurück, die von einem Spieler bereits gespielt wurden
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x25", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        Array< int > *ret = new Array< int >();
        for( int i = 0; i < anz; i++ )
        {
            int val = 0;
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            ret->set( val, i );
        }
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::getSpielPartnerListe( int account, Array< int > *spieler, Array< int > *karten, Array< int > *anzahl ) // Gibt eine Liste von Spiel Partnern eines Spielers zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x26", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        int anz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
        for( int i = 0; i < anz; i++ )
        {
            int val = 0;
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            spieler->set( val, i );
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            karten->set( val, i );
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            anzahl->set( val, i );
        }
        UNLOCK( &cs );
        return 1;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts,
                                           RCArray< Array< int > > *werte, RCArray< Text > *namen ) // Gibt eine Liste mit Spiel Statistiken zurück
{
    if( !*seite )
        *seite = 1;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    char serverReturn = 0;
    klient->sendeVerschlüsselt( "\x27", 1 );
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    if( serverReturn == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        klient->sendeVerschlüsselt( (char*)seite, 4 );
        klient->sendeVerschlüsselt( &sortSpalte, 1 );
        klient->sendeVerschlüsselt( &rückwärts, 1 );
        klient->getNachrichtVerschlüsselt( (char*)seite, 4 );
        klient->getNachrichtVerschlüsselt( (char*)maxSeite, 4 );
        int zAnz = 0;
        int sAnz = 0;
        klient->getNachrichtVerschlüsselt( (char*)&zAnz, 4 );
        klient->getNachrichtVerschlüsselt( (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;
                    klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
                    tmp->set( val, j );
                }
                else
                {
                    char län = 0;
                    klient->getNachrichtVerschlüsselt( &län, 1 );
                    char *n = new char[ län + 1 ];
                    n[ län ] = 0;
                    if( län )
                        klient->getNachrichtVerschlüsselt( n, län );
                    namen->set( new Text( n ), i );
                    delete[] n;
                }
            }
            werte->set( tmp, i );
        }
        UNLOCK( &cs );
        return 1;
    }
    if( serverReturn == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return 0;
}

AHDaten *InformationKlient::getSpielHistorieDaten( int account ) // Gibt eine Liste mit den letzten 20 Spielen zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x28", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&account, 4 );
        AHDaten *ret = new AHDaten();
        char anz = 0;
        klient->getNachrichtVerschlüsselt( &anz, 1 );
        for( char i = 0; i < anz; i++ )
        {
            AHSpielDaten *spiel = new AHSpielDaten();
            klient->getNachrichtVerschlüsselt( (char*)&spiel->id, 4 );
            klient->getNachrichtVerschlüsselt( (char*)&spiel->karteId, 4 );
            char län = 0;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->spiel->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->karte->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->datum->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->status->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->dauer->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->spielStatus->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            spiel->gewinner->setText( txt );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( (char*)&spiel->sAnzahl, 4 );
            char tAnz = 0;
            klient->getNachrichtVerschlüsselt( &tAnz, 1 );
            for( char j = 0; j < tAnz; j++ )
            {
                AHSpielTeamDaten *team = new AHSpielTeamDaten();
                char län = 0;
                klient->getNachrichtVerschlüsselt( &län, 1 );
                char *txt = new char[ län + 1 ];
                txt[ län ] = 0;
                if( län )
                    klient->getNachrichtVerschlüsselt( txt, län );
                team->name->setText( txt );
                delete[] txt;
                klient->getNachrichtVerschlüsselt( (char*)&team->sAnzahl, 4 );
                klient->getNachrichtVerschlüsselt( &län, 1 );
                txt = new char[ län + 1 ];
                txt[ län ] = 0;
                if( län )
                    klient->getNachrichtVerschlüsselt( txt, län );
                team->status->setText( txt );
                delete[] txt;
                klient->getNachrichtVerschlüsselt( (char*)&team->farbe, 4 );
                char sAnz = 0;
                klient->getNachrichtVerschlüsselt( &sAnz, 1 );
                for( char k = 0; k < sAnz; k++ )
                {
                    AHSpielSpielerDaten *spieler = new AHSpielSpielerDaten();
                    char län = 0;
                    klient->getNachrichtVerschlüsselt( &län, 1 );
                    char *txt = new char[ län + 1 ];
                    txt[ län ] = 0;
                    if( län )
                        klient->getNachrichtVerschlüsselt( txt, län );
                    spieler->name->setText( txt );
                    delete[] txt;
                    klient->getNachrichtVerschlüsselt( (char*)&spieler->punkte, 4 );
                    klient->getNachrichtVerschlüsselt( &län, 1 );
                    txt = new char[ län + 1 ];
                    txt[ län ] = 0;
                    if( län )
                        klient->getNachrichtVerschlüsselt( txt, län );
                    spieler->status->setText( txt );
                    delete[] txt;
                    klient->getNachrichtVerschlüsselt( (char*)&spieler->farbe, 4 );
                    team->spieler->set( spieler, k );
                }
                spiel->teams->set( team, j );
            }
            ret->spiele->set( spiel, i );
        }
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
        UNLOCK( &cs );
        return 0;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::getHistorieServer( int spielId, int *port, Text *ip ) // sucht nach dem Historie Server von einem Spiel
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x29", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&spielId, 4 );
        klient->getNachrichtVerschlüsselt( (char*)&ret, 1 );
        if( ret == 1 )
        {
            klient->getNachrichtVerschlüsselt( (char*)port, 4 );
            char län = 0;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            ip->füllText( ' ', län );
            klient->getNachrichtVerschlüsselt( ip->getText(), län );
            UNLOCK( &cs );
            return 1;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::keepAlive() // Erhält die Verbindung aufrecht
{
    if( !verbunden )
        return 0;
    char res = 0;
    if( !TryEnterCriticalSection( &cs ) )
        return 1;
    klient->sendeVerschlüsselt( "\x2C", 1 );
    klient->getNachrichtVerschlüsselt( &res, 1 );
    UNLOCK( &cs );
    if( res != 1 )
        trenne();
    return res == 1;
}

bool InformationKlient::hatRecht( int recht ) // Prüft ob Berechtigung vorhanden
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x2D", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&recht, 4 );
        klient->getNachrichtVerschlüsselt( (char*)&ret, 1 );
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return ret == 1;
}

int InformationKlient::getKartenListe( char *filter, char sortSpalte, char absteigend, Array< int > *kId, RCArray< Text > *kName, RCArray< Text > *sName,
                                       Array< int > *kupfer, Array< int > *verkauft, Array< int > *maxSpieler ) // Gibt eine Liste mit Karten zurück
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x2E", 1 );
    char res = 0;
    klient->getNachrichtVerschlüsselt( &res, 1 );
    int ret = 0;
    if( res == 1 )
    {
        char län = textLänge( filter );
        klient->sendeVerschlüsselt( &län, 1 );
        klient->sendeVerschlüsselt( filter, län );
        klient->sendeVerschlüsselt( &sortSpalte, 1 );
        klient->sendeVerschlüsselt( &absteigend, 1 );
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        for( int i = 0; i < ret; i++ )
        {
            int val = 0;
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            kId->set( val, i );
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            kName->set( new Text( txt ), i );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            txt = new char[ län + 1 ];
            txt[ län ] = 0;
            if( län )
                klient->getNachrichtVerschlüsselt( txt, län );
            sName->set( new Text( txt ), i );
            delete[] txt;
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            kupfer->set( val, i );
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            verkauft->set( val, i );
            klient->getNachrichtVerschlüsselt( (char*)&val, 4 );
            maxSpieler->set( val, i );
        }
    }
    if( res == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return ret;
}

bool InformationKlient::getEditorServer( int karteId, int *port, Text *ip ) // sucht nach dem Editor Server von einer Karte
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x2F", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&karteId, 4 );
        klient->getNachrichtVerschlüsselt( (char*)&ret, 1 );
        if( ret == 1 )
        {
            klient->getNachrichtVerschlüsselt( (char*)port, 4 );
            char län = 0;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            ip->füllText( ' ', län );
            klient->getNachrichtVerschlüsselt( ip->getText(), län );
            UNLOCK( &cs );
            return 1;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::getKartenServer( int karteId, int *port, Text *ip ) // sucht nach dem Karten Server von einer Karte
{
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x30", 1 );
    char ret = 0;
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&karteId, 4 );
        klient->getNachrichtVerschlüsselt( (char*)&ret, 1 );
        if( ret == 1 )
        {
            klient->getNachrichtVerschlüsselt( (char*)port, 4 );
            char län = 0;
            klient->getNachrichtVerschlüsselt( &län, 1 );
            ip->füllText( ' ', län );
            klient->getNachrichtVerschlüsselt( ip->getText(), län );
            UNLOCK( &cs );
            return 1;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtVerschlüsselt( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtVerschlüsselt( f, byte );
        fehler->setText( f );
        delete[] f;
    }
    UNLOCK( &cs );
    return 0;
}

bool InformationKlient::trenne() // trennt sich von dem Informaion Server
{
    LOCK( &cs );
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 1;
    }
    klient->sendeVerschlüsselt( "\3", 1 );
    Sleep( 100 );
    klient->trenne();
    verbunden = 0;
    UNLOCK( &cs );
    return 1;
}

// constant
bool InformationKlient::istVerbunden() const // prüft, ob mit Informaion Server verbunden
{
    return verbunden;
}

char *InformationKlient::getLetzterFehler() const // gibt den Letzten Fehlertext zuück
{
    return fehler->getText();
}

// Reference Counting
InformationKlientV *InformationKlient::getThis()
{
    ref++;
    return this;
}

InformationKlientV *InformationKlient::release()
{
    ref--;
    if( !ref )
        delete this;
    return 0;
}