KSG-Client/KSGClient/Netzwerk/Klients/KartenK.cpp

#include "../KSGKlient.h"
#include "../KSGServer.h"
#include <Datei.h>
#include "../../Global/Variablen.h"
#include "../Keys.h"
#include <Globals.h>

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

// Destruktor
KartenKlient::~KartenKlient()
{
    cs.lock();
    if( verbunden )
        trenne();
    fehler = fehler->release();
    cs.unlock();
}

// nicht constant
bool KartenKlient::verbinde( unsigned short port, char *ip ) // verbindet ich mit dem Karten Server
{
    if( klient && verbunden && klient->getServerPort() == port && Text( ip ).istGleich( klient->getServerIp() ) )
        return 1;
    if( klient || verbunden )
        trenne();
    klient = new Klient();
    Framework::logLine( ( ( Text( "Zugeteilter Karten Server:" ) += ip ) += ":" ) += port );
    Framework::logLine( "Verbinung mit Karten Server wird hergestellt..." );
    int keyLen = 0;
    char *key = 0;
    Keys::getServerKey( &key, keyLen, Keys::KARTEN, Keys::SENDEN );
    klient->setSendeKey( key, keyLen );
    delete[] key;
    Keys::getServerKey( &key, keyLen, Keys::KARTEN, Keys::EMPFANGEN );
    klient->setEmpfangKey( key, keyLen );
    delete[] key;
    if( !klient->verbinde( (unsigned short)port, ip ) )
    {
        Framework::logLine( "ERROR: Server nicht erreichbar." );
        klient = klient->release();
        fehler->setText( "Fehler beim verbinden mit dem Editor Server." );
        return 0;
    }
    klient->sendeEncrypted( "\1", 1 );
    klient->sendeEncrypted( (char*)&klientId, 4 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtEncrypted( nachricht, län );
        fehler->setText( nachricht );
        Framework::logLine( Text( "ERROR: " ) += nachricht );
        delete[]nachricht;
        trenne();
        return 0;
    }
    if( ret == 1 )
    {
        char *sl = 0;
        char slLän = getSchlüssel( &sl );
        klient->setSendeKey( sl, slLän );
        klient->setEmpfangKey( sl, slLän );
        delete[] sl;
        verbunden = 1;
    }
    Framework::logLine( "Erfolgreich mit Karten Server verbunden." );
    return 1;
}

