////////////////////////////////////////////////////////////////////////////////
//filename: enet.h
//copyright: Peter Soxberger
//autor: Peter Soxberger
//last change: 13.10.2008
//version: 0.9.11.6
//Describtion: Header für die enet.dll ( (c) Peter Soxberger)
//Note: Keine
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////Prototypen///////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/////////////////////////
//Verwaltungsfunktionen//
/////////////////////////
//------------------------------------------------------------------------------
//Name: void enet_set_warning(var mode)
//Funktion: Schaltet Warnungen ein/aus.
//Parameter: mode...1: Warnungen werden angezeigt; 2: Warnungen werden
// nicht angezeigt
//Rückgabe: keine
//Besonderheiten: Warnungen sind standartmäßig eingeschaltet!
//------------------------------------------------------------------------------
void enet_set_warning(var mode);
//------------------------------------------------------------------------------
//Name: var init_enet()
//Funktion: Initialisiert Enet. Muss vor dem benutzen jeder anderen Enet
// Funktion einmal erfolgreich ausgeführt werden.
//Parameter: keine
//Rückgabe: 1 bei erfolgreicher Initialisierung
// -1 wenn ein Fehler aufgetreten ist
//Besonderheiten: Nur einmal ausführen!
//------------------------------------------------------------------------------
var enet_init();
//------------------------------------------------------------------------------
//Name: void deinit_enet()
//Funktion: Macht die Initialisierung von Enet rückgängig.
//Parameter: keine
//Rückgabe: keine
//Besonderheiten: Enet sollte vorher initialisiert worden sein!
//------------------------------------------------------------------------------
void enet_deinit();
//------------------------------------------------------------------------------
//Name: var enet_init_server(var port, var max_player, STRING* password)
//Funktion: Erstellt einen Server, der den angegebenen Port benutzt.
//Parameter: port.........port der benutzt wird (2300-2400)
// max_player...maximale Spieleranzahl, die sich verbinden kann
// password.....Serverpasswort (max. 30 Zeichen)
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// 1 wenn alles geklappt hat
//Besonderheiten: Nur aufrufen, wenn noch kein Server initialisiert wurde!
//------------------------------------------------------------------------------
var enet_init_server(var port, var max_player, STRING* password);
//------------------------------------------------------------------------------
//Name: var enet_init_client(STRING* ip, var port, STRING* password)
//Funktion: Erstellt einen Client, und verbindet diesen über den
// angegebenen Port mit dem durch die IP angegebenen Server.
//Parameter: ip.........ip des Servers
// port.......port der für das Kommunizieren benutzt wird (2300-2400)
// password...Passwort des Servers (max. 30 Zeichen)
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// 1 wenn alles geklappt hat
//Besonderheiten: Nur aufrufen, wenn noch kein Client initialisiert wurde!
// Wenn die Verbindung zum Server nicht hergestellt werden kann,
// bzw. unerwartet unterbrochen wurde, so wird nach einem Timeout
// das clientseitige disconnected Event ausgeführt!
//------------------------------------------------------------------------------
var enet_init_client(STRING* ip, var port, STRING* password);
//------------------------------------------------------------------------------
//Name: void enet_disconnect_client(var ClientID)
//Funktion: Trennt die Verbindung mit den Clients mit der angegebenen ID
// und erzeugt ein Disconnectevent.
//Parameter: ClientID...ID des Clients, der entfernt werden soll
//Rückgabe: keine
//Besonderheiten: Kann nur vom Server ausgeführt werden!
// Darf nicht dafür benutzt werden, um im Client/Server Modus
// dem "eigenen" Client die Verbindung zu trennen!
//------------------------------------------------------------------------------
void enet_disconnect_client(var ClientID);
//------------------------------------------------------------------------------
//Name: void enet_destroy_host()
//Funktion: Beendet die Serverengine bzw. die Clientengine und trennt
// dadurch die Verbindung. Das Disconnect Event wird nicht erzeugt,
// es entsteht nur ein Timeout Disconnectevent.
//Parameter: keine
//Rückgabe: keine
//Besonderheiten: Wenn möglich sollte enet_disconnect_client verwendet werden.
// Diese Funktion sollte nur im Notfall verwendet werden!
//------------------------------------------------------------------------------
void enet_destroy_host();
//////////////////
//Pollfunktionen//
//////////////////
//------------------------------------------------------------------------------
//Name: void enet_server_poll()
//Funktion: Wenn man einen Server erstellt hat, muss diese Funktion
// solange in einer Schleife aufgerufen werden, wie der Server
// existiert!
//Parameter: keine
//Rückgabe: keine
//Besonderheiten: Kann nur von einem Server ausgeführt werden!
//------------------------------------------------------------------------------
void enet_server_poll();
//------------------------------------------------------------------------------
//Name: void enet_client_poll()
//Funktion: Wenn man einen Client erstellt hat, muss diese Funktion
// solange in einer Schleife aufgerufen werden, wie der Client
// existiert bzw. eine Verbindung zum Server hat!
//Parameter: keine
//Rückgabe: keine
//Besonderheiten: Kann nur von einem Client ausgeführt werden!
//------------------------------------------------------------------------------
void enet_client_poll();
//////////////////
//Infofunktionen//
//////////////////
//------------------------------------------------------------------------------
//Name: STRING* enet_get_version()
//Funktion: Gibt die Dll-Version zurück.
//Parameter: keine
//Rückgabe: String in dem die Dll-Version gespeichert ist (z.B. "0.9.8.2")
//Besonderheiten: keine
//------------------------------------------------------------------------------
STRING* enet_get_version();
//------------------------------------------------------------------------------
//Name: var get_clientid()
//Funktion: Gibt die eigene Clientid zurück.
//Parameter: keine
//Rückgabe: -1 wenn man noch keine ClientID hat
// ansonsten die eigene ClientID
//Besonderheiten: Kann nur von einem Client ausgeführt werden!
//------------------------------------------------------------------------------
var enet_get_clientid();
//------------------------------------------------------------------------------
//Name: var get_connection()
//Funktion: Gibt zurück ob ein Client initialisiert wurde, ein Server oder
// beides.
//Parameter: keine
//Rückgabe: 0 wenn man mit nichts Verbunden ist
// 1 wenn man Server ist
// 2 wenn man Client ist
// 3 wenn man Server/Client ist
//Besonderheiten: Diese Werte sagen nichts darüber aus, ob eine Verbindung
// hergestellt ist. Ledeglich welche hosts initilisiert wurden.
//------------------------------------------------------------------------------
var enet_get_connection();
//------------------------------------------------------------------------------
//Name: var enet_connected_clients()
//Funktion: Gibt die Anzahl der Verbundenen Clients zurück
//Parameter: keine
//Rückgabe: Anzahl der verbundenen Clients
//Besonderheiten: keine
//------------------------------------------------------------------------------
var enet_connected_clients();
//------------------------------------------------------------------------------
//Name: var enet_check_client(var clientid)
//Funktion: Prüft ob ein Client noch verbunden ist.
//Parameter: keine
//Rückgabe: -1 wenn keine Verbindung mehr besteht
// 1 wenn er noch verbunden ist
//Besonderheiten: Kann nur vom Server ausgeführt werden.
//------------------------------------------------------------------------------
var enet_check_client(clientid);
//------------------------------------------------------------------------------
//Name: var enet_get_myip(STRING* ip1,STRING* ip2,STRING* ip3,STRING* ip4)
//Funktion: Gibt 4 IP-Addressen des PCs zurück. Im Normalfall, hat ein
// PC nur eine IP enthalten in ip1.
//Parameter: ip1,ip2,ip3,ip4...enthält die IP-Addressen
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// 1 wenn alles funktioniert hat
//Besonderheiten: keine
//------------------------------------------------------------------------------
var enet_get_myip(STRING* ip1,STRING* ip2,STRING* ip3,STRING* ip4);
//------------------------------------------------------------------------------
//Name: var enet_get_clientip(var clientid, STRING* ip)
//Funktion: Gibt die IP-Addresse eines Clients zurück.
//Parameter: ip1...enthält die IP-Addresse
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// 1 wenn alles funktioniert hat
//Besonderheiten: Darf nur serverseitig ausgeführt werden!
//------------------------------------------------------------------------------
var enet_get_clientip(var clientid,STRING* ip);
//------------------------------------------------------------------------------
//Name: var enet_get_serverip(STRING* ip)
//Funktion: Gibt die IP-Addresse eines Clients zurück.
//Parameter: ip...enthält die IP-Addresse
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// 1 wenn alles funktioniert hat
//Besonderheiten: Darf nur clientseitig ausgeführt werden!
//------------------------------------------------------------------------------
var enet_get_serverip(STRING* ip);
//------------------------------------------------------------------------------
//Name: var enet_get_ping(var typ)
//Funktion: Gibt den aktuellen Ping (RTT=Round-trip-time) zurück.
//Parameter: type...1: letzte Roundtriptime (Ping)
// 2: durchschnittlicher Ping
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// Ping (in ms) wenn alles funktioniert hat
//Besonderheiten: keine
//------------------------------------------------------------------------------
var enet_get_ping(var typ);
//------------------------------------------------------------------------------
//Name: var enet_get_datatransfer(var typ)
//Funktion: Gibt Werte betreffend der Transferrate zurück.
//Parameter: type...1: gesendete Daten der letzten Sekunde (in Byte/s)
// 2: empfangene Daten der letzten Sekunde (in Bytes/s)
//Rückgabe: -1 wenn ein Fehler aufgetreten ist
// Ansonsten gewünschter Wert
//Besonderheiten: keine
//------------------------------------------------------------------------------
var enet_get_datatransfer(var typ);
///////////////////
//Eventfunktionen//
///////////////////
//------------------------------------------------------------------------------
//Name: var enet_set_event(var typ, STRING* funcname)
//Funktion: Weist einem Eventtyp eine Funktion zu. Die Funktionen werden
// mit folgenden Parametern aufgerufen:
// -sender: Client der das Event ausgelöst hat
// -msg: String der gesendet wurde
// (nur 1 Frame verfügbar!)
//Parameter: typ........Typ des Events
// 1: Client connected (nur Server)
// 2: Client disconnected (nur Server)
// 3: Connected (nur Client, msg enthält Level das
// am Server geladen ist)
// 4: Disconnected (nur Client)
// 5: Synchronizing complete (nur Client)
// 6: Synchronizing complete (nur Server), gibt die
// ClientID des Auslösers zurück
// 7: Entity removed (auf allen Rechnern außer dem,
// der das Event ausgelöst hat) übergibt den
// globalen Pointer (nur 1 Frame gültig)
// 8: Wrong Password (nur Client)
// 9-max_events(30): Userevents
// funcname...Name der Funktion, die bei dem jeweiligen Event
// ausgeführt werden soll.
//Rückgabe: -1 wenn typ eine ungültige Zahl ist
// 1 wenn alles geklappt hat
//Besonderheiten: Der Funktionsname darf nicht mehr als 29 Zeichen enthalten!
// Event 3,4&5 werden ohne Parameter aufgerufen, Event 1&2 nur
// mit dem sender Parameter!
//------------------------------------------------------------------------------
var enet_set_event(var typ,STRING* funcname);
//////////////////
//Sendfunktionen//
//////////////////
//------------------------------------------------------------------------------
//Name: void enet_send_var(STRING* varname, var reseiver)
//Funktion: Sendet eine Variable zu dem angegebnen Client, oder an alle
// verbundenen Clients wenn reseiver auf -1 gesetzt wird.
//Parameter: varname....Variablenname der Variable die gesendet werden soll
// reseiver...Clientid des Empfängers oder -1 wenn es an alle
// gesendet werden soll.
//Rückgabe: keine
//Besonderheiten: Variablenname darf nicht länger als 30 Zeichen sein. Je
// kürzer der Variablenname, um so weniger Byte.
//------------------------------------------------------------------------------
void enet_send_var(STRING* varname, var reseiver);
//------------------------------------------------------------------------------
//Name: void enet_send_array(STRING* arrayname, var from, var to, var reseiver)
//Funktion: Sendet einen Teil eines Arrays zu dem angegebnen Client, oder
// an alle verbundenen Clients wenn reseiver auf -1 gesetzt wird.
//Parameter: arrayname...Arrayname des array der gesendet werden soll
// from........erster Index der gesendet werden soll
// to..........letzter Index der gesendet werden soll
// reseiver....Clientid des Empfängers oder -1 wenn es an alle
// gesendet werden soll.
//Rückgabe: keine
//Besonderheiten: Arrayname darf nicht länger als 30 Zeichen sein. Je
// kürzer der Variablenname, um so weniger Byte.
// Es können maximal 40 Indexe versendet werden.
//------------------------------------------------------------------------------
void enet_send_array(STRING* arrayname, var from, var to, var reseiver);
//------------------------------------------------------------------------------
//Name: void enet_send_string(STRING* strname, var reseiver)
//Funktion: Sendet einen String zu dem angegebnen Client, oder an alle
// verbundenen Clients wenn reseiver auf -1 gesetzt wird.
//Parameter: strname....Stringname des Strings der gesendet werden soll
// reseiver...Clientid des Empfängers oder -1 wenn es an alle
// gesendet werden soll.
//Rückgabe: keine
//Besonderheiten: Der Stringname darf nicht länger als 30 Zeichen sein. Je
// kürzer der Stringname, um so weniger Byte.
// Der Stringinhalt darf nicht länger als 255 Zeichen sein!
//------------------------------------------------------------------------------
void enet_send_string(STRING* strname, var reseiver);
//------------------------------------------------------------------------------
//Name: void enet_send_event(var typ,STRING* msg,var reseiver)
//Funktion: Sendet ein userevent mit der angegebenen Nachricht an den
// angegebenen Empfänger. Die Funktion die unter diesem Typ
// gespeichert ist wird dann von dem Empfänger ausgeführt.
//Parameter: typ........Event das aufgerufen werden soll
// msg........Nachricht die gesendet werden soll
// (max. 255 Zeichen)
// reseiver...Clientid des Empfängers oder -1 wenn es an alle
// gesendet werden soll.
//Rückgabe: keine
//Besonderheiten: Es dürfen nur Userdefinierte Events sein, also ab 6-20.
// Kann nur von einem Client ausgeführt werden.
//------------------------------------------------------------------------------
void enet_send_event(var typ,STRING* msg,var reseiver);
//------------------------------------------------------------------------------
//Name: void enet_send_skills(var entity,var from,var to,var reseiver)
//Funktion: Sendet alle angegebenen Skills der globalen Entity. Es werden
// die durch from und to angegebenen Skills auch mit gesendet. Um
// nur einen Skill zu senden, müssen from und to gleich sein.
//Parameter: entity.....globaler Entitypointer
// from.......1. Skill der gesendet werden soll
// to.........letzter Skill der gesendet werden soll
//Rückgabe: keine
//Besonderheiten: Es können maximal 40 Skills gesendet werden.
//------------------------------------------------------------------------------
void enet_send_skills(var entity,var from,var to,var reseiver);
////////////////////
//Entityfunktionen//
////////////////////
//------------------------------------------------------------------------------
//Name: ENTITY* enet_ent_create(STRING* filename,VECTOR* position,
// STRING* funcname)
//Funktion: Erzeugt eine globale Entity auf allen verbundenen Clients. Die
// angegebene Funktion wird bei allen Clients ausgeführt. Für
// lokale Entities sollte das normale ent_create benutzt werden.
//Parameter: filename...Dateiname der zu erstellenden Entity
// position...Position an der die Entity erstellt werden soll
// funcname...Name der Funktion, die gestartet werden soll
//Rückgabe: lokaler Entitypointer
// 0 bei Fehler
//Besonderheiten: Der globale Pointer ist erst 1 Frame nach dem die angegebene
// Funktion gestartet wurde verfügbar (-> wait(1) in Funktion).
// Es muss eine Verbindung hergestellt sein, und bereits ein
// Level geladen worden sein.
// Um den globalen Pointer zu erhalten, muss enet_ent_globpointer
// benutzt werden.
// Darf nicht vor enet_synchronize ausgeführt werden (am Client)
// Die Anzahl der globalen Entities ist beschränkt!
//------------------------------------------------------------------------------
ENTITY* enet_ent_create(STRING* filename,VECTOR* position,STRING* funcname);
//------------------------------------------------------------------------------
//Name: void enet_ent_remove(var glob_pointer)
//Funktion: Entfernt eine globale Entity auf dem Server und allen
// verbundenen PCs.
//Parameter: glob_pointer...globaler Pointer der Entity
//Rückgabe: keine
//Besonderheiten: keine
//------------------------------------------------------------------------------
void enet_ent_remove(var glob_pointer);
//------------------------------------------------------------------------------
//Name: var enet_ent_globpointer(ENTITY* entity)
//Funktion: Gibt den globalen Pointer einer Entity zurück. Oder -1 falls
// diese keine globale Entity ist.
//Parameter: entity...lokaler Pointer der Entity
//Rückgabe: globaler Pointer auf die Entity
// -1 bei Fehler
//Besonderheiten: keine
//------------------------------------------------------------------------------
var enet_ent_globpointer(ENTITY* entity);
//------------------------------------------------------------------------------
//Name: ENTITY* enet_ent_locpointer(var globalpointer)
//Funktion: Gibt den lokalen Pointer einer Entity zurück. Oder 0 falls
// diese keine globale Entity ist.
//Parameter: globalpointer...globaler Pointer der Entity
//Rückgabe: lokaler Pointer auf die Entity
// 0 bei Fehler
//Besonderheiten: keine
//------------------------------------------------------------------------------
ENTITY* enet_ent_locpointer(var globalpointer);
//------------------------------------------------------------------------------
//Name: var enet_ent_creator(var globalpointer)
//Funktion: Gibt die ClientID des Erstellers dieser Entity zurück.
//Parameter: globalpointer...globaler Pointer der Entity
//Rückgabe: ClientID des Erstellers
// -1 bei Fehler
//Besonderheiten: keine
//------------------------------------------------------------------------------
var enet_ent_creator(var globalpointer);
//------------------------------------------------------------------------------
//Name: void enet_ent_synchronize()
//Funktion: Synchronisiert alle Entities mit dem Server. D.h. es werden
// alle globalen Entities an der Position erstellt, die sie am
// Server aktuell haben.
// Wenn das Synchronisieren erfolgreich war, wird das 5. Event
// ausgelöst.
//Parameter: keine
//Rückgabe: keine
//Besonderheiten: Skills,Flags,... werden NICHT übernommen.
// Diese Funktion darf nicht öfter als 1 mal pro Verbindung
// verwendet werden.
// Sie verbraucht sehr viel KB/s.
//------------------------------------------------------------------------------
void enet_ent_synchronize();
//------------------------------------------------------------------------------
//Name: void enet_ent_freeglobs()
//Funktion: Löscht alle globalen Pointer auf allen Rechnern. Dadurch wird
// ein Levelwechsel ermöglicht.
//Parameter: keine
//Rückgabe: keine
//Besonderheiten: Darf nur vom Server ausgeführt werden.
//------------------------------------------------------------------------------
void enet_ent_freeglobs();
//////////////////////////////
//Verschlüsselungsfunktionen//
//////////////////////////////
//------------------------------------------------------------------------------
//Name: void encrypt_string(char string[],unsigned long key[])
//Funktion: Verschlüsselt einen String.
//Parameter: string...String der verschlüsselt werden soll
// key......Schlüssel mit dem verschlüsselt werden soll
//Rückgabe: keine
//Besonderheiten: Wird zum Verschlüsseln des Datenverkehrs benutzt.
//------------------------------------------------------------------------------
void encrypt_string(char* str,unsigned long* key);
//------------------------------------------------------------------------------
//Name: void decrypt_string(char string[],unsigned long key[])
//Funktion: Entschlüsselt einen String.
//Parameter: string...String der entschlüsselt werden soll
// key......Schlüssel mit dem entschlüsselt werden soll
//Rückgabe: keine
//Besonderheiten: Wird zum Entschlüsseln des Datenverkehrs genutzt.
//------------------------------------------------------------------------------
void decrypt_string(char* str,unsigned long* key);
