3DTest/3DTest/Netzwerk/Klients/ShopK.cpp

#include "../KSGKlient.h"
#include "../KSGServer.h"
#include <Datei.h>

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

// Destruktor
ShopKlient::~ShopKlient()
{
    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 ] = { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 };
            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 );
}

// privat
bool ShopKlient::verbinde( int port, char *ip ) // verbindet sich mit vorgegebenem Server
{
    unsigned char schlüssel[ 20 ] = { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 };
    klient->setSendeSchlüssel( (char*)schlüssel, 20 );
    klient->setEmpfangSchlüssel( (char*)schlüssel, 20 );
    if( klient->verbinde( port, ip ) )
    {
        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;
                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;
            return 1;
        }
        else
        {
            fehler->setText( "Der dir zugewiesene Shop Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut." );
            klient = klient->release();
        }
    }
    else
    {
        fehler->setText( "Der dir zugewiesene Shop Server antwortet nicht. Bitte versuche es Später erneut." );
        klient = klient->release();
    }
    return 0;
}

// nicht constant
bool ShopKlient::verbinde() // verbindet ich mit dem Shop 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\7", 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 ] = { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 };
            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 ] = { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 };
    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 Shop Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut." );
            klient = klient->release();
        }
    }
    else
    {
        fehler->setText( "Der dir zugewiesene Shop Server antwortet nicht. Bitte versuche es Später erneut." );
        klient = klient->release();
    }
    UNLOCK( &cs );
    return 0;
}

Array< int > *ShopKlient::suchSpiele( const char *suche ) // sucht nach Spielen
{
    char län = (char)textLänge( suche );
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\5", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( &län, 1 );
        if( län )
            klient->sendeVerschlüsselt( suche, län );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            Array< int > *ret = new Array< int >();
            for( int i = 0; i < anz; i++ )
            {
                int w = 0;
                klient->getNachrichtVerschlüsselt( (char*)&w, 4 );
                ret->add( w );
            }
            UNLOCK( &cs );
            return ret;
        }
    }
    if( ret == 3 )
    {
        klient->getNachrichtVerschlüsselt( &län, 1 );
        char *err = new char[ län + 1 ];
        err[ län ] = 0;
        if( län )
            klient->getNachrichtVerschlüsselt( err, län );
        fehler->setText( err );
        delete[] err;
    }
    UNLOCK( &cs );
    return 0;
}

bool ShopKlient::ladeSpielTitel( int id ) // läd Titelbild des Spieles herunter
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\6", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/spiele/" );
            pf->anhängen( id );
            pf->anhängen( "/titelbg.ltdb" );
            Datei *dat = new Datei();
            dat->setDatei( pf );
            dat->erstellen();
            dat->öffnen( Datei::Style::schreiben );
            __int64 gr = 0;
            klient->getNachrichtVerschlüsselt( (char*)&gr, 8 );
            char bytes[ 2048 ];
            while( gr > 0 )
            {
                int län = gr > 2048 ? 2048 : (int)gr;
                klient->getNachricht( bytes, län );
                dat->schreibe( bytes, län );
                gr -= län;
            }
            dat->schließen();
            dat->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            int port = 0;
            char län = 0;
            klient->getNachrichtVerschlüsselt( (char*)&port, 4 );
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *ip = new char[ län + 1 ];
            klient->getNachrichtVerschlüsselt( ip, län );
            ip[ län ] = 0;
            klient->trenne();
            if( !verbinde( port, ip ) )
            {
                delete[] ip;
                trenne();
                UNLOCK( &cs );
                return 0;
            }
            delete[] ip;
            UNLOCK( &cs );
            return ladeSpielTitel( id );
        }
    }
    if( ret == 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;
    }
    UNLOCK( &cs );
    return 1;
}

