A real Networksolution for GS A6/A7

////////////////////////////////////////////////////////////////////////////////
//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);