bool KartenKlient::downloadKarte( int id ) // läd die Karte herunter
{
    cs.lock();
    if( !verbunden )
    {
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( "\x6", 1 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeEncrypted( (char*)&id, 4 );
        klient->getNachrichtEncrypted( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            cs.unlock();
            return 0;
        }
        else if( ret == 1 )
        {
            int anz = 0;
            klient->getNachrichtEncrypted( (char*)&anz, 4 );
            for( int i = 0; i < anz; i++ )
            {
                char län = 0;
                klient->getNachrichtEncrypted( &län, 1 );
                if( !län )
                    continue;
                char *pf = new char[ län + 1 ];
                pf[ län ] = 0;
                klient->getNachrichtEncrypted( pf, län );
                __int64 größe = 0;
                klient->getNachrichtEncrypted( (char*)&größe, 8 );
                char *buffer = new char[ 2048 ];
                Text pfad = "data/tmp/Karten/";
                pfad += id;
                pfad += "/spiel";
                pfad += pf;
                delete[] pf;
                Datei d;
                d.setDatei( pfad );
                d.erstellen();
                d.open( Datei::Style::schreiben );
                while( größe )
                {
                    int l = größe >= 2048 ? 2048 : (int)größe;
                    klient->getNachricht( buffer, l );
                    d.schreibe( buffer, l );
                    größe -= l;
                }
                d.close();
                delete[] buffer;
            }
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtEncrypted( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtEncrypted( f, byte );
        fehler->setText( f );
        delete[] f;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool KartenKlient::downloadKarteTitel( int id ) // läd das Titelbild einer Karte herunter
{
    cs.lock();
    if( !verbunden )
    {
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( "\x8", 1 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeEncrypted( (char*)&id, 4 );
        klient->getNachrichtEncrypted( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            cs.unlock();
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtEncrypted( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/titel.ltdb";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.open( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.close();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtEncrypted( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtEncrypted( f, byte );
        fehler->setText( f );
        delete[] f;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool KartenKlient::downloadKarteBeschreibung( int id ) // läd die Beschreibung einer Karte herunter
{
    cs.lock();
    if( !verbunden )
    {
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( "\x9", 1 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeEncrypted( (char*)&id, 4 );
        klient->getNachrichtEncrypted( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            cs.unlock();
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtEncrypted( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/beschreibung.ksgs";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.open( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.close();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtEncrypted( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtEncrypted( f, byte );
        fehler->setText( f );
        delete[] f;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool KartenKlient::downloadKarteMinimap( int id ) // läd die Minimap einer Karte herunter
{
    cs.lock();
    if( !verbunden )
    {
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( "\xA", 1 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeEncrypted( (char*)&id, 4 );
        klient->getNachrichtEncrypted( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            cs.unlock();
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtEncrypted( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/minimap.ltdb";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.open( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.close();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtEncrypted( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtEncrypted( f, byte );
        fehler->setText( f );
        delete[] f;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool KartenKlient::downloadKarteLadebild( int id ) // läd das Ladebild einer Karte herunter
{
    cs.lock();
    if( !verbunden )
    {
        cs.unlock();
        return 0;
    }
    klient->sendeEncrypted( "\xB", 1 );
    char ret = 0;
    klient->getNachrichtEncrypted( &ret, 1 );
    if( ret == 1 )
    {
        klient->sendeEncrypted( (char*)&id, 4 );
        klient->getNachrichtEncrypted( &ret, 1 );
        if( ret == 2 )
        { // update
            nachLogin->zNachrichtenListe()->addNachricht( new Text( "Fehler" ), new Text( "Die Karte wird momentan aktualisiert." ), new Text( "Ok" ) );
            cs.unlock();
            return 0;
        }
        else if( ret == 1 )
        {
            __int64 größe = 0;
            klient->getNachrichtEncrypted( (char*)&größe, 8 );
            char *buffer = new char[ 2048 ];
            Text pfad = "data/tmp/Karten/";
            pfad += id;
            pfad += "/ladebild.ltdb";
            Datei d;
            d.setDatei( pfad );
            d.erstellen();
            d.open( Datei::Style::schreiben );
            while( größe )
            {
                int l = größe >= 2048 ? 2048 : (int)größe;
                klient->getNachricht( buffer, l );
                d.schreibe( buffer, l );
                größe -= l;
            }
            d.close();
            delete[] buffer;
        }
    }
    if( ret == 3 )
    {
        char byte = 0;
        klient->getNachrichtEncrypted( &byte, 1 );
        char *f = new char[ byte + 1 ];
        f[ byte ] = 0;
        klient->getNachrichtEncrypted( f, byte );
        fehler->setText( f );
        delete[] f;
        cs.unlock();
        return 0;
    }
    cs.unlock();
    return 1;
}

bool KartenKlient::keepAlive() // Erhält die Verbindung aufrecht
{
    if( !verbunden )
        return 0;
    char res = 0;
    if( !cs.tryLock() )
        return 1;
    Framework::logLine( "Verbindungstest zum Karten Server..." );
    bool ok = klient->sendeEncrypted( "\x5", 1 );
    ok &= klient->getNachrichtEncrypted( &res, 1 );
    cs.unlock();
    if( res != 1 || !ok )
    {
        Framework::logLine( "Verbindungsabbruch." );
        trenne();
        fehler->setText( "Verbindung unterbrochen: 'Keep Alive' nicht erfolgreich." );
    }
    else
        Framework::logLine( "Verbindung besteht." );
    return res == 1;
}

bool KartenKlient::trenne() // trennt sich von dem Editor Server
{
    if( !klient || !verbunden )
    {
        if( klient )
            klient = klient->release();
        return 1;
    }
    Framework::logLine( "Verbindung zum Karten Server wird getrennt..." );
    char serverReturn;
    klient->sendeEncrypted( "\4", 1 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    if( serverReturn == 3 )
    {
        char län = 0;
        klient->getNachrichtEncrypted( &län, 1 );
        char *nachricht = new char[ län + 1 ];
        nachricht[ län ] = 0;
        klient->getNachrichtEncrypted( nachricht, län );
        delete[]nachricht;
    }
    klient->sendeEncrypted( "\3", 1 );
    klient->getNachrichtEncrypted( &serverReturn, 1 );
    klient->trenne();
    klient = klient->release();
    return 1;
}

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

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

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

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