bool ShopKlient::ladeSpielSeite( int id ) // läd Seite des Spieles herunter
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\7", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/spiele/" );
            pf->anhängen( id );
            pf->anhängen( "/" );
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char län = 0;
                klient->getNachrichtVerschlüsselt( &län, 1 );
                char *name = new char[ län + 1 ];
                name[ län ] = 0;
                klient->getNachrichtVerschlüsselt( name, län );
                Text *pfad = new Text( pf->getText() );
                pfad->anhängen( name );
                delete[] name;
                Datei *d = new Datei();
                d->setDatei( pfad );
                d->erstellen();
                d->öffnen( Datei::Style::schreiben );
                __int64 gr = 0;
                klient->getNachrichtVerschlüsselt( (char*)&gr, 8 );
                char bytes[ 2048 ];
                while( gr > 0 )
                {
                    int län = gr > 2048 ? 2048 : (int)gr;
                    klient->getNachricht( bytes, län );
                    d->schreibe( bytes, län );
                    gr -= län;
                }
                d->schließen();
                d->release();
            }
            pf->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            int port = 0;
            char län = 0;
            klient->getNachrichtVerschlüsselt( (char*)&port, 4 );
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *ip = new char[ län + 1 ];
            klient->getNachrichtVerschlüsselt( ip, län );
            ip[ län ] = 0;
            klient->trenne();
            if( !verbinde( port, ip ) )
            {
                delete[] ip;
                trenne();
                UNLOCK( &cs );
                return 0;
            }
            delete[] ip;
            UNLOCK( &cs );
            return ladeSpielSeite( id );
        }
    }
    if( ret == 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;
    }
    UNLOCK( &cs );
    return 1;
}

int ShopKlient::getSpielBesitzStatus( int id ) // 0 = nicht im Besitz, 1 = Testversion, 2 = gekauft
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x8", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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 ShopKlient::getSpielTestversion( int id ) // gibt die Anzahl der verbleibenden Spiele zurück
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x9", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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 ShopKlient::istSpielErwerbbar( int id ) // prüft, ob das Spiel erworben werden kann
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xA", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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 ShopKlient::getSpielPreis( int id, bool testVersion ) // gibt den Preis eines Spieles zurück
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xB", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->sendeVerschlüsselt( (char*)&testVersion, 1 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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;
}

bool ShopKlient::spielErwerben( int spielId, bool testVersion ) // Spiel kaufen
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xC", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&spielId, 4 );
        klient->sendeVerschlüsselt( (char*)&testVersion, 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            UNLOCK( &cs );
            return 1;
        }
    }
    if( ret == 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;
}

Array< int > *ShopKlient::suchKarten( const char *suche, int spielId ) // sucht nach Karten
{
    char län = (char)textLänge( suche );
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xD", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&spielId, 4 );
        klient->sendeVerschlüsselt( &län, 1 );
        if( län )
            klient->sendeVerschlüsselt( suche, län );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            Array< int > *ret = new Array< int >();
            for( int i = 0; i < anz; i++ )
            {
                int w = 0;
                klient->getNachrichtVerschlüsselt( (char*)&w, 4 );
                ret->add( w );
            }
            UNLOCK( &cs );
            return ret;
        }
    }
    if( ret == 3 )
    {
        klient->getNachrichtVerschlüsselt( &län, 1 );
        char *err = new char[ län + 1 ];
        err[ län ] = 0;
        if( län )
            klient->getNachrichtVerschlüsselt( err, län );
        fehler->setText( err );
        delete[] err;
    }
    UNLOCK( &cs );
    return 0;
}

bool ShopKlient::ladeKarteTitel( int id ) // läd Titelbild der Karte herunter
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xE", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/karten/" );
            pf->anhängen( id );
            pf->anhängen( "/titelbg.ltdb" );
            Datei *dat = new Datei();
            dat->setDatei( pf );
            dat->erstellen();
            dat->öffnen( Datei::Style::schreiben );
            __int64 gr = 0;
            klient->getNachrichtVerschlüsselt( (char*)&gr, 8 );
            char bytes[ 2048 ];
            while( gr > 0 )
            {
                int län = gr > 2048 ? 2048 : (int)gr;
                klient->getNachricht( bytes, län );
                dat->schreibe( bytes, län );
                gr -= län;
            }
            dat->schließen();
            dat->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            int port = 0;
            char län = 0;
            klient->getNachrichtVerschlüsselt( (char*)&port, 4 );
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *ip = new char[ län + 1 ];
            klient->getNachrichtVerschlüsselt( ip, län );
            ip[ län ] = 0;
            klient->trenne();
            if( !verbinde( port, ip ) )
            {
                delete[] ip;
                trenne();
                UNLOCK( &cs );
                return 0;
            }
            delete[] ip;
            UNLOCK( &cs );
            return ladeKarteTitel( id );
        }
    }
    if( ret == 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;
    }
    UNLOCK( &cs );
    return 1;
}

