KSGNetwork/KSGNetwork/SpielClient.cpp

#include "SpielClient.h"
#include <Klient.h>
#include "Keys.h"

using namespace KSGClient;

// Inhalt der SpielClient Klasse

// Konstruktor
SpielClient::SpielClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
{
    ref = 1;
    this->ip = ip;
    this->port = port;
    cId = klientId;
    senden = 0;
    empfangen = 0;
    this->key = new char[ keyLen ];
    memcpy( this->key, key, keyLen );
    this->keyLen = keyLen;
}

// Destruktor
SpielClient::~SpielClient()
{
    trenne();
    delete[] key;
}

// verbindet sich mit dem zugewiesenen Karten Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::verbinde()
{
    cs.lock();
    if( senden )
    {
        cs.unlock();
        return 1;
    }
    if( !senden )
        senden = new Network::Klient();
    int keyLen = 0;
    char *key = 0;
    Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::SENDEN );
    senden->setSendeKey( key, keyLen );
    delete[] key;
    Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::EMPFANGEN );
    senden->setEmpfangKey( key, keyLen );
    delete[] key;
    if( senden->verbinde( port, ip ) )
    {
        if( senden->sendeEncrypted( "\1", 1 ) )
        {
            char serverReturn = 0;
            senden->sendeEncrypted( (char*)&cId, 4 );
            char ret = 0;
            senden->getNachrichtEncrypted( &ret, 1 );
            if( ret != 1 )
            {
                if( ret == 3 )
                {
                    char byte = 0;
                    senden->getNachrichtEncrypted( &byte, 1 );
                    char *f = new char[ byte + 1 ];
                    f[ byte ] = 0;
                    senden->getNachrichtEncrypted( f, byte );
                    err = f;
                    delete[]f;
                }
                senden->sendeEncrypted( "\3", 1 );
                senden->getNachrichtEncrypted( &serverReturn, 1 );
                senden->trenne();
                senden = senden->release();
                err = "Server akzeptiert den Klient nicht.";
                cs.unlock();
                return 0;
            }
            senden->setSendeKey( this->key, this->keyLen );
            senden->setEmpfangKey( this->key, this->keyLen );
            if( !empfangen )
                empfangen = new Network::Klient();
            int keyLen = 0;
            char *key = 0;
            Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::SENDEN );
            empfangen->setSendeKey( key, keyLen );
            delete[] key;
            Keys::getServerKey( &key, keyLen, Keys::SPIEL, Keys::EMPFANGEN );
            empfangen->setEmpfangKey( key, keyLen );
            delete[] key;
            if( empfangen->verbinde( senden->getServerPort(), senden->getServerIp() ) )
            {
                empfangen->sendeEncrypted( "\1", 1 );
                empfangen->sendeEncrypted( (char*)&cId, 4 );
                char res = 0;
                empfangen->getNachrichtEncrypted( &res, 1 );
                if( res == 3 )
                {
                    char län = 0;
                    empfangen->getNachrichtEncrypted( &län, 1 );
                    char *nachricht = new char[ län + 1 ];
                    nachricht[ län ] = 0;
                    empfangen->getNachrichtEncrypted( nachricht, län );
                    err = nachricht;
                    delete[] nachricht;
                }
                if( res == 1 )
                {
                    empfangen->setSendeKey( this->key, this->keyLen );
                    empfangen->setEmpfangKey( this->key, this->keyLen );
                }
                else if( res != 0 )
                {
                    err = "Fehler beim Verbinden mit dem Spiel Server.";
                    senden->sendeEncrypted( "\3", 1 );
                    char serverReturn = 0;
                    senden->getNachrichtEncrypted( &serverReturn, 1 );
                    senden->trenne();
                    senden = senden->release();
                    empfangen->trenne();
                    empfangen = empfangen->release();
                    return 0;
                }
                cs.unlock();
                return 1;
            }
            else
            {
                empfangen = empfangen->release();
                senden->sendeEncrypted( "\3", 1 );
                char serverReturn = 0;
                senden->getNachrichtEncrypted( &serverReturn, 1 );
                senden->trenne();
                senden = senden->release();
                err = "Der dir zugewiesene Spiel Server kann dir keine Nachrichten senden.";
                cs.unlock();
                return 0;
            }
        }
        else
        {
            senden->trenne();
            senden = senden->release();
            err = "Der dir zugewiesene Spiel Server hat die Verbindung abgebrochen. Bitte versuche es Später erneut.";
            cs.unlock();
            return 0;
        }
    }
    else
    {
        err = "Der dir zugewiesene Spiel Server antwortet nicht. Bitte versuche es Später erneut.";
        senden = senden->release();
        cs.unlock();
        return 0;
    }
    err = "Unbekannter Fehler";
    cs.unlock();
    return 0;
}

