MinigameClient hinzugefügt

Include/KSGNetwork.h

@@ -1064,12 +1064,9 @@ namespace KSGClient
         //  mName: Der Name des Minigames
         //  oName: Die Optionen mit denen gespielt wurde
         //  score: Der Erreichte Score
-        //  Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war, 2 wenn ein Game Capture hochgeladen werden muss
-        virtual int reportEndOfGame( char *mName, char *oName, int score ) = 0;
-        // Lädt ein Game Capture hoch
-        //  zCapture: Ein Zeiger auf die Capture Datei
-        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
-        virtual bool uploadGameCapture( Framework::Datei *zCapture ) = 0;
+        //  zCapture: Ein Zeiger auf eine Datei mit der Spielaufzeichnung
+        //  Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war
+        virtual bool reportEndOfGame( char *mName, char *oName, int score, Framework::Datei *zCapture ) = 0;
         // Lädt ein Game Capture herunter und speichert sie unter data/tmp/minigames/wb.mgc
         //  mName: Der Name des Minigames
         //  oName: Die Optionen

KSGNetwork/KSGNetwork.vcxproj

@@ -158,6 +158,7 @@
     <ClInclude Include="LoginClient.h" />
     <ClInclude Include="Main.cpp" />
     <ClInclude Include="MainClient.h" />
+    <ClInclude Include="MinigameClient.h" />
     <ClInclude Include="NewsClient.h" />
     <ClInclude Include="PatchClient.h" />
     <ClInclude Include="RegisterServer.h" />
@@ -174,6 +175,7 @@
     <ClCompile Include="Keys.cpp" />
     <ClCompile Include="LoginClient.cpp" />
     <ClCompile Include="MainClient.cpp" />
+    <ClCompile Include="MinigameClient.cpp" />
     <ClCompile Include="NewsClient.cpp" />
     <ClCompile Include="PatchClient.cpp" />
     <ClCompile Include="RegisterServer.cpp" />

KSGNetwork/KSGNetwork.vcxproj.filters

@@ -63,6 +63,9 @@
     <ClInclude Include="HistorieClient.h">
       <Filter>Headerdateien</Filter>
     </ClInclude>
+    <ClInclude Include="MinigameClient.h">
+      <Filter>Headerdateien</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MainClient.cpp">
@@ -107,5 +110,8 @@
     <ClCompile Include="HistorieClient.cpp">
       <Filter>Quelldateien</Filter>
     </ClCompile>
+    <ClCompile Include="MinigameClient.cpp">
+      <Filter>Quelldateien</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

KSGNetwork/Keys.cpp

@@ -15,8 +15,9 @@ void Keys::getServerKey( char **key, int &length, Keys::Server sTyp, Keys::Key k
     { 186, 186, 179, 126, 216, 207, 123, 154, 168, 149, 51, 221, 6, 193, 160, 141, 164, 126, 44, 242 }, // Register
     { 218, 226, 231, 216, 68, 63, 132, 155, 49, 235, 239, 0, 19, 23, 116, 244, 235, 21, 189, 53 }, // Shop
     { 253, 234, 211, 132, 121, 230, 95, 145, 201, 13, 43, 77, 153, 223, 253, 69, 234, 43, 52, 99 }, // Spiel
-    {}, // Patch
-    { 207, 242, 142, 161, 148, 107, 131, 33, 172, 68, 91, 169, 81, 106, 69, 131, 207, 56, 166, 248 } // Erhaltung
+    { 102, 139, 140, 143, 52, 52, 194, 167, 97, 106, 23, 72, 170, 121, 213, 178, 28, 28, 124, 185 }, // Patch
+    { 207, 242, 142, 161, 148, 107, 131, 33, 172, 68, 91, 169, 81, 106, 69, 131, 207, 56, 166, 248 }, // Erhaltung
+    { 88, 103, 192, 232, 69, 54, 57, 3, 239, 138, 234, 172, 126, 72, 81, 55, 205, 97, 59, 255 } // Minigame
     };
     length = 20;
     *key = new char[ 20 ];

KSGNetwork/Keys.h

@@ -19,7 +19,8 @@ public:
         SHOP = 10,
         SPIEL = 11,
         PATCH = 12,
-        ERHALTUNG = 13
+        ERHALTUNG = 13,
+        MINIGAME = 14
     };
 
     // Keytypen

KSGNetwork/LoginClient.cpp