bool ShopKlient::ladeKarteSeite( int id ) // läd Seite der Karte herunter
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\xF", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            Text *pf = new Text( "data/tmp/shop/kaufen/karten/" );
            pf->anhängen( id );
            pf->anhängen( "/" );
            int anz = 0;
            klient->getNachrichtVerschlüsselt( (char*)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char län = 0;
                klient->getNachrichtVerschlüsselt( &län, 1 );
                char *name = new char[ län + 1 ];
                name[ län ] = 0;
                klient->getNachrichtVerschlüsselt( name, län );
                Text *pfad = new Text( pf->getText() );
                pfad->anhängen( name );
                delete[] name;
                Datei *d = new Datei();
                d->setDatei( pfad );
                d->erstellen();
                d->öffnen( Datei::Style::schreiben );
                __int64 gr = 0;
                klient->getNachrichtVerschlüsselt( (char*)&gr, 8 );
                char bytes[ 2048 ];
                while( gr > 0 )
                {
                    int län = gr > 2048 ? 2048 : (int)gr;
                    klient->getNachricht( bytes, län );
                    d->schreibe( bytes, län );
                    gr -= län;
                }
                d->schließen();
                d->release();
            }
            pf->release();
        }
        if( ret == 2 )
        { // Verweis auf anderen ShopServer
            int port = 0;
            char län = 0;
            klient->getNachrichtVerschlüsselt( (char*)&port, 4 );
            klient->getNachrichtVerschlüsselt( &län, 1 );
            char *ip = new char[ län + 1 ];
            klient->getNachrichtVerschlüsselt( ip, län );
            ip[ län ] = 0;
            klient->trenne();
            if( !verbinde( port, ip ) )
            {
                delete[] ip;
                trenne();
                UNLOCK( &cs );
                return 0;
            }
            delete[] ip;
            UNLOCK( &cs );
            return ladeKarteSeite( id );
        }
    }
    if( ret == 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;
    }
    UNLOCK( &cs );
    return 1;
}

int ShopKlient::getKarteBesitzStatus( int id ) // 0 = nicht im Besitz, 1 = Testversion, 2 = gekauft
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x10", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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 ShopKlient::getKarteTestversion( int id ) // gibt die Anzahl der verbleibenden Spiele zurück
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x11", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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 ShopKlient::istKarteErwerbbar( int id ) // prüft, ob die Karte erworben werden kann
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x12", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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 ShopKlient::getKartePreis( int id, bool testVersion ) // gibt den Preis einer Karte zurück
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x13", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&id, 4 );
        klient->sendeVerschlüsselt( (char*)&testVersion, 1 );
        int ret = 0;
        klient->getNachrichtVerschlüsselt( (char*)&ret, 4 );
        UNLOCK( &cs );
        return ret;
    }
    if( ret == 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;
}

bool ShopKlient::karteErwerben( int karteId, bool testVersion ) // Karte kaufen
{
    char ret = 0;
    LOCK( &cs );
    if( !verbunden )
        verbinde();
    if( !verbunden )
    {
        UNLOCK( &cs );
        return 0;
    }
    klient->sendeVerschlüsselt( "\x14", 1 );
    klient->getNachrichtVerschlüsselt( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeVerschlüsselt( (char*)&karteId, 4 );
        klient->sendeVerschlüsselt( (char*)&testVersion, 1 );
        klient->getNachrichtVerschlüsselt( &ret, 1 );
        if( ret == 1 )
        {
            UNLOCK( &cs );
            return 1;
        }
    }
    if( ret == 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;
}

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

bool ShopKlient::trenne() // trennt sich von dem Shop Server
{
    if( !verbunden )
        return 1;
    LOCK( &cs );
    klient->sendeVerschlüsselt( "\3", 1 );
    char serverReturn = 0;
    klient->getNachrichtVerschlüsselt( &serverReturn, 1 );
    klient->trenne();
    verbunden = 0;
    UNLOCK( &cs );
    return 1;
}

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

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

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

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