// Betritt das Vorgeschlagene Spiel
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::spielErstelltAnnehmen()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\4", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim annehmen des Spiels.";
    cs.unlock();
    return ret == 1;
}

// Lehnt das Vorgeschlagene Spiel ab
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::spielErstelltAblehnen()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\5", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim ablehnen des Spiels.";
    cs.unlock();
    return ret == 1;
}

// Wechselt zu einem bestimmten Team
//  team: Die Id des teams
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::spielErstelltTeamWechseln( int team )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\6", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( !ret )
    {
        err = "Fehler beim wechseln des Teams.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( (char*)&team, 4 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim wechseln des Teams.";
    cs.unlock();
    return ret == 1;
}

// Bestätigt die Teamauswahl so dass das Spiel früher beginnen kann
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::spielErstelltTeamFertig()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\xE", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim setzen der Bereitschaft.";
    cs.unlock();
    return ret == 1;
}

// sendet eine Chat Nachricht an die mitglieder des erstellten Spiels
//  nachricht: Die Nachricht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::spielErstelltChatNachricht( char *nachricht )
{
    char län = textLength( nachricht );
    if( !län )
        return 1;
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\7", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( !ret )
    {
        err = "Fehler beim senden der Chat Nachricht.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( &län, 1 );
    senden->sendeEncrypted( nachricht, län );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim senden der Chat Nachricht.";
    cs.unlock();
    return ret == 1;
}

// Teilt dem Server mit, dass der Client bereit ist das Spiel zu laden
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::bereitZumLaden()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\x9", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim setzen der Bereitschaft.";
    cs.unlock();
    return ret == 1;
}

// Teilt dem Server mit, zu wie viel Prozent der Client das Spiel geladen hat
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::setLadenProzent( int prozent )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\xC", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret )
    {
        senden->sendeEncrypted( (char*)&prozent, 4 );
        senden->getNachrichtEncrypted( &ret, 1 );
    }
    if( ret != 1 )
        err = "Fehler beim setzen des Fortschritts.";
    cs.unlock();
    return ret == 1;
}

// Teilt dem Server mit, dass das Spiel fertig geladen wurde
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::bereitZumSpiel()
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\xA", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret != 1 )
        err = "Fehler beim setzen der Bereitschaft.";
    cs.unlock();
    return ret == 1;
}

// Sendet während des Spiels eine Nachricht an den Server
//  län: Die Länge der Nachricht
//  bytes: Ein Zeiger auf die Nachricht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::spielNachricht( short län, char *bytes )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    senden->sendeEncrypted( "\xB", 1 );
    senden->sende( (char*)&län, 2 );
    senden->sende( bytes, län );
    cs.unlock();
    return 1;
}

