diff --git a/SimuClient/ClientSocket.cpp b/SimuClient/ClientSocket.cpp new file mode 100644 index 0000000..692af7d --- /dev/null +++ b/SimuClient/ClientSocket.cpp @@ -0,0 +1,104 @@ +/* + * ClientSocket 0.2 + * (c) Robert Uhl 2009 + * Datei: ClientSocket.cpp + * Inhalt: ClientSocket Implementierung + */ + +#include "ClientSocket.h" + +//#define DEBUG DEBUG // Debugging an/aus(auskommentieren!) + +/* + * PUBLIC Methoden + */ + +// Konstruktor, der den Typ des Sockets übergeben bekommt +ClientSocket::ClientSocket(const int iType) : p_iType(iType), p_iSocket(-1), p_bVerbunden(false) { + p_iSocket = socket(AF_INET, p_iType, 0); // Socket anlegen + + if (p_iSocket == -1) { + std::cerr << "--> Socket konnte nicht angelegt werden!" << std::endl; + } +} + +// Destruktor +ClientSocket::~ClientSocket(void) { + if (p_bVerbunden) { + Disconnect(); + } +} + +/* + * PRIVATE Methoden + */ + +// Verbindung zum Server aufnehmen +// Rückgabe: true wenn Verbindung erfolgreich aufgebaut +bool ClientSocket::Connect(const std::string& sServer, const unsigned short iPort) { + struct sockaddr_in strAdresse; + struct in_addr strInAdresse; + struct hostent* strHost; + + if (p_iSocket == -1) { + std::cerr << "--> Connect(): Socket wurde nicht angelegt!" << std::endl; + return false; + } + + if (p_bVerbunden) { + std::cerr << "--> Connect(): Achtung, noch verbunden! Keine neue Verbindung angelegt!" << std::endl; + return false; + } + + // Domainnamen in IP auflösen + strHost = gethostbyname(sServer.c_str()); +#ifdef DEBUG + std::cout << "Host: " << strHost->h_name << std::endl; + std::cout << "IP: " << inet_ntoa( **(struct in_addr**) strHost->h_addr_list) << std::endl; + std::cout << "Port: " << iPort << std::endl; +#endif + // IP-Adresse für connect() erzeugen + strInAdresse = **(struct in_addr**) strHost->h_addr_list; + strAdresse.sin_family = AF_INET; + strAdresse.sin_port = htons(iPort); + strAdresse.sin_addr = strInAdresse; + + // Verbindung aufbauen + if (connect(p_iSocket, (struct sockaddr*) &strAdresse, sizeof(strAdresse)) == -1) { + std::cerr << "--> connect() nicht erfolgreich!" << std::endl; + return false; + } else { + p_bVerbunden = true; + return true; + } +} + +// Verbindung zum Server abbauen +void ClientSocket::Disconnect(void) { + if (close(p_iSocket) == -1) { + std::cerr << "--> Disconnect(): Konnte die Verbindung nicht schliessen!" << std::endl; + } else { + p_bVerbunden = false; + } +} + +// Sendet etwas über das Socket +bool ClientSocket::Send(const void* vDaten, ssize_t data_len) { + if (p_iSocket == -1) { + std::cerr << "--> Send(): Socket wurde nicht angelegt!" << std::endl; + return false; + } else if (!p_bVerbunden) { + std::cerr << "--> Send(): Noch keine Verbindung aufgebaut!" << std::endl; + return false; + } + + // Senden + if (send(p_iSocket, vDaten, data_len, 0) != data_len) { + std::cerr << "--> Send(): Es konnte nicht alles gesendet werden!" << std::endl; + return false; + } + + return true; +} + +// eof \ No newline at end of file diff --git a/SimuClient/ClientSocket.h b/SimuClient/ClientSocket.h new file mode 100644 index 0000000..00d08b0 --- /dev/null +++ b/SimuClient/ClientSocket.h @@ -0,0 +1,39 @@ +/* + * ClientSocket 0.2 + * (c) Robert Uhl 2009 + * Datei: ClientSocket.h + * Inhalt: ClientSocket sendet Daten an einen Server + */ + +#ifndef CLIENTSOCKET_H +#define CLIENTSOCKET_H + +#include +#include +#include +#include +#include +#include +#include + + +class ClientSocket { + public: + // Konstruktor/Destruktor + ClientSocket(const int iType); // als Type z.B. SOCK_STREAM für TCP + ~ClientSocket(void); + + // Methoden + bool Connect(const std::string& sServer, const unsigned short iPort);// auf Server mit Namen/IP sServer verbinden mit Portangabe + void Disconnect(void); + bool Send(const void* vDaten, ssize_t data_len); + + private: + // Variablen + const int p_iType; // Socket-Type + int p_iSocket; // Socket-Nummer + bool p_bVerbunden; // true = verbunden +}; + +#endif // CLIENTSOCKET_H +// eof \ No newline at end of file diff --git a/SimuClient/SimuClient.cpp b/SimuClient/SimuClient.cpp new file mode 100644 index 0000000..78e8538 --- /dev/null +++ b/SimuClient/SimuClient.cpp @@ -0,0 +1,506 @@ +/* + * SimuClient für MacOS/Linux (Praktikum Informatik 2, WS 2009/10 RWTH Aachen) + * Version 0.5 + * von Robert Uhl, 2009 - 2010 + * Vielen Dank an den Lehrstuhl EECS, RWTH Aachen, für den Zugang zum Quellcode + * des SimuClient für Windows. + * Datei: SimuClient.cpp + * Inhalt: Implementierung des SimuClient für MacOS und Linux + */ + +#include "SimuClient.h" +#include +#include +#include +#include +#include +#include +#include "ClientSocket.h" + +//#define DEBUG DEBUG // Debugging an/aus(auskommentieren!) + +// Variablen der Bibliothek +static ClientSocket* p_cGrafikServerVerbindung = NULL; // Verbindung zum Grafikserver +static string p_sServer; // Servername +static unsigned int p_iPort = 0; // Serverport +static bool p_bInitialisiert = false; // Simulationsdarstellung initialisiert? true = ja +static int p_iXSize = 0; // X Größe des Verkehrsplanes +static int p_iYSize = 0; // Y Größe des Verkehrsplanes +static map p_mWege; // Map aller erzeugten Wege; map ermöglicht find() + + +/* + * Hilfsfunktionen + */ + +// sendet eine Fehlermeldung an den Server, wenn verbunden. +// Diese wird dort als Error-MsgBox angezeigt. +static void vSendeNachricht(const string& sNachricht) { + ostringstream ssNachricht; + + // noch nicht initialisiert? - muss so bleiben sonst endlose Rekursion !!! + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return; + } + + // Fehlermeldung an den GrafikServer schicken + ssNachricht << "message " << sNachricht << "#"; + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { +#ifdef DEBUG + cerr << "Fehlermeldung gesendet: " << ssNachricht.str() << endl; +#endif + //Sleep(100); + return; + } else { + cerr << "--> Fehler: Senden der Fehlermeldung fehlgeschlagen!" << endl; + cerr << "Die Fehlermeldung war: " << sNachricht << endl; + return; + } + return; +} + +// Prüft ob der Name für eine Straße den Konventionen genügt +static bool bStreetOk(const string& sName, const bool bNeu) { + if (sName.empty()) { + cerr << "--> Fehler: Der Wegname ist leer!" << endl; + vSendeNachricht("Der Wegname ist leer!"); + return false; + } + + if (sName.size() > 10) { + cerr << "--> Fehler: Der Wegname darf maximal 10 Zeichen lang sein!" << endl; + vSendeNachricht("Der Wegname darf maximal 10 Zeichen lang sein!"); + return false; + } + + // Nach ungültigen Zeichen im Namen suchen + if (sName.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_-") != string::npos) { + cerr << "--> Fehler: Der Wegname darf nur Buchstaben, Ziffern, -, _ und keine Leerzeichen enthalten!" << endl; + vSendeNachricht("Der Wegname darf nur Buchstaben, Ziffern, -, _ und keine Leerzeichen enthalten!"); + return false; + } + + if (bNeu) { // Weg wird neu angelegt + if (p_mWege.find(sName) != p_mWege.end()) { + cerr << "--> Fehler: Der Wegname wurde schon verwendet!" << endl; + vSendeNachricht("Der Wegname wurde schon verwendet!"); + return false; + } else { + p_mWege[sName] = 0; // Weg in der map speichern + return true; + } + } else { // Weg wird auf Vorhandensein geprüft + if (p_mWege.find(sName) != p_mWege.end()) { // Weg gefunden + return true; + } else { + cerr << "--> Fehler: Der Weg ist nicht vorhanden!" << endl; + vSendeNachricht("Der Weg ist nicht vorhanden!"); + return false; + } + } +} + +// Prüft ob der Name für ein Farzeug den Konventionen genügt +static bool bVehikelOk(const string& sName, const double rel_position, const double speed) { + if (sName.empty()) { + cerr << "--> Fehler: Fahrzeugname ist leer!" << endl; + vSendeNachricht("Fahrzeugname ist leer!"); + return false; + } + + if (sName.size() > 10) { + cerr << "--> Fehler: Der Fahrzeugname darf maximal 10 Zeichen lang sein!" << endl; + vSendeNachricht("Der Fahrzeugname darf maximal 10 Zeichen lang sein!"); + return false; + } + + // Nach ungültigen Zeichen im Namen suchen + if (sName.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890_-") != string::npos) { + cerr << "--> Fehler: Der Fahrzeugname darf nur Buchstaben, Ziffern, -, _ und keine Leerzeichen enthalten!" << endl; + vSendeNachricht("Der Fahrzeugname darf nur Buchstaben, Ziffern, -, _ und keine Leerzeichen enthalten!"); + return false; + } + + if (speed < 0.0) { + cerr << "--> Fehler: Geschwindigkeit < 0.0km/h!" << endl; + vSendeNachricht("Geschwindigkeit < 0.0km/h!"); + return false; + } + + if (speed > 300.0) { + cerr << "--> Fehler: Fahrraeder sind keine Formel1-Fahrzeuge, Geschwindigkeit <= 300km/h!" << endl; + vSendeNachricht("Fahrraeder sind keine Formel1-Fahrzeuge, Geschwindigkeit <= 300km/h!"); + return false; + } + + if ( (rel_position < 0.0) || (rel_position > 1.0) ) { + cerr << "--> Fehler: Relative Position ausserhalb [0, 1]!" << endl; + vSendeNachricht("Relative Position ausserhalb [0, 1]!"); + return false; + } + + return true; +} + + +/* + * nutzbare Funktionen + */ + +// Grafik-Server initialisieren +// Standard: bStarteServer = true, sServer = "localhost", iPort = 7654 +bool bInitialisiereGrafik(int sizeX, int sizeY, bool bStarteServer, const string& sServer, const unsigned short iPort) { + ostringstream ssNachricht; + + // schon initialisiert? + if (p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer ist schon initialisert!" << endl; + return false; + } + + // Socket für die Kommunikation zum Server anlegen + p_cGrafikServerVerbindung = new ClientSocket(SOCK_STREAM); + p_sServer = sServer; + p_iPort = iPort; + + // Größe des Verkehrsplanes speichern + p_iXSize = sizeX; + p_iYSize = sizeY; + + // Größe des Verkehrsplanes kontrollieren + if ( (sizeX < 100) || (sizeX > 2000) || (sizeY < 100) || (sizeY > 2000) ) { + cerr << "--> Fehler: Groesse des Verkehrsplanes < 100 oder > 2000" << endl; + } + + // Grafik-Server starten + if (bStarteServer) { + cout << "--> SimuServer starten ..." << endl; + system("java -jar SimuServer.jar &"); + Sleep(3 * 1000); // 3 Sekunden warten + } + + // Verbindung zum Server aufbauen + if (!p_cGrafikServerVerbindung->Connect(p_sServer, p_iPort)) { + cerr << "--> Fehler: TCP/IP-Verbindung nicht moeglich!" << endl; + return false; + } + + // Init-Befehl senden + ssNachricht << "init " << sizeX << " " << sizeY << "#"; + + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { + p_bInitialisiert = true; +#ifdef DEBUG + cerr << "Init gesendet: " << ssNachricht.str() << endl; +#endif + Sleep(500); + return true; + } else { + cerr << "--> Fehler: Senden Init fehlgeschlagen!" << endl; + return false; + } +} + +// Zeichnet eine Kreuzung +bool bZeichneKreuzung(int posX, int posY) { + ostringstream ssNachricht; + + // noch nicht initialisiert? + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return false; + } + + // Kreuzung innerhalb des Verkehrsplanes? + if ( (posX > 0) && (posX < p_iXSize) && (posY > 0) && (posY < p_iYSize) ) { + ssNachricht << "crossing " << posX << " " << posY << "#"; + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { +#ifdef DEBUG + cerr << "Kreuzung gesendet: " << ssNachricht.str() << endl; +#endif + //Sleep(100); + return true; + } else { + cerr << "--> Fehler: Senden Kreuzung fehlgeschlagen!" << endl; + vSendeNachricht("Senden Kreuzung fehlgeschlagen!"); + return false; + } + } else { + cerr << "--> Fehler: Koordinaten ausserhalb des Verkehrsplanes!" << endl; + vSendeNachricht("Koordinaten ausserhalb des Verkehrsplanes!"); + return false; + } + return false; +} + +// Straße zeichnen +bool bZeichneStrasse(const string& way_to_name, const string& way_back_name, int length, int numPoints, int* points_xy) { + ostringstream ssNachricht; + int iCounter; + + // noch nicht initialisiert ? + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return false; + } + + // Straßenname ok? + if (!bStreetOk(way_to_name, true) || !bStreetOk(way_back_name, true)) { + return false; + } + + if (length < 0) { + cerr << "--> Fehler: Weglaenge kleiner 0!" << endl; + vSendeNachricht("Weglaenge kleiner 0!"); + return false; + } + + if (numPoints < 2) { + cerr << "--> Fehler: Mindestens zwei Koordinaten fuer die Strasse notwendig!" << endl; + vSendeNachricht("Mindestens zwei Koordinaten fuer die Strasse notwendig!"); + return false; + } + + // Strasse senden + ssNachricht << "street " << way_to_name << " " << way_back_name << " " << length << " " << numPoints; + + for (iCounter = 0; iCounter < numPoints * 2; iCounter += 2) { + if ( (points_xy[iCounter] > 0) && (points_xy[iCounter] < p_iXSize) && (points_xy[iCounter + 1] > 0) && (points_xy[iCounter + 1] < p_iYSize) ) { + ssNachricht << " " << points_xy[iCounter] << " " << points_xy[iCounter + 1]; + } else { + cerr << "--> Fehler: Koordinaten ausserhalb des Verkehrsplanes! Ueberspringe..." << endl; + //vSendeNachricht("Koordinaten ausserhalb des Verkehrsplanes! Ueberspringe..."); + } + } + + ssNachricht << "#"; + + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { +#ifdef DEBUG + cerr << "Strasse gesendet: " << ssNachricht.str() << endl; +#endif + //Sleep(100); + return true; + } else { + cerr << "--> Fehler: Senden Strasse fehlgeschlagen!" << endl; + vSendeNachricht("Senden Strasse fehlgeschlagen!"); + return false; + } +} + +// PKW zeichnen +bool bZeichnePKW(const string& carname, const string& streetname, double rel_position, double speed, double tank) { + ostringstream ssNachricht; + + // noch nicht initialisiert ? + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return false; + } + + // PKW-Name, Position und Geschwindigkeit in den Grenzen? + if (!bVehikelOk(carname, rel_position, speed)) { + return false; + } + + if (tank < 0.0) { + cerr << "--> Fehler: Tank < 0.0l!" << endl; + vSendeNachricht("Tank < 0.0l!"); + return false; + } + + if (tank > 999.9) { + cerr << "--> Fehler: Versteckte Tanks sind nicht erlaubt! Tankinhalt < 1000l!" << endl; + vSendeNachricht("Versteckte Tanks sind nicht erlaubt! Tankinhalt < 1000l!"); + return false; + } + + // Existiert die Straße? + if (!bStreetOk(streetname, false)) { + cerr << "--> Fehler: Diese Strasse gibt es nicht!" << endl; + vSendeNachricht("Diese Strasse gibt es nicht!"); + return false; + } + + ssNachricht << "sc " << carname << " " << streetname << setiosflags(ios::fixed); + ssNachricht << " " << setw(7) << setprecision(4) << rel_position; + ssNachricht << " " << setw(6) << setprecision(1) << speed; + ssNachricht << " " << setw(6) << setprecision(1) << tank << "#"; + + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { +#ifdef DEBUG + cerr << "PKW gesendet: " << ssNachricht.str() << endl; +#endif + //Sleep(100); + return true; + } else { + cerr << "--> Fehler: Senden PKW fehlgeschlagen!" << endl; + vSendeNachricht("Senden PKW fehlgeschlagen!"); + return false; + } +} + +// Zeichne Fahrrad +bool bZeichneFahrrad(const string& bikename, const string& streetname, double rel_position, double speed) { + ostringstream ssNachricht; + + // noch nicht initialisiert ? + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return false; + } + + // Fahrradname, Position und Geschwindigkeit in den Grenzen? + if (!bVehikelOk(bikename, rel_position, speed)) { + return false; + } + + // Existiert die Straße? + if (!bStreetOk(streetname, false)) { + cerr << "--> Fehler: Diese Strasse gibt es nicht!" << endl; + vSendeNachricht("Diese Strasse gibt es nicht!"); + return false; + } + + ssNachricht << "sb " << bikename << " " << streetname << setiosflags(ios::fixed); + ssNachricht << " " << setw(7) << setprecision(4) << rel_position; + ssNachricht << " " << setw(6) << setprecision(1) << speed << "#"; + + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { +#ifdef DEBUG + cerr << "Fahrrad gesendet: " << ssNachricht.str() << endl; +#endif + //Sleep(100); + return true; + } else { + cerr << "--> Fehler: Senden Fahrrad fehlgeschlagen!" << endl; + vSendeNachricht("Senden Fahrrad fehlgeschlagen!"); + return false; + } +} + +// sendet die aktuelle Simulationszeit an den erweiterten SimuServer +// (angepasste Funktion) +void vSetzeZeit(const double dTime) { + ostringstream ssNachricht; +#ifdef DEBUG + cout << dTime << endl; +#endif + // noch nicht initialisiert ? + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return; + } + + if (dTime < 0.0) { + cerr << "--> Fehler: Die Zeit darf nicht negativ sein!" << endl; + vSendeNachricht("Die Zeit darf nicht negativ sein!"); + return; + } + + ssNachricht << "time " << dTime << "#"; + + if (p_cGrafikServerVerbindung->Send(ssNachricht.str().c_str(), ssNachricht.str().size())) { +#ifdef DEBUG + cerr << "Zeit gesendet: " << ssNachricht.str() << endl; +#endif + //Sleep(100); + return; + } else { + cerr << "--> Fehler: Senden der Zeit fehlgeschlagen!" << endl; + vSendeNachricht("Senden der Zeit fehlgeschlagen!"); + return; + } +} + +// wartet mSec Millisekunden +void Sleep(const int mSec) { + if (mSec > 0) { + usleep(mSec * 1000); + } + return; +} + +// Grafikserver beenden +void vBeendeGrafik(void) { + // noch nicht initialisiert ? + if (!p_bInitialisiert) { + cerr << "--> Fehler: GrafikServer noch nicht initialisert!" << endl; + return; + } + + vSendeNachricht("Simulation beendet!"); + p_cGrafikServerVerbindung->Send("close#", 6); +#ifdef DEBUG + cerr << "Close gesendet." << endl; +#endif + //Sleep(100); + p_cGrafikServerVerbindung->Disconnect(); + delete p_cGrafikServerVerbindung; + p_cGrafikServerVerbindung = NULL; + return; +} + +/* + * Zusätzliche Schnittstellen wegen eventueller Konvertierungsprobleme bei string/char* + */ + +bool bZeichneStrasse(const char* way_to_name, const char* way_back_name, int length, int numPoints, int* points_xy) { + string sHinweg = string(way_to_name); + string sRueckweg = string(way_back_name); + + return bZeichneStrasse(sHinweg, sRueckweg, length, numPoints, points_xy); +} + +bool bZeichneStrasse(const string& way_to_name, const char* way_back_name, int length, int numPoints, int* points_xy) { + string sRueckweg = string(way_back_name); + + return bZeichneStrasse(way_to_name, sRueckweg, length, numPoints, points_xy); +} + +bool bZeichneStrasse(const char* way_to_name, const string& way_back_name, int length, int numPoints, int* points_xy) { + string sHinweg = string(way_to_name); + + return bZeichneStrasse(sHinweg, way_back_name, length, numPoints, points_xy); +} + +bool bZeichnePKW(const char* carname, const char* streetname, double rel_position, double speed, double tank) { + string sName = string(carname); + string sWeg = string(streetname); + + return bZeichnePKW(sName, sWeg, rel_position, speed, tank); +} + +bool bZeichnePKW(const string& carname, const char* streetname, double rel_position, double speed, double tank) { + string sWeg = string(streetname); + + return bZeichnePKW(carname, sWeg, rel_position, speed, tank); +} + +bool bZeichnePKW(const char* carname, const string& streetname, double rel_position, double speed, double tank) { + string sName = string(carname); + + return bZeichnePKW(sName, streetname, rel_position, speed, tank); +} + +bool bZeichneFahrrad(const char* bikename, const char* streetname, double rel_position, double speed) { + string sName = string(bikename); + string sWeg = string(streetname); + + return bZeichneFahrrad(sName, sWeg, rel_position, speed); +} + +bool bZeichneFahrrad(const string& bikename, const char* streetname, double rel_position, double speed) { + string sWeg = string(streetname); + + return bZeichneFahrrad(bikename, sWeg, rel_position, speed); +} + +bool bZeichneFahrrad(const char* bikename, const string& streetname, double rel_position, double speed) { + string sName = string(bikename); + + return bZeichneFahrrad(sName, streetname, rel_position, speed); +} + +// eof diff --git a/SimuClient/SimuClient.h b/SimuClient/SimuClient.h new file mode 100644 index 0000000..f7c7252 --- /dev/null +++ b/SimuClient/SimuClient.h @@ -0,0 +1,41 @@ +/* + * SimuClient für MacOS/Linux (Praktikum Informatik 2, WS 2009/10 RWTH Aachen) + * Version 0.5 + * von Robert Uhl, 2009 - 2010 + * Vielen Dank an den Lehrstuhl EECS, RWTH Aachen, für den Zugang zum Quellcode + * des SimuClient für Windows. + * Datei: SimuClient.h + * Inhalt: SimuClient sendet Daten an den (erweiterten) Java-Grafik-Server + */ + +#ifndef SIMUCLIENT_H +#define SIMUCLIENT_H + +#include +using namespace std; + +// Funktionen der Library +bool bInitialisiereGrafik(int sizeX, int sizeY, bool bStarteServer = true, const string& sServer = "localhost", const unsigned short iPort = 7654); +bool bZeichneKreuzung(int posX, int posY); +bool bZeichneStrasse(const string& way_to_name, const string& way_back_name, int length, int numPoints, int* points_xy); +bool bZeichnePKW(const string& carname, const string& streetname, double rel_position, double speed, double tank); +bool bZeichneFahrrad(const string& bikename, const string& streetname, double relposition, double speed); +void vSetzeZeit(const double dTime); // sendet die Simulationszeit an den erweiterten Grafikserver +void Sleep(const int mSec); // ersetzt die Sleep()-Funktion von Windows, die mSek übernimmt +void vBeendeGrafik(void); + +// Zusätzliche Schnittstellen wegen eventueller Konvertierungsprobleme bei string/char* +bool bZeichneStrasse(const char* way_to_name, const char* way_back_name, int length, int numPoints, int* points_xy); +bool bZeichneStrasse(const string& way_to_name, const char* way_back_name, int length, int numPoints, int* points_xy); +bool bZeichneStrasse(const char* way_to_name, const string& way_back_name, int length, int numPoints, int* points_xy); + +bool bZeichnePKW(const char* carname, const char* streetname, double rel_position, double speed, double tank); +bool bZeichnePKW(const string& carname, const char* streetname, double rel_position, double speed, double tank); +bool bZeichnePKW(const char* carname, const string& streetname, double rel_position, double speed, double tank); + +bool bZeichneFahrrad(const char* bikename, const char* streetname, double rel_position, double speed); +bool bZeichneFahrrad(const string& bikename, const char* streetname, double rel_position, double speed); +bool bZeichneFahrrad(const char* bikename, const string& streetname, double rel_position, double speed); + +#endif // SIMUCLIENT_H +// eof