#pragma once #include namespace Framework { class Text; } namespace Network { class Klient; } namespace KSGClient { // Enthält die Daten eines Spielers zu einem vergangenen Spiel struct SpielHistorieSpielerDaten { protected: int ref; // Reference Counter public: Framework::Text *name; // Der Sichtabe Name des Spielers int punkte; // Die Punkte, die der Spieler in dem Spiel gewonnen / verloren hat Framework::Text *status; // Der Status des Spielers in dem Spiel (verloren, gewonnen, nicht anwesend, beobachter, unentschieden) int farbe; // Die Farbe des Spielers // Erhöht den Reference Counter um 1 un gibt this zurück virtual SpielHistorieSpielerDaten *getThis() = 0; // 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 virtual SpielHistorieSpielerDaten *release() = 0; }; // Enthält die Datein eines Teams zu einem vergangenen Spiel struct SpielHistorieTeamDaten { protected: int ref; // Reference Counter public: Framework::Text *name; // Der Sichtabe Name des Teams int sAnzahl; // Die Anzahl der Spieler im Team Framework::Text *status; // Der Status des Teams (verloren, gewonnen, beobachter, unentschieden) int farbe; // Die Farbe des Teams Framework::RCArray< SpielHistorieSpielerDaten > *spieler; // Eine Liste mit den Spielerdaten zu den Spielern aus dem Team // Erhöht den Reference Counter um 1 un gibt this zurück virtual SpielHistorieTeamDaten *getThis() = 0; // 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 virtual SpielHistorieTeamDaten *release() = 0; }; // Enthält Daten zu einem vergangenen Spiel struct SpielHistorieDaten { protected: int ref; // Reference Counter public: int id; // Die Id des vergangenen Spiels int karteId; // Die Id der Karte, welche gespielt wurde Framework::Text *spiel; // Der Name des Spiels, welches gespielt wurde Framework::Text *karte; // Der Name der Karte, welche gespielt wurde Framework::Text *datum; // Der Zeitpunkt, an dem das Spiel Statfand Framework::Text *status; // Der Status des Spielers, über welchen die Statistik angefragt wurde Framework::Text *dauer; // Die Dater des Spiels Framework::Text *spielStatus; // Der Status des Spiels (beginnt, läuft, abgebrochen, fehlerhaft, beendet, unbewertet) Framework::Text *gewinner; // Der Name des Gewinners int sAnzahl; // TODO: Ermitteln wozu dieser Wert gut ist Framework::RCArray< SpielHistorieTeamDaten > *teams; // Die Daten der Teams des Spiels // Erhöht den Reference Counter um 1 un gibt this zurück virtual SpielHistorieDaten *getThis() = 0; // 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 virtual SpielHistorieDaten *release() = 0; }; // Enthält eine Liste von Spiel Daten aus vergangenen Spielen struct SpielHistorieListe { protected: int ref; // Reference Counter public: Framework::RCArray< SpielHistorieDaten > *spiele; // Eine Liste mit den Daten zu vergangenen Spielen // Erhöht den Reference Counter um 1 un gibt this zurück virtual SpielHistorieListe *getThis() = 0; // 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 virtual SpielHistorieListe *release() = 0; }; // Wird benutzt, um die Verbindung mit den Servern aufrecht zu erhalten. Bei einem Verbindungsabbruch wird der Client automatisch abgemeldet class ErhaltungServerClient { }; // Wird benutzt, um aktualisierte Spieldateien herunterzuladen class PatchServerClient { }; // Wird verwendet um News Oberflächen abzufragen (KSG Script Seiten) class NewsServerClient { }; // Wird benutzt, um Accounts zu erstellen zu ändern oder zu löschen class RegisterServerClient { public: // verbindet ich mit dem Register Server // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst virtual bool verbinde() = 0; // Sendet eine Anfrage auf Erstellung eines neuen Accounts. Ein neuer Account kann erst verwendet werden, wenn ein Link in der Bestätigungsemail angeklickt wurde. // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts // eMail: Die EMail Adresse an die die bestätigungs EMail gesendet werden soll // jahr: Das Jahr des Geburtsdatums // monat: Der Monat des Geburtstages // tag: Der Tag des Geburtstages virtual bool accountErstellen( const char *name, const char *pass, const char *geheim, const char *eMail, unsigned short jahr, char monat, char tag ) = 0; // Sendet eine Anfrage auf Löschung eines neuen Accounts. Ein neuer Account kann erst gelöscht werden, wenn ein Link in der Bestätigungsemail angeklickt wurde. // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts virtual bool accountLöschen( const char *name, const char *pass, const char *geheim ) = 0; // Ändert das Passwort eines Accounts // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts // nPass: Das neue Passwort des Accounts virtual bool passwortÄndern( const char *name, const char *pass, const char *geheim, const char *nPass ) = 0; // Ändert die EMail Adresse eines Accounts // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts // nEMail: Die neue EMail Adresse virtual bool eMailÄndern( const char *name, const char *pass, const char *geheim, const char *nEMail ) = 0; // Ändert das Geheimnis eines Accounts // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts // nGeheim: Das neue Geheimnis virtual bool geheimnisÄndern( const char *name, const char *pass, const char *geheim, const char *nGeheim ) = 0; // Sendet eine Anfrage auf Name Vergessen. Der Name wird an die angegebene EMail Adresse gesendet // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts virtual bool nameVergessen( const char *pass, const char *geheim ) = 0; // Sendet eine Anfrage auf Passwort Vergessen. Es wird ein Link an die angegebene Email Adresse gesendet, über den ein neues Passwort vergeben werden kann // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // geheim: Das Geheimnis des Accounts virtual bool passwortVergessen( const char *name, const char *geheim ) = 0; // Sendet eine Anfrage auf Geheimnis Vergessen. Das Geheimnis wird an die angegebene EMail Adresse gesendet // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts virtual bool geheimnisVergessen( const char *name, const char *pass ) = 0; // Sendet eine Anfrage auf EMail Vergessen. Die EMail Adresse wird direkt vom Server zurückgegeben // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // name: Der Login Name des Accounts // pass: Das Login Passwort des Accounts // geheim: Das Geheimnis des Accounts // eMail: Ein Zeiger auf eine Zeichenkette. Diese wird bei einem Erfolgreichen Aufruf auf die EMail Adresse gesetzt und muss manuell mit delete[] gelöscht werden virtual bool eMailVergessen( const char *name, const char *pass, const char *geheim, char **eMail ) = 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 virtual bool keepAlive() = 0; // 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 virtual bool trenne() = 0; // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst virtual bool istVerbunden() const = 0; // gibt den Letzten Fehlertext zuück // sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist virtual char *getLetzterFehler() const = 0; // Erhöht den Reference Counter um 1 un gibt this zurück virtual RegisterServerClient *getThis() = 0; // 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 virtual RegisterServerClient *release() = 0; }; // Wird verwendet um sich einzuloggen oder auszuloggen class LoginServerClient { public: // verbindet sich mit dem zugewiesenen Login Server // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst virtual bool verbinde() = 0; // Der Client wird beim Serversystem in einen Account eingeloggt // gibt bei Erfolg 1 zurück // Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden virtual int login( const char *name, const char *pass ) = 0; // Diese Funktion wird in der Zukunft mal implementiert werden. Mit dem Geheimnis des Accounts können so andere Clients, welche bereits in dem Account eingeloggt werden rausgeschmissen werden. virtual bool kick( const char *geheim ) = 0; // logt den Account aus // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst // sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist virtual bool logout() = 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 virtual bool keepAlive() = 0; // 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 virtual bool trenne() = 0; // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst virtual bool istVerbunden() const = 0; // Gibt die Id des Accounts zurück, in den sich der Client eingeloggt hat. // sollte erst aufgerufen werden, nachdem ein erfolgreicher Aufruf von login erfolg ist virtual int getAccountId() const = 0; // gibt den Letzten Fehlertext zuück // sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist virtual char *getLetzterFehler() const = 0; // Erhöht den Reference Counter um 1 un gibt this zurück virtual LoginServerClient *getThis() = 0; // 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 virtual LoginServerClient *release() = 0; }; // Wird verwendet um informationen über Accounts abzufragen // Kann nur von eingeloggten Clients verwendet werden class InformationServerClient { public: // nicht constant virtual bool verbinde() = 0; // verbindet ich mit dem Informaion Server virtual bool getInformationText( Text *txt, int *typ ) = 0; // fragt nach Informationstext virtual bool istSpielErlaubt( int spielId ) = 0; // fragt, ob das entsprechende Spiel vom Server gesperrt wurde virtual bool istKarteErlaubt( int karteId ) = 0; // fragt, ob die entsprechende Karte vom Server gesperrt wurde virtual int getKarteId( char *name ) = 0; // fragt nach der Id einer Karte virtual int getSpielId( char *name ) = 0; // fragt nach der id eines Spiels virtual Text *getSpielerName( int accountId ) = 0; // fragt nach dem Namen eines Accounts virtual bool getSpielStatistik( int accountId, int spielId, Array< int > *werte ) = 0; // fragt nach der Spiel Statistik eines Accounts virtual Text *getKarteName( int karteId ) = 0; // fragt nach dem Namen einer Karte virtual Text *getSpielName( int spielId ) = 0; // fragt nach dem Namen einer Spielart virtual Text *getChatroomName( int chatroomId ) = 0; // fragt nach dem Namen eines Chatrooms virtual int getSpielId( int karteId ) = 0; // fragt zu welcher Spielart die Karte gehört virtual int getAccountId( char *name ) = 0; // gibt die Id des Accounts zurück virtual int getChatroomId( char *name ) = 0; // gibt die Id des Chatrooms zurück virtual int getGruppenKarteId( int gruppenId ) = 0; // gibt die karten Id der gruppe zurück virtual bool getGruppeSpielerHinzufügen( int gruppeId ) = 0; // gibt die Spieler hinzufügen Funktion der Gruppe zurück virtual int getGruppeAdminId( int gruppeId ) = 0; // gibt den Gruppen Administrator zurück virtual int getSpielerPunkte( int accountId, int spielId ) = 0; // gibt die Punkte eines Spielers zurück virtual Array< int > *getAccountSpielArtListe() = 0; // gibt eine Liste mit gekauften Spielen zurück virtual int getSpielVersion( int spielId ) = 0; // gibt die neuste Version eines Spiels zurück virtual int getKupfer() = 0; // gibt das Kupfer des Accounts zurück virtual int getDateiGruppeIdVonSpiel( int spielId ) = 0; // Gibt die Dateigruppe eines Spieles zurück virtual Text *getDateiGruppePfad( int dgId ) = 0; // Gibt den Dateigruppen Pfad zurück virtual Array< int > *getAccountKarteListe( int spielId ) = 0; // gibt eine Liste mit gekauften Karten zurück virtual int getDateiGruppeIdVonPfad( char *pfad ) = 0; // Gibt die Dateigruppe eines Pfades zurück virtual int getDateiGruppeVersion( int dg ) = 0; // gibt die neuste Version einer Dateigruppe zurück virtual int 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 ) = 0; // sucht nach Spielern virtual bool getSpielerAktivität( int accId, RCArray< Text > *datum, Array< double > *stOnline, Array< double > *stGespielt, Array< int > *anzSpiele, Array< int > *anzGewonnen ) = 0; // ermittelt die aktivität eines Spielers virtual int getAccountKarteSpiele( int account, int karte ) = 0; // Gibt zurück, wie oft ein Spieler eine Karte schon gespielt hat virtual int getAccountKarteSpieleGewonnen( int account, int karte ) = 0; // Gibt zurück, wie oft ein Spieler eine Karte schon gewonnen hat virtual bool hatAccountKarte( int account, int karte ) = 0; // Gibt zurück, ob ein Spieler die Karte im Besitz hat virtual bool hatAccountSpiel( int account, int spiel ) = 0; // Gibt zurück, ob ein Spieler ein Spiel im Besitz hat virtual Array< int > *getAccountKarteGespieltListe( int account, int spielId ) = 0; // gibt eine Liste mit Karten zurück, die von einem Spieler bereits gespielt wurden virtual Array< int > *getAccountSpielGespieltListe( int account ) = 0; // gibt eine Liste mit Spielen zurück, die von einem Spieler bereits gespielt wurden virtual bool getSpielPartnerListe( int account, Array< int > *spieler, Array< int > *karten, Array< int > *anzahl ) = 0; // Gibt eine Liste von Spiel Partnern eines Spielers zurück virtual bool getStatistikListe( int account, int *seite, int *maxSeite, char sortSpalte, char rückwärts, RCArray< Array< int > > *werte, RCArray< Text > *namen ) = 0; // Gibt eine Liste mit Spiel Statistiken zurück // Gibt eine Liste mit den Daten der letzten 20 Spiele von einem Account zurück // account: Die Id des Accounts virtual SpielHistorieListe *getSpielHistorieDaten( int account ) = 0; // Erzeugt einen Client zu dem Historie Server, welcher die Aufzeichnungen und Statistiken eines Bestimmten Spiels verwaltet // spielId: Die id des Spiels // Gibt bei misserfolg 0 zurück virtual HistorieServerClient *createHistorieServerClient( int spielId ) = 0; // sucht nach dem Historie Server von einem Spiel // Prüft, ob der Account bestimmte Berechtigungen besitzt // recht: Die Id der Berechtigungen virtual bool hatRecht( int recht ) = 0; // Prüft ob Berechtigung vorhanden // Gibt eine Liste mit Karten zurück, die einen bestimmten Text im Namen enthalten und bestimmt sortiert ist // filter: Die Zeichenkette, die im Namen Auftreten soll // sortSpalte: Der Index der Spalte, nach der sortiert werden soll // absteigend: 1:=absteigende sortierung,0:=aufsteigende Sortierung // kId: Eine Liste, welche nach einem erfolgreichen Aufruf die Ids der Karten enthält // kName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Karten enthält // sName: Eine Liste, welche nach einem erfolgreichen Aufruf die Namen der Spiele der Karten enthält // kupfer: Eine Liste, welche nach einem erfolgreichen Aufruf die Preise der Karten in Kupfer // verkauft: Eine Liste, welche nach einem erfolgreichen Aufruf die Anzahl der Verkäufe der Karten enthält // maxSpieler: Eine Liste, welche nach einem erfolgreichen Aufruf die Maximalen Spieleranzahlen der Karten enthält virtual int getKartenListe( char *filter, char sortSpalte, char absteigend, Framework::Array< int > *kId, Framework::RCArray< Framework::Text > *kName, Framework::RCArray< Framework::Text > *sName, Framework::Array< int > *kupfer, Framework::Array< int > *verkauft, Framework::Array< int > *maxSpieler ) = 0; // Erzeugt einen Client zu dem Editor Server von der Karte mit einer bestimmten Id // karteId: Die Id der Karte // Gibt bei misserfolg 0 zurück virtual EditorServerClient *createEditorServerClient( int karteId ) = 0; // Erzeugt einen Client zu dem Karten Server von der Karte mit einer bestimmten Id // karteId: Die Id der Karte // Gibt bei misserfolg 0 zurück virtual KartenServerClient *createKartenServerClient( int karteId ) = 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 virtual bool keepAlive() = 0; // Erhält die Verbindung aufrecht // 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 virtual bool trenne() = 0; // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst virtual bool istVerbunden() const = 0; // gibt den Letzten Fehlertext zuück // sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist virtual char *getLetzterFehler() const = 0; // Erhöht den Reference Counter um 1 un gibt this zurück virtual InformationServerClient *getThis() = 0; // 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 virtual InformationServerClient *release() = 0; }; // Wird verwendet um Chat nachrichten zu senden oder zu empfangen. Das Serversystem sendet außerdem einiege Mitteilungen über den Chat (z.B. Gefundene Spiele, Gruppeneinladungen ...) // Kann nur von eingeloggten Clients verwendet werden class ChatServerClient { }; // Wird verwendet um Spiele oder Karten zu kaufen // Kann nur von eingeloggten Clients verwendet werden class ShopServerClient { }; // Wird verwendet um sich für Spiele anzumelden // Kann nur von eingeloggten Clients verwendet werden class AnmeldungServerClient { }; // Wird verwendet um die aktuellen versionen der Karten vor dem Spiel herunterzuladen // Kann nur von eingeloggten Clients verwendet werden class KartenServerClient { }; // Wird zum Online Spielen verwendet // Kann nur von eingeloggten Clients verwendet werden class SpielServerClient { }; // Wird verwendet um Statistiken und Aufzeichnungen von vergangenen Spielen abzufragen // Kann nur von eingeloggten Clients verwendet werden class HistorieServerClient { }; // Wird verwendet um Minigame Bestscores abzufragen und Minigame Spielaufzeichnungen zu laden // Kann nur von eingeloggten Clients verwendet werden class MinigameServerClient { }; // Wird verwendet um Karten für Spiele zu erstellen // Kann nur von eingeloggten Clients verwendet werden class EditorServerClient { }; // Wird verwendet um Eine Verbindung mit dem Serversystem herzustellen class MainServerClient { public: // Meldet den neuen Client beim Serversystem an. Durch diesen Vorgang erhält der Client eine Id und den Port und die Ip Addresse des Main Servers virtual bool registerSSL( Framework::Text *ip, unsigned short port ) = 0; // Verbindet den Client mit dem Server // Wird automatisch aufgerufen, falls eine Methode aufgerufen wird, die eine Verbindung erfordert. In diesem Fall wird die Verbindung auch automatisch wieder getrennt. virtual bool connect() = 0; // Erzeugt einen Erhaltungs Server Client // Gibt bei misserfolg 0 zurück virtual ErhaltungServerClient *createErhaltungServerClient() = 0; // Erzeugt einen Patch Server Client // Gibt bei misserfolg 0 zurück virtual PatchServerClient *createPatchServerClient() = 0; // Erzeugt einen News Server Client // Gibt bei misserfolg 0 zurück virtual NewsServerClient *createNewsServerClient() = 0; // Erzeugt einen Register Server Client // Gibt bei misserfolg 0 zurück virtual RegisterServerClient *createRegisterServerClient() = 0; // Erzeugt einen Login Server Client // Gibt bei misserfolg 0 zurück virtual LoginServerClient *createLoginServerClient() = 0; // Erzeugt einen Information Server Client // Gibt bei misserfolg 0 zurück virtual InformationServerClient *createInformationServerClient() = 0; // Erzeugt einen Chat Server Client // Gibt bei misserfolg 0 zurück virtual ChatServerClient *createChatServerClient() = 0; // Erzeugt einen Shop Server Client // Gibt bei misserfolg 0 zurück virtual ShopServerClient *createShopServerClient() = 0; // Erzeugt einen Anmeldung Server Client // Gibt bei misserfolg 0 zurück virtual AnmeldungServerClient *createAnmeldungServerClient() = 0; // Erzeugt einen Minigame Server Client // Gibt bei misserfolg 0 zurück virtual MinigameServerClient *createMinigameServerClient() = 0; // Trennt die Verbindung zum Server. Muss nur aufgerufen werden, wenn vorher manuell connect aufgerufen wurde virtual bool disconnect() = 0; // Meldet den Client vom Server ab. Alle zuvor von diesem Client erzeugten Clients werden durch diesen Vorgang unbrauchbar virtual bool unregister() = 0; // Gibt die dem Client zugewiesene Id zurück. // sollte erst nach dem Aufruf von registerSSL verwendet werden. virtual int getClientId() const = 0; // Gibt die Ip Adresse des dem Client zugewiesenen Main Servers zurück. // sollte erst nach dem Aufruf von registerSSL verwendet werden. virtual Framework::Text *getServerIp() const = 0; // Gibt den Port des dem Client zugewiesenen Main Servers zurück. // sollte erst nach dem Aufruf von registerSSL verwendet werden. virtual unsigned short getServerPort() const = 0; }; extern "C" { // Einstiegspunkte in die Bibliothek // Erzeugt einen neuen Client beim Serversystem. // registerSSL Methode muss aufgerufen werden um den Client beim Serversystem anzumelden MainServerClient *createMainServerClient(); // Erzeugt einen Client, der bereits beim Serversystem angemeldet ist // ip: Die Ip des Main Servers für angemeldete Clients // port: Der Port des Main Servers für angemeldete Clients // klientId: Die Id die der Client durch das Anmelden bekommen hat MainServerClient *createMainServerClient( char *ip, unsigned short port, int klientId ); } }