// Sendet während der Statistik eine Nachricht an den Server
//  län: Die Länge der Nachricht
//  bytes: Ein Zeiger auf die Nachricht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
bool SpielClient::statistikNachricht( short län, char *bytes )
{
    cs.lock();
    if( !senden )
    {
        err = "Der Client ist nicht verbunden.";
        cs.unlock();
        return 0;
    }
    char ret = 0;
    senden->sendeEncrypted( "\xD", 1 );
    senden->getNachrichtEncrypted( &ret, 1 );
    if( ret )
    {
        senden->sendeEncrypted( (char*)&län, 2 );
        senden->sendeEncrypted( bytes, län );
        senden->getNachrichtEncrypted( &ret, 1 );
    }
    if( ret != 1 )
        err = "Fehler beim setzen der Statistik Nachricht.";
    cs.unlock();
    return ret == 1;
}

// Wartet auf eine Nachricht vom Spiel Server.
//  Gibt bei Erfolg 1 zurück, 0 sonnst
//  nachricht: Eine Referenz auf die Struktur, in der die Nachricht gespeichert werden soll
bool SpielClient::getNextMessage( SpielServerNachricht &nachricht )
{
    do
    {
        if( !empfangen->getNachrichtEncrypted( &nachricht.type, 1 ) )
        {
            return 0;
        }
        switch( nachricht.type )
        {
        case 0: // verbindung getrennt
            trenne();
            break;
        case 1: // verbleibende Zeit
            empfangen->getNachrichtEncrypted( &nachricht.sekunden, 1 );
            break;
        case 2: // SpielErstellt abbruch
            if( 1 )
            {
                char län = 0;
                empfangen->getNachrichtEncrypted( &län, 1 );
                char *grund = new char[ län + 1 ];
                grund[ län ] = 0;
                empfangen->getNachrichtEncrypted( grund, län );
                nachricht.message = grund;
                delete[] grund;
            }
            break;
        case 3: // Fehler
            if( 1 )
            {
                char länge = 0;
                empfangen->getNachrichtEncrypted( &länge, 1 );
                char *txt = new char[ länge + 1 ];
                txt[ länge ] = 0;
                empfangen->getNachrichtEncrypted( txt, länge );
                nachricht.message = txt;
                delete[]txt;
            }
            break;
        case 4: // zurück in Warteschlange
            empfangen->getNachrichtEncrypted( &nachricht.stunden, 1 );
            empfangen->getNachrichtEncrypted( &nachricht.minuten, 1 );
            empfangen->getNachrichtEncrypted( &nachricht.sekunden, 1 );
            break;
        case 6: // SpielErstellt Initialisierung
            empfangen->getNachrichtEncrypted( (char*)&nachricht.sts->spielerAnzahl, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.sts->teamAnzahl, 4 );
            for( int i = 0; i < nachricht.sts->spielerAnzahl; i++ )
            {
                int farbe = 0;
                empfangen->getNachrichtEncrypted( (char*)&farbe, 4 );
                nachricht.sts->spielerFarbe->set( farbe, i );
            }
            for( int i = 0; i < nachricht.sts->teamAnzahl; i++ )
            {
                int farbe = 0;
                empfangen->getNachrichtEncrypted( (char*)&farbe, 4 );
                nachricht.sts->teamFarbe->set( farbe, i );
            }
            for( int i = 0; i < nachricht.sts->teamAnzahl; i++ )
            {
                char län = 0;
                empfangen->getNachrichtEncrypted( &län, 1 );
                char *name = new char[ län + 1 ];
                name[ län ] = 0;
                if( län )
                    empfangen->getNachrichtEncrypted( name, län );
                Text *tmp = new Text( name );
                delete[] name;
                nachricht.sts->teamName->set( tmp, i );
            }
            for( int i = 0; i < nachricht.sts->teamAnzahl; i++ )
            {
                int größe = 0;
                empfangen->getNachrichtEncrypted( (char*)&größe, 4 );
                nachricht.sts->teamGröße->set( größe, i );
            }
            break;
        case 7: // SpielErstellt Spieler hinzugefügt
            empfangen->getNachrichtEncrypted( (char*)&nachricht.accountId, 4 );
            break;
        case 8: // SpielErstellt Spieler entfernt
            empfangen->getNachrichtEncrypted( (char*)&nachricht.accountId, 4 );
            break;
        case 9: // SpielErstellt Spieler wechselt Team
            empfangen->getNachrichtEncrypted( (char*)&nachricht.accountId, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.spielerNummer, 4 );
            break;
        case 0xA: // SpielErstellt Chat Nachricht
            if( 1 )
            {
                char län = 0;
                empfangen->getNachrichtEncrypted( &län, 1 );
                char *txt = new char[ län + 1 ];
                txt[ län ] = 0;
                if( län )
                    empfangen->getNachrichtEncrypted( txt, län );
                nachricht.message = txt;
                delete[] txt;
            }
            break;
        case 0xB: // Spiel gefunden
            empfangen->getNachrichtEncrypted( (char*)&nachricht.karteId, 4 );
            break;
        case 0xD: // Spiel Laden Spieler hinzufügen
            empfangen->getNachrichtEncrypted( (char*)&nachricht.accountId, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.spielerNummer, 4 );
            break;
        case 0xE: // Spiel Laden Spieler Prozent
            empfangen->getNachrichtEncrypted( (char*)&nachricht.accountId, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.prozent, 4 );
            break;
        case 0xF: // Spiel Laden Spieler Ping
            empfangen->getNachrichtEncrypted( (char*)&nachricht.accountId, 4 );
            empfangen->getNachrichtEncrypted( (char*)&nachricht.ping, 4 );
            break;
        case 0x10: // ping
            empfangen->sendeEncrypted( "\1", 1 );
            break;
        case 0x12: // Spiel Nachricht
            empfangen->getNachricht( (char*)&nachricht.län, 2 );
            nachricht.data = new char[ nachricht.län ];
            empfangen->getNachricht( nachricht.data, nachricht.län );
            break;
        case 0x13: // Statistik Nachricht
            empfangen->getNachrichtEncrypted( (char*)&nachricht.län, 2 );
            nachricht.data = new char[ nachricht.län ];
            empfangen->getNachrichtEncrypted( nachricht.data, nachricht.län );
            break;
        case 0x14: // ping
            empfangen->sendeEncrypted( "\1", 1 );
            break;
        }
    } while( nachricht.type == 0x10 || nachricht.type == 0x14 );
}