@@ -269,7 +269,9 @@ bool LoginClient::logout()
 //  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
 bool LoginClient::keepAlive() 
 {
-    cs.lock();
+    char res = 0;
+    if( !cs.tryLock() )
+        return 1;
     if( !k )
     {
         err = "Der Client ist nicht verbunden.";

KSGNetwork/MainClient.cpp

@@ -9,6 +9,7 @@
 #include "ShopClient.h"
 #include "ChatClient.h"
 #include "AnmeldungClient.h"
+#include "MinigameClient.h"
 
 using namespace KSGClient;
 
@@ -585,7 +586,52 @@ AnmeldungServerClient *MainClient::createAnmeldungServerClient()
 //  Gibt bei misserfolg 0 zurück
 MinigameServerClient *MainClient::createMinigameServerClient()
 {
-
+    cs.lock();
+    bool connected = k != 0;
+    if( !connected )
+        connect();
+    if( !k )
+    {
+        err = "no connection to minigame Server";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\6\xA", 2 );
+    char byte = 0;
+    k->getNachrichtEncrypted( &byte, 1 );
+    if( byte == 2 )
+    {
+        unsigned char lsIp[ 4 ];
+        k->getNachrichtEncrypted( (char *)lsIp, 4 );
+        unsigned short lsPort = 0;
+        k->getNachrichtEncrypted( (char*)&lsPort, 2 );
+        Framework::Text ipT;
+        ipT += (int)lsIp[ 0 ];
+        ipT += ".";
+        ipT += (int)lsIp[ 1 ];
+        ipT += ".";
+        ipT += (int)lsIp[ 2 ];
+        ipT += ".";
+        ipT += (int)lsIp[ 3 ];
+        if( !connected )
+            disconnect();
+        cs.unlock();
+        return new MinigameClient( cId, lsPort, ipT, key, keyLen );
+    }
+    else if( byte == 3 )
+    {
+        k->getNachrichtEncrypted( &byte, 1 );
+        char *f = new char[ byte + 1 ];
+        f[ byte ] = 0;
+        k->getNachrichtEncrypted( f, byte );
+        err = "error while requesting ShopServer server returned: ";
+        err += f;
+        delete[]f;
+    }
+    if( !connected )
+        disconnect();
+    cs.unlock();
+    return 0;
 }
 
 // Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde

KSGNetwork/MinigameClient.cpp

@@ -0,0 +1,494 @@
+#include "MinigameClient.h"
+#include <Klient.h>
+#include "Keys.h"
+#include <Datei.h>
+
+using namespace KSGClient;
+
+// Inhalt der MinigameClient Klasse
+
+// Konstruktor
+MinigameClient::MinigameClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen )
+{
+    ref = 1;
+    this->ip = ip;
+    this->port = port;
+    cId = klientId;
+    k = 0;
+    this->key = new char[ keyLen ];
+    memcpy( this->key, key, keyLen );
+    this->keyLen = keyLen;
+}
+
+// Destruktor
+MinigameClient::~MinigameClient()
+{
+    trenne( 1 );
+    delete[] key;
+}
+
+// verbindet sich mit dem zugewiesenen Minigame Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+bool MinigameClient::verbinde()
+{
+    cs.lock();
+    if( k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    k = new Network::Klient();
+    int l = 0;
+    char *key;
+    Keys::getServerKey( &key, l, Keys::MINIGAME, Keys::SENDEN );
+    k->setSendeKey( key, l );
+    delete[] key;
+    Keys::getServerKey( &key, l, Keys::MINIGAME, Keys::EMPFANGEN );
+    k->setEmpfangKey( key, l );
+    delete[] key;
+    if( k->verbinde( port, ip ) )
+    {
+        if( k->sendeEncrypted( "\1", 1 ) )
+        {
+            k->sendeEncrypted( (char*)&cId, 4 );
+            char serverReturn = 0;
+            k->getNachrichtEncrypted( &serverReturn, 1 );
+            if( serverReturn == 3 )
+            {
+                char byte = 0;
+                k->getNachrichtEncrypted( &byte, 1 );
+                char *f = new char[ byte + 1 ];
+                f[ byte ] = 0;
+                k->getNachrichtEncrypted( f, byte );
+                err = "error while identifying client Minigame Server returned: ";
+                err += f;
+                delete[]f;
+                trenne( 0 );
+                cs.unlock();
+                return 0;
+            }
+            k->setSendeKey( this->key, this->keyLen );
+            k->setEmpfangKey( this->key, this->keyLen );
+        }
+        else
+        {
+            err = "network error while sending to Minigame Server";
+            k = k->release();
+            cs.unlock();
+            return 0;
+        }
+    }
+    else
+    {
+        err = "network error while connecting to Minigame Server";
+        k = k->release();
+        cs.unlock();
+        return 0;
+    }
+    cs.unlock();
+    return 1;
+}
+
+// Ermittelt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
+//  mName: Der Name des Minigames
+//  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen
+//  Gibt die Anzahl der Optionen zurück
+int MinigameClient::getMinigameOptionList( char *mName, Framework::RCArray< Framework::Text > *zOptionList )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x6", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        char l = (char)textLength( mName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( mName, l );
+        int anz = 0;
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
+        for( int i = 0; i < anz; i++ )
+        {
+            k->getNachrichtEncrypted( &l, 1 );
+            char *option = new char[ l + 1 ];
+            option[ l ] = 0;
+            k->getNachrichtEncrypted( option, l );
+            zOptionList->add( new Text( option ) );
+            delete[] option;
+        }
+        cs.unlock();
+        return anz;
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *fehler = new char[ l + 1 ];
+        fehler[ l ] = 0;
+        k->getNachrichtEncrypted( fehler, l );
+        err = fehler;
+        delete[] fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Ermittelt eine Liste mit den Weltbesten Scores zurück
+//  mName: Der Name des Minigames
+//  zScore: Enthält nach erfolgreichem Aufruf eine Liste mit Scores
+//  zPlayerList: Enthält nach erfolgreichem Aufruf eine Liste mit angezeigten Account Namen, die die Scores erreicht haben.
+//  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen, die beim erreichen der Scores aktiv waren.
+//  Gibt die Anzahl der Bestscores zurück
+int MinigameClient::getMinigameBestscoreList( char *mName, Framework::Array< int > *zScore, Framework::RCArray< Framework::Text > *zPlayerList, Framework::RCArray< Framework::Text > *zOptionList )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x7", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        char l = (char)textLength( mName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( mName, l );
+        int anz = 0;
+        k->getNachrichtEncrypted( (char*)&anz, 4 );
+        for( int i = 0; i < anz; i++ )
+        {
+            int score = 0;
+            k->getNachrichtEncrypted( (char*)&score, 4 );
+            zScore->add( score );
+            k->getNachrichtEncrypted( &l, 1 );
+            char *player = new char[ l + 1 ];
+            player[ l ] = 0;
+            k->getNachrichtEncrypted( player, l );
+            zPlayerList->add( new Text( player ) );
+            delete[] player;
+            k->getNachrichtEncrypted( &l, 1 );
+            char *option = new char[ l + 1 ];
+            option[ l ] = 0;
+            k->getNachrichtEncrypted( option, l );
+            zOptionList->add( new Text( option ) );
+            delete[] option;
+        }
+        cs.unlock();
+        return anz;
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *fehler = new char[ l + 1 ];
+        fehler[ l ] = 0;
+        k->getNachrichtEncrypted( fehler, l );
+        err = fehler;
+        delete[] fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Gibt den Welt bestscore zu einem Bestimmten Minigame mit bestimmten Optionen zurück.
+//  mName: Der Name des Minigames
+//  oName: Die Optionen
+//  zPlayer: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
+int MinigameClient::getMinigameOptionBestscore( char *mName, char *oName, Framework::Text *zPlayer )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x8", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        char l = (char)textLength( mName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( mName, l );
+        l = (char)textLength( oName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( oName, l );
+        int score = 0;
+        k->getNachrichtEncrypted( (char*)&score, 4 );
+        k->getNachrichtEncrypted( &l, 1 );
+        char *player = new char[ l + 1 ];
+        player[ l ] = 0;
+        k->getNachrichtEncrypted( player, l );
+        zPlayer->setText( player );
+        delete[] player;
+        cs.unlock();
+        return score;
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *fehler = new char[ l + 1 ];
+        fehler[ l ] = 0;
+        k->getNachrichtEncrypted( fehler, l );
+        err = fehler;
+        delete[] fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Meldet die Beendigung eines Minigames
+//  mName: Der Name des Minigames
+//  oName: Die Optionen mit denen gespielt wurde
+//  score: Der Erreichte Score
+//  zCapture: Ein Zeiger auf eine Datei mit der Spielaufzeichnung
+//  Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war
+bool MinigameClient::reportEndOfGame( char *mName, char *oName, int score, Framework::Datei *zCapture )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\x9", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        char l = (char)textLength( mName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( mName, l );
+        l = (char)textLength( oName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( oName, l );
+        k->sendeEncrypted( (char*)&score, 4 );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            int size = (int)zCapture->getSize();
+            if( !zCapture->istOffen() )
+                zCapture->open( Datei::Style::lesen );
+            k->sendeEncrypted( (char*)&size, 4 );
+            char *buffer = new char[ 2048 ];
+            while( size > 0 )
+            {
+                int l = size > 2048 ? 2048 : size;
+                zCapture->lese( buffer, l );
+                k->sendeEncrypted( buffer, l );
+                size -= l;
+            }
+            delete[] buffer;
+            zCapture->close();
+            cs.unlock();
+            return 1;
+        }
+        else if( ret == 0 )
+        {
+            cs.unlock();
+            return 1;
+        }
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *fehler = new char[ l + 1 ];
+        fehler[ l ] = 0;
+        k->getNachrichtEncrypted( fehler, l );
+        err = fehler;
+        delete[] fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Lädt ein Game Capture herunter und speichert sie unter data/tmp/minigames/wb.mgc
+//  mName: Der Name des Minigames
+//  oName: Die Optionen
+//  Gibt die Datei mit dem Capture zurück
+Framework::Datei *MinigameClient::downloadGameCapture( char *mName, char *oName )
+{
+    cs.lock();
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    k->sendeEncrypted( "\xA", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 1 )
+    {
+        char l = (char)textLength( mName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( mName, l );
+        l = (char)textLength( oName );
+        k->sendeEncrypted( &l, 1 );
+        k->sendeEncrypted( oName, l );
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 1 )
+        {
+            Datei *capture = new Datei();
+            capture->setDatei( "data/tmp/minigames/wb.mgc" );
+            capture->erstellen();
+            capture->open( Datei::Style::schreiben );
+            int size = 0;
+            k->getNachrichtEncrypted( (char*)&size, 4 );
+            char *buffer = new char[ 2048 ];
+            while( size > 0 )
+            {
+                int l = size > 2048 ? 2048 : size;
+                k->getNachrichtEncrypted( buffer, l );
+                capture->schreibe( buffer, l );
+                size -= l;
+            }
+            delete[] buffer;
+            capture->close();
+            cs.unlock();
+            return capture;
+        }
+        err = "Unbekannter Fehler";
+        cs.unlock();
+        return 0;
+    }
+    if( ret == 3 )
+    {
+        char l = 0;
+        k->getNachrichtEncrypted( &l, 1 );
+        char *fehler = new char[ l + 1 ];
+        fehler[ l ] = 0;
+        k->getNachrichtEncrypted( fehler, l );
+        err = fehler;
+        delete[] fehler;
+        cs.unlock();
+        return 0;
+    }
+    err = "Unbekannter Fehler";
+    cs.unlock();
+    return 0;
+}
+
+// Erhält die Verbindung aufrecht
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
+bool MinigameClient::keepAlive()
+{
+    char res = 0;
+    if( !cs.tryLock() )
+        return 1;
+    if( !k )
+    {
+        err = "Der Client ist nicht verbunden.";
+        cs.unlock();
+        return 0;
+    }
+    bool ok = k->sendeEncrypted( "\x5", 1 );
+    ok &= k->getNachrichtEncrypted( &res, 1 );
+    cs.unlock();
+    if( res != 1 || !ok )
+        trenne( 0 );
+    return res == 1;
+}
+
+// Trennt die Verbindung zum Server
+//  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+//  Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
+bool MinigameClient::trenne( bool abmelden )
+{
+    cs.lock();
+    verbinde();
+    if( !k )
+    {
+        cs.unlock();
+        return 1;
+    }
+    if( abmelden )
+    {
+        k->sendeEncrypted( "\4", 1 );
+        char ret = 0;
+        k->getNachrichtEncrypted( &ret, 1 );
+        if( ret == 3 )
+        { // error
+            k->getNachrichtEncrypted( &ret, 1 );
+            char *msg = new char[ ret + 1 ];
+            msg[ ret ] = 0;
+            if( ret )
+                k->getNachrichtEncrypted( msg, ret );
+            err = "error while unregister Client Minigame Server returned: ";
+            err += msg;
+            delete[] msg;
+        }
+    }
+    k->sendeEncrypted( "\3", 1 );
+    char ret = 0;
+    k->getNachrichtEncrypted( &ret, 1 );
+    if( ret == 3 )
+    { // error
+        k->getNachrichtEncrypted( &ret, 1 );
+        char *msg = new char[ ret + 1 ];
+        msg[ ret ] = 0;
+        if( ret )
+            k->getNachrichtEncrypted( msg, ret );
+        err = "error while trenne Minigame Server returned: ";
+        err += msg;
+        delete[] msg;
+    }
+    k->trenne();
+    k = k->release();
+    cs.unlock();
+    return 1;
+}
+
+// Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+bool MinigameClient::istVerbunden() const
+{
+    return k != 0;
+}
+
+// gibt den Letzten Fehlertext zuück
+//  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+char *MinigameClient::getLetzterFehler() const
+{
+    return err;
+}
+
+// Erhöht den Reference Counter um 1 un gibt this zurück
+MinigameServerClient *MinigameClient::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 
+MinigameServerClient *MinigameClient::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

KSGNetwork/MinigameClient.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "../Include/KSGNetwork.h"
+#include <Critical.h>
+
+namespace KSGClient
+{
+    // Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden
+    //  Kann nur von eingeloggten Clients verwendet werden
+    class MinigameClient : public MinigameServerClient
+    {
+    private:
+        int ref;
+        Framework::Text ip;
+        unsigned short port;
+        int cId;
+        Network::Klient *k;
+        char *key;
+        unsigned char keyLen;
+        Framework::Critical cs;
+        Framework::Text err;
+
+    public:
+        // Konstruktor
+        MinigameClient( int klientId, unsigned short port, char *ip, char *key, unsigned char keyLen );
+        // Destruktor
+        ~MinigameClient();
+        // verbindet sich mit dem zugewiesenen Minigame Server
+        //  Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
+        bool verbinde() override;
+        // Ermittelt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
+        //  mName: Der Name des Minigames
+        //  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen
+        //  Gibt die Anzahl der Optionen zurück
+        int getMinigameOptionList( char *mName, Framework::RCArray< Framework::Text > *zOptionList ) override;
+        // Ermittelt eine Liste mit den Weltbesten Scores zurück
+        //  mName: Der Name des Minigames
+        //  zScore: Enthält nach erfolgreichem Aufruf eine Liste mit Scores
+        //  zPlayerList: Enthält nach erfolgreichem Aufruf eine Liste mit angezeigten Account Namen, die die Scores erreicht haben.
+        //  zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen, die beim erreichen der Scores aktiv waren.
+        //  Gibt die Anzahl der Bestscores zurück
+        int getMinigameBestscoreList( char *mName, Framework::Array< int > *zScore, Framework::RCArray< Framework::Text > *zPlayerList, Framework::RCArray< Framework::Text > *zOptionList ) override;
+        // Gibt den Welt bestscore zu einem Bestimmten Minigame mit bestimmten Optionen zurück.
+        //  mName: Der Name des Minigames
+        //  oName: Die Optionen
+        //  zPlayer: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
+        int getMinigameOptionBestscore( char *mName, char *oName, Framework::Text *zPlayer ) override;
+        // Meldet die Beendigung eines Minigames
+        //  mName: Der Name des Minigames
+        //  oName: Die Optionen mit denen gespielt wurde
+        //  score: Der Erreichte Score
+        //  zCapture: Ein Zeiger auf eine Datei mit der Spielaufzeichnung
+        //  Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war
+        bool reportEndOfGame( char *mName, char *oName, int score, Framework::Datei *zCapture ) override;
+        // Lädt ein Game Capture herunter und speichert sie unter data/tmp/minigames/wb.mgc
+        //  mName: Der Name des Minigames
+        //  oName: Die Optionen
+        //  Gibt die Datei mit dem Capture zurück
+        Framework::Datei *downloadGameCapture( char *mName, char *oName ) override;
+        // 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 keepAlive() override;
+        // 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 trenne( bool abmelden ) override;
+        // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
+        bool istVerbunden() const override;
+        // gibt den Letzten Fehlertext zuück
+        //  sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
+        char *getLetzterFehler() const override;
+        // Erhöht den Reference Counter um 1 un gibt this zurück
+        MinigameServerClient *getThis() override;
+        // 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 
+        MinigameServerClient *release() override;
+    };
+}