SimuClient hinzugefügt

This commit is contained in:
Steffen Vogel 2011-11-09 10:18:54 +01:00
parent 19f1e99deb
commit d92cdfd398
4 changed files with 690 additions and 0 deletions

104
SimuClient/ClientSocket.cpp Normal file
View file

@ -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

39
SimuClient/ClientSocket.h Normal file
View file

@ -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 <string>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <iostream>
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

506
SimuClient/SimuClient.cpp Normal file
View file

@ -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 <iostream>
#include <iomanip>
#include <string>
#include <sstream>
#include <map>
#include <cstdlib>
#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<string, int> 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

41
SimuClient/SimuClient.h Normal file
View file

@ -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 <string>
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