// Erhält die Verbindung aufrecht
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
bool SpielClient::keepAlive()
{
    if( !senden )
        return 0;
    char res = 0;
    if( !cs.tryLock() )
        return 1;
    bool ok = senden->sendeEncrypted( "\xF", 1 );
    ok &= senden->getNachrichtEncrypted( &res, 1 );
    cs.unlock();
    if( res != 1 || !ok )
    {
        err = "Die Verbindung zum Spiel Server ist abgebrochen.";
        trenne();
        return 0;
    }
    return res == 1;
}

// Trennt die Verbindung zum Server
//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
bool SpielClient::trenne()
{
    cs.lock();
    if( !senden )
    {
        cs.unlock();
        return 1;
    }
    senden->sendeEncrypted( "\3", 1 );
    char serverReturn = 0;
    senden->getNachrichtEncrypted( &serverReturn, 1 );
    senden->trenne();
    senden = senden->release();
    empfangen->trenne();
    empfangen = empfangen->release();
    cs.unlock();
    return 1;
}

// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
bool SpielClient::istVerbunden() const
{
    return senden != 0;
}

// gibt den Letzten Fehlertext zuück
//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
char *SpielClient::getLetzterFehler() const
{
    return err;
}

// Erhöht den Reference Counter um 1 un gibt this zurück
SpielServerClient *SpielClient::getThis()
{
    ref++;
    return this;
}

// Verringert den Reference Counter um 1 und gibt 0 zurück.
//  Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst 
SpielServerClient *SpielClient::release()
{
    if( !--ref )
        delete this;
    return 0;
}