© Kurt Michel, Pixelio.de

The Open Racing Car Simulator, kurz Torcs, gehört zu den beliebtesten freien Autorennspielen unter Linux. Einen Großteil dieses Erfolges verdankt es neben der 3-D-Engine vor allem seinem modularen Aufbau, mit dessen Hilfe sich fast alle Einstellungen mit etwas Kreativität und einem Texteditor verändern lassen.

Modifizierbar

So liegen die Texturen der Rennwagen in einer einfachen Bilddatei, mitgelieferte Schablonen erlauben eigene Embleme auf Türen und Motorhaube. Ähnlich einfach modifiziert der Benutzer die Rennmodi, entwirft Strecken im Trackeditor, baut neue Fahrzeuge und bestimmt deren physikalische Eigenschaften.

Engagierte Fans haben mehr als 50 Rennwagen und über 20 abwechslungsreiche Rennstrecken beigesteuert [1], neben Nascar-Ovalen und bekannten Formel-1-Kursen auch anspruchsvolle Phantasiestrecken im winterlichen Gebirge oder in dem staubigen Outback Australiens (Abbildung 1).

Abbildung 1: Die Rennsportsimulation Torcs bringt viele frei konfigurierbare Strecken, Autos und Computergegner mit. Von links nach rechts: ein Ferrari im Australien, ein winterlicher Zweikampf, ein Porsche auf einer Bergrennstrecke. Alle Elemente lassen sich mit OSS-Tools editieren, so auch die 3-D-Trackside-Objects.

Abbildung 1: Die Rennsportsimulation Torcs bringt viele frei konfigurierbare Strecken, Autos und Computergegner mit. Von links nach rechts: ein Ferrari im Australien, ein winterlicher Zweikampf, ein Porsche auf einer Bergrennstrecke. Alle Elemente lassen sich mit OSS-Tools editieren, so auch die 3-D-Trackside-Objects.

Abbildung 1: Die Rennsportsimulation Torcs bringt viele frei konfigurierbare Strecken, Autos und Computergegner mit. Von links nach rechts: ein Ferrari im Australien, ein winterlicher Zweikampf, ein Porsche auf einer Bergrennstrecke. Alle Elemente lassen sich mit OSS-Tools editieren, so auch die 3-D-Trackside-Objects.

Herausragend sind bei Torcs jedoch die intelligenten Computergegner (Robots). Torcs-typisch lassen sie sich nicht nur austauschen, sondern mit etwas C oder C++-Kenntnissen auch selbst erschaffen. Das macht das Autorennspiel zu einem Übungsgelände für künstliche Intelligenz, das auch Forscher an Universitäten nutzen.

KI-Wettbewerbe

Die Programmierer der besten Robots messen sich regelmäßig in internationalen Meisterschaften. Das Torcs Racing Board [2] richtet zum Beispiel seit 2005 jährlich die Torcs Endurance World Championship aus. In vorgegebenen Autos müssen hier die Robots mehrere Langstreckenrennen auf bestimmten Strecken bestreiten. Die Polytechnische Universität Mailand veranstaltet seit 2008 zusammen mit der Universität Würzburg die Simulated Car Racing Championship.

Die an Formel-1-Regeln angelehnten Rennen finden gleich mehrfach pro Jahr auf verschiedenen Konferenzen statt, 2010 beispielsweise auf der Genetic and Evolutionary Computation Conference (GECCO, [3]) in Portland, dem IEEE World Congress on Computational Intelligence (WCCI) in Spanien und im August auf dem IEEE Symposium on Computational Intelligence (CIG, [4]) am 22. August in Kopenhagen.

Die Universität Würzburg hat sogar ein eigenes Demolition Derby eingeführt. Da gilt es nicht, die schnellsten Rundenzeiten zu fahren, sondern die Gegner absichtlich zu rammen – und dabei selbst möglichst wenig Schaden zu nehmen.

Anfahrhilfe

Wer jetzt Lust bekommt, einen eigenen Robot zu programmieren, muss sich zunächst den Torcs-Quellcode angeln [5]. Die fertigen Pakete in den Repositories der Distributionen sind meist unbrauchbar, da ihnen die zur Entwicklung notwendigen Headerdateien fehlen. Das benötigte Tgz-Archiv findet sich auf der etwas unübersichtlichen Leiste links unter »Download/Installation« und dann »For Linux and BSD from “all-in-one” Source Package«.

Zum Redaktionsschluss war die Version 1.3.1 aktuell, die auch bei zwei der erwähnten Wettbewerbe die tragende Rolle spielt. Wer das heruntergeladene Torcs-Archiv im eigenen Heimatverzeichnis entpackt hat, zückt den Paketmanager und löst die verlangten Abhängigkeiten auf. Neben »g++« und »menu« sind die Entwicklerpakete zu Open GL, Freeglut3, Open AL, ALUT, X11, Plib, Zlib und Libpng erforderlich. Unter Ubuntu 10.04 erledigt das beispielsweise »apt-get install g++ freeglut3 freeglut3-dev libopenal1 libalut0 libalut-dev menu libplib1 libplib-dev xorg-dev libpng12-dev«.

Selbstverständlich setzt Torcs im X-Server aktivierte 3-D-Beschleunigung voraus. Ohne sie ruckelt die Grafik bestenfalls, was wiederum die Kontrolle eines handkodierten Robots erschwert. Sind alle Voraussetzungen erfüllt, übersetzt der folgende Vierzeiler Torcs:

./configure
make
sudo make install
sudo make datainstall

Die Spieldaten wandern dabei nach »/usr/local/share/games/Torcs«, wo später auch die selbst entwickelten Robots landen. Das zurückgebliebene Quellcodeverzeichnis »Torcs-1.3.1« dient ab sofort als Entwicklungsumgebung.

Ob die Installation geklappt hat, erfährt der Benutzer durch die Eingabe von »torcs«. Für ein erstes schnelles Rennen wählt er im Hauptmenü »Race« gefolgt von »Quick Race«. Unter »Configure Race« sucht er zunächst eine Strecke aus und nach einem Klick auf »Accept« die gegnerischen Robots. Die Liste auf der linken Seite führt dabei die Rennteilnehmer, alle bekannten Robots finden sich rechts. Per »(De)Select« wechselt der gerade markierte Fahrer die Spalte.

Menschen unerwünscht

Entfernt der User auf diese Weise den menschlichen »Player« aus der linken Liste, bestreiten nur noch Computer das Rennen – ideal um eigene Robots zu testen oder ihre Leistung mit den anderen zu vergleichen. Nach einem weiteren »Accept« und der Eingabe der Renndistanz startet »New Race« das Rennen. Die übrigen Rennmodi richten sich eher an den Spieler, ein Artikel des “LinuxUser” beschreibt sie genauer [6].

Bei diesen Modi gibt der menschliche Fahrer per Joystick, Lenkrad oder Pfeiltasten Gas, lenkt und bremst. Über [F2] bis [F11] wechselt er die Perspektive, [F1] zeigt die Onlinehilfe und mit [Esc] kehrt er zum Menü zurück. [Bild auf] und [Bild ab] springen zwischen den Fahrzeugen.

Fahrerlager

Damit die Übersetzung des ersten eigenen Robots reibungslos klappt, sind in der Datei ».bashrc« noch ein paar Umgebungsvariablen erforderlich:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:
/usr/local/lib
export Torcs_BASE=~/Torcs-1.3.1
export MAKE_DEFAULT=$Torcs_BASE/Make-
default.mk

Hinter »Torcs_BASE« steht der Pfad zum Quellcodeverzeichnis, »MAKE_DEFAULT« verweist auf ein vorgefertigtes Basis-Makefile.

Um einen eigenen Robot zu basteln, überlegt sich der Programmierer zunächst einen Kurznamen und wählt einen fahrbaren Untersatz. Die derzeit installierten Autos verrät »ls« im Unterverzeichnis »cars« (Abbildung 2).

Abbildung 2: Unter »/usr/share/games/torcs« finden sich »cars«, »tracks« und »drivers«. Deren Verzeichnisse tragen meist recht kryptische Namen.

Für den Einstieg empfiehlt sich der recht gutmütige einfache Nascar-Wagen »cg-nascar-rwd«, sein künstlicher Fahrer nennt sich in den folgenden Beispielen »tux«. Mit diesen beiden Informationen erzeugt das Skript »robotgen.sh« aus dem Torcs-Quellcodeverzeichnis das Grundgerüst des neuen Robots:

cd ~/Torcs-1.3.1
./robotgen -n "tux" -a "Tim Schürmann" ./-c
 "cg-nascar-rwd" --gpl

In diesem Beispiel heißt der Autor des Robots »Tim Schürmann«, via »–gpl« erhalten alle erzeugten Dateien noch einen Hinweis auf die GPL-Lizenz. Wie die Ausgabe aus Abbildung 3 zeigt, bekommt der neue Robot ein eigenes Unterverzeichnis »~/Torcs-1.3.1/src/drivers/tux« spendiert. Dort liegen ein Makefile, eine Konfigurationsdatei »tux.xml« sowie der eigentliche Quellcode in »tux.cpp«. Alle anderen Dateien sind nur für Windows-Programmierer interessant.

Abbildung 3: Hier hat »robotgen« alle Dateien für einen neuen Robot erstellt, der so allerdings mangels Instruktionen an der Starlinie stehen bleibt.

Ein Dummy gibt Gas

Der von »robotgen« erzeugte Default-Fahrer ist jedoch so simpel, dass er prompt an der Start- und Ziellinie stehen bleibt. Wer ihm etwas mehr Intelligenz einimpfen will, öffnet in seinem Unterverzeichnis die Datei »tux.cpp«. Darin hat »robotgen« schon ein paar Funktionen vorgegeben, die Torcs zu unterschiedlichen Zeitpunkten aufruft: »newrace()« zum Beispiel kurz vor dem Start des Rennens beziehungsweise »endrace()« analog nach seinem Ende.

Von besonderem Interesse ist die Funktion »drive()«. Torcs ruft sie während des Rennens alle 0,02 Sekunden auf und bittet damit den künstlichen Fahrer seine Entscheidungen zu treffen. Übergeben bekommt »drive()« sowohl den Zustand des Autos in der Variablen »car« als auch die Situation auf der Strecke in der Variablen »s«. Den Aufbau der dahinter stehenden Strukturen verraten die Headerdateien »car.h« und »raceman.h« im Verzeichnis »Torcs-1.3.1/export/include«.

Um voranzukommen, empfiehlt es sich, zunächst den ersten Gang einzulegen. Dazu muss sich lediglich der Zustand des Autos verändern, indem der Programmierer die entsprechende Variable setzt:

car->ctrl.gear = 1;

Jetzt drückt er ein wenig aufs Gaspedal und für flotteres Vorankommen löst er die Bremsen:

car->ctrl.accelCmd = 0.3;
car->ctrl.brakeCmd = 0.0;

Die Werte für Gas und Bremse stammen aus dem Intervall [0.0, 1.0], wobei 1.0 das jeweilige Pedal voll durchtritt. Auf wie viele Kilometer pro Stunde der Wagen damit beschleunigt oder abbremst, hängt von seinem Motor, den Reifen und den übrigen physikalischen Faktoren ab. Das Nascar-Auto braust so gleich mit ungefähr 80 km/h über die Strecke.

Steuermann

Der Wagen rollt jetzt, der Robot muss ihn nur noch auf der Strecke halten. Den Track baut Torcs aus Geraden, Links- und Rechtskurven zusammen. Diese einzelnen Segmente sind teilweise recht kurz, eine Biegung kann aus mehreren kleinen Teilstücken bestehen. Jede Gerade hat eine bestimmte Breite und Länge, Kurven auch noch einen Krümmungsradius.

Die Teilstücke sind zudem zentriert aneinander ausgerichtet: Verlässt ein Auto ein Segment in der Straßenmitte, rollt es auch auf das nachfolgende in der Mitte. Wer den Wagen konsequent auf der Mittellinie hält, kommt weder von der Fahrbahn ab, noch stößt er gegen irgendein Hindernis (Abbildung 4).

Abbildung 4: Der einfache Robot klebt an der Mittellinie.

Um genau dieses Ziel zu erreichen, richtet der Robot in Anlehnung an [7] zunächst die Räder parallel zur Mittellinie aus. Dazu benötigt der Programmierer zwei Winkel (Abbildung 5), zuerst den Drehwinkel, wenn das Auto etwas gedreht auf der Fahrbahn (gieren, auf Englisch yaw) steht:

Abbildung 5: Die grüne Linie zeigt den Abstand zwischen Wagen und Straßenmitte, die rote Linie liegt als Tangente an der Mittellinie.

car->_yaw

Als Nächstes holt der Robot die aktuelle Fahrzeugposition (»car->_trkPos«) und legt an dieser Stelle eine Tangente an die Mittellinie an. Ihren Winkel ermittelt eine eingebaute Hilfsfunktion:

RtTrackSideTgAngleL(&(car->_trkPos))

Nach Subtraktion des Drehwinkels vom eben errechneten Tangentenwinkel stehen die Räder parallel zur Mitte der Rennstrecke:

float winkel;
winkel = RtTrackSideTgAngleL(&(car->_trkPos
)) - car->_yaw;
NORM_PI_PI(winkel);

Das Makro »NORM_PI_PI()« stammt von Torcs selbst und konvertiert den Winkel in den Wertebereich [»-PI«, »PI«].

Die wahre Mitte

Damit fährt das Auto allerdings immer parallel zur Mittellinie (Abbildung 6). Um es genau auf die Linie zu bugsieren, muss der Robot das Lenkrad noch etwas weiter einschlagen. Dafür bietet sich der Abstand des Autos zur Straßenmitte an:

Abbildung 6: Die einfache Heuristik (erster Gang, Vollgas, immer an der Mittellinie entlang) funktioniert auch in Kurven, wenn sie nicht zu eng sind.

car->_trkPos.toMiddle

Bei einem positiven Wert befindet sich der Wagen links von der Mittellinie, bei einem negativen rechts davon. Diese Meterangabe lässt sich natürlich nicht einfach zum Winkel hinzurechnen. Also teilt man ihn durch die Streckenbreite und zieht das Ergebnis von »winkel« ab:

winkel = winkel - car->_trkPos.toMiddle / 
car->_trkPos.seg->width;

Jetzt ist das Lenkrad einzuschlagen. Wie stark, bestimmt wie bei den Pedalen ein Wert zwischen »-1.0« und »+1.0«. Bei »-1« ist das Lenkrad am linken Anschlag, bei »+1« am rechten. Um den Winkel auf den Wertebereich abzubilden, teilt ihn

car->ctrl.steer = winkel / car->_steerLock;

durch die für diesen Zweck eingebaute Konstante »car->_steerLock«. Den endgültigen Lenkradeinschlag nimmt »car->ctrl.steer« auf. Die komplette »drive()«-Funktion zeigt Listing 1.

01 static void drive(int index, tCarElt* car, tSituation *s)
02 {
03   memset((void *)&car->ctrl, 0, sizeof(tCarCtrl));
04   /* Auto bewegen */
05   car->ctrl.gear = 1;  /* ersten Gang einlegen */
06   car->ctrl.accelCmd = 0.3; /* Gaspedal treten */
07   car->ctrl.brakeCmd = 0.0; /* Bremse lösen */
08   /* Lenken */
09   float winkel;
10   winkel = RtTrackSideTgAngleL(&(car->_trkPos)) - car->_yaw;
11   NORM_PI_PI(winkel);
12   winkel = winkel - car->_trkPos.toMiddle / car->_trkPos.seg->width;
13   car->ctrl.steer = winkel / car->_steerLock;
14 }

Abschließend kann der virtuelle Fahrer dem Auto noch ein anderes Aussehen verpassen, indem er seine Außenhaut in der Datei »cg-nascar-rwd.rgb« mit einem Malprogramm dekoriert. Um den fertigen Robot zu übersetzen, wechselt er ins Verzeichnis »cd ~/Torcs-1.3.1/src/drivers/tux«, ruft »make« auf und installiert ihn schließlich via »make install« (ohne »sudo«-Rechte).

Für eine Probefahrt setzt er im »Quick Race« unter »Configure« im Schritt »Select Drivers« nur den neuen Robot »tux« auf die Strecke (Abbildung 7). Da Torcs bei jedem Rennstart grundsätzlich sämtliche beteiligten Robots neu lädt, reicht es, das Spiel während der weiteren Robot-Entwicklung einfach im Hintergrund laufen zu lassen.

Abbildung 7: Nach wenigen Handgriffen dreht »tux« ganz alleine seine Runden. Die 3-D-Vogelperspektive zeigt die Fahrweise des Robots am besten.

Intelligenter Boxenstopp

Nun gilt es, den extrem einfachen Robot sukzessive zu verbessern. So sollte der Wagen natürlich auf der Ideallinie fahren, durch passende Gas- und Brems-Vorgaben bessere Rundenzeiten erzielen, Gegner überholen und bei Unfällen wieder zurück auf die Strecke finden. Die Königsdisziplin sind Langstreckenrennen, in denen der Robot selbstständig die eigene Box aufsucht und gezielt nachtankt, während die Boxencrew in der Zwischenzeit das Fahrzeug repariert.

Vielleicht ließe sich für all diese Situationen jeweils eine eigene Lösung finden: Wenn etwa der Wagen trotz Vollgas nicht von der Stelle kommt, ist er vermutlich in die Bande gefahren, weshalb der Robot den Rückwärtsgang einlegen und Gas geben könnte. Solche einfachen Heuristiken verwendet auch die gute Einführung in die Robot-Programmierung von Bernhard Wymann [7].

Die damit erzielten Ergebnisse stecken im Torcs-Fahrer »bt 1« und funktionieren erstaunlich gut. Allerdings muss der Programmierer bei diesem Vorgehen wirklich für fast jede (Ausnahme-)Situation eine geeignete Routine schreiben. Um dabei nicht den Überblick zu verlieren, nutzt er meist ein zweistufiges System, bei dem er zunächst den Zustand des Autos ermittelt, etwa “auf der Strecke”, “neben der Strecke”, “falsche Fahrtrichtung”. Ausgehend von diesem Wissen leitet der Robot die entsprechenden Maßnahmen ein. Auch kommerzielle Rennspiele setzen solche zustandsbasierten Systeme ein.

KI-Almanach

Die alternativen Verfahren lesen sich wie das Inhaltsverzeichnis eines Buchs über künstliche Intelligenz. So gingen bei Wettbewerben bereits neuronale Netze, Fuzzy Logic und evolutionäre Algorithmen gegeneinander an den Start. Sehr gut übertragbar sind auch die Ergebnisse aus der Roboterforschung, die ähnliche Aufgaben löst. Der heilige Gral ist aber auch hier noch nicht gefunden, es wirken einfach zu viele Parameter auf das Auto ein. So sind allein schon über die möglichst effiziente Ermittlung der Ideallinie mehrere Aufsätze entstanden [8].

Als kleine Hilfe stellt Torcs den Robots über »car« und »s« mehr Informationen bereit als einem menschlichen Fahrer und vereinfacht somit viele Berechnungen. Beispielsweise sieht der Robot immer die komplette Strecke. Folglich könnte er die Ideallinie schon vor dem eigentlichen Rennbeginn errechnen und sich anschließend daran entlangschlängeln. Jeder Programmierer kann sich aus der Datenfülle die für ihn benötigten Informationen herauspicken. Das wiederum macht allerdings die verschiedenen Algorithmen schlechter vergleichbar.

Boxenfunk

Anders als das Torcs Racing Board verschärften deshalb die Veranstalter der Simulated Car Racing Championship und des Demolition Derby die Regeln. Mehr noch: Mit einem speziellen Patch verwandeln sie das Rennspiel in ein Client-Server-System. Torcs selbst läuft dabei auf einem Server, die Robots in externen Prozessen. Ihre Entscheidungen senden sie über eine UDP-Verbindung an Torcs. Das hat den angenehmen Nebeneffekt, dass Entwickler die Robots in einer beliebigen Programmiersprache schreiben können. Bei den Wettbewerben zugelassen sind derzeit aber nur C++ und Java.

Das modifizierte Torcs bittet die Clients nicht mehr nacheinander, sondern gleichzeitig um ihre Entscheidungen. Für die notwendigen Berechnungen stehen den Robots nur 10 Millisekunden bereit. Bleibt eine Antwort aus, fährt der Wagen einfach unverändert weiter.

Informationen über das Auto und die Strecke liefern nur noch wenige Sensoren. Zum Beispiel verrät ein Sensor die aktuelle Geschwindigkeit, ein anderer den Füllstand des Tanks. Dieses Sensor-Aktor-Modell ist in der KI und besonders in der Robotik weit verbreitet, bestehende Algorithmen lassen sich so einfach übertragen. Zudem muss der Programmierer nicht mit den Torcs-eigenen Datenstrukturen hantieren, wodurch der Code einigermaßen portierbar bleibt.

Torcs selbst tastet das Patch nur an wenigen Ecken an. Hinzu kommen spezielle Robots, die so genannten Server-Bots. Pro Client, der auch auf einem anderen Rechner laufen kann, kommuniziert ein eigener Server-Bot über einen UDP-Port mit dem Controller (Abbildung 8).

Abbildung 8: Die Architektur des Client-Server-Torcs. Die Klasse, die innerhalb eines Clients die eigentlichen Entscheidungen trifft, bezeichnet die Wettbewerbs-Dokumentation als Controller.

Wer an der Simulated Car Racing Championship teilnehmen möchte, muss Torcs zunächst dieses Patch einimpfen, das derzeit zwingend die Torcs-Version 1.3.1 voraussetzt. Die ist auf der DELUG-DVD enthalten, später sicher auch im Archiv mit allen älteren Fassungen auf Sourceforge [7] in der Gruppe »all-in-one«.

Das Patch erhält der Benutzer direkt auf der Homepage der Simulated Car Racing Championship unter »Competition Software« [9]. Das heruntergeladene Archiv entpackt er direkt im »Torcs-1.3.1«-Verzeichnis und wechselt auf der Kommandozeile in »champ2010patch« und aktiviert das Patch mit »sh do_patch«. Dann noch Torcs neu übersetzen und installieren – schon kann es losgehen.

Kaputt machen

Das Demolition Derby verlangt ein eigenes Patch, das dummerweise mit dem der Racing Championship inkompatibel ist [8]. Wer an beiden Veranstaltungen teilnehmen möchte, muss mit zwei verschiedene Torcs-Quellcode-Verzeichnisse jonglieren. Die Installation des Patch erfolgt wie beim Kollegen: Archiv von der Destruction-Derby-Seite herunterladen, im Torcs-Verzeichnis entpacken und im neuen Ordner »ddpatch« den Befehl »sh do_patch« aufrufen. Zusätzlich benötigt das Patch noch den speziellen Demolition-Derby-Rundkurs [10], dessen Paket entpackt im Verzeichnis »/usr/local/share/games/Torcs/oval« landet.

Dann heißt es wieder Torcs starten, »Quick Race«, »Configure Race« und die Strecke »derby2« aus der Gruppe der »Oval Tracks« auswählen. Für die Simulated Car Racing Championship taugt jede Strecke. Nach einem Klick auf »Accept« finden sich in der Liste auf der rechten Seite mehrere »championship2010server«-Fahrer, von denen normalerweise der erste ausgewählt ist.

Für die Entwicklung eines eigenen Controllers genügt dies vollauf, wer mehrere Clients gegeneinander fahren lassen möchte, muss weitere »championship2010server«-Fahrer hinzufügen. Im letzten Menü mit den »Quick Race Options« sollte der Anwender noch das »Display« auf »normal« stellen, andernfalls präsentiert Torcs während des Rennens nur einen schwarzen Bildschirm und anschließend die Ergebnisse. Jetzt startet das Rennen, wobei Torcs allerdings im Ladebildschirm auf die Rückmeldung der Clients wartet.

C++ und Java: Fremde Intelligenz am Steuer

Je ein Beispielclient findet sich für C++ und Java auf der Homepage des jeweiligen Wettbewerbs ([9], [10]). Deren Archive folgen dem bekannten Ablauf: entpacken und bei der C++-Variante den herausgepurzelten Quellcode mit einem einfachen »make« übersetzen. Das Ergebnis namens »client« startet mit:

./client host:127.0.0.1 port:3001

Java-Liebhaber benutzen hingegen im Unterverzeichnis »classes« den etwas längeren Bandwurm:

java champ2010client.Client champ2010client
.SimpleDriver host:127.0.0.1 port:3001

Hinter »host:« folgt die IP-Adresse, unter der Torcs läuft (im Bespiel also derselbe Rechner), hinter »port:« folgt der UDP-Port auf dem der Server-Bot wartet. Standardmäßig lauscht der erste »championship2010server« an Port 3001, der zweite an 3002 und so fort. Torcs und Controller sollten sich jetzt gegenseitig erkennen und das eigentliche Rennen ausführen (Abbildung 9).

Abbildung 9: Hier fährt der Client (linkes Terminal), während Torcs rechts seine Kommandos umsetzt.

Für eigene Controller lässt sich einfach der Beispielclient modifizieren – entweder durch Anpassung der »SimpleDriver«-Klasse direkt oder durch Ableitung einer eigenen Unterklasse von ihrer Basis »BaseDriver« beziehungsweise bei Java von »Controller«. Kern ist wieder die Methode »drive()«, bei einem Java-Client heißt sie »control()«. Diesmal übergibt ihr Torcs jedoch den Zustand aller Sensoren.

Welche Sensoren verfügbar sind, listet das lesenswerte »Software manual« von der Homepage der Simulated Car Racing Championship. Dessen Ausführungen gelten weitgehend auch für Demolition-Derby-Teilnehmer, die aber auch das »Demolition Derby Manual« von der Wettbewerbs-Homepage lesen sollten. Das ausgefeilte Sensormodell aus Abbildung 10 eignet sich übrigens auch für die Steuerung von Modellfahrzeugen, aber das ist noch Zukunftsmusik.

Abbildung 10: Aus dem Input der Sensoren berechnen Robots in 10 Millisekunden Kommandos fürs Fahrzeug.

Wer sich erst einmal durch die etwas umständliche Installation geackert und die bereitgestellten Datenstrukturen erkundet hat, dem bietet Torcs einen schnellen und unterhaltsamen Einstieg in die KI. Das Rennspiel unterstützt den Entwickler dabei mit umfangreichen Funktionen. So darf er seinem Robot beispielsweise mehrere Autos mit auf ein spezielles Fahrverhalten abgestimmten Einstellungen zur Verfügung stellen.

Anmelden und mitmachen

Wer seine Eigenkreation für gelungen hält, sollte sie bei einem der Wettbewerbe anmelden. Die Teilnahme ist durchweg kostenlos, die Bedingungen und alle weiteren notwendigen Informationen für die angehenden Rennfahrer finden sich auf der jeweiligen Homepage.

Bei der Gecco 2010 gewann Enrique Onieva Caracuel mit seinem Racer Autopia, der einer mit evolutionären Methoden optimierten modularen Architektur folgt. Anmeldeschluss für das IEEE Symposium der CIG 2010 ist der 8. August, das Rennen steigt am 22.8.

Vorsicht ist jedoch geboten: Die Programmierung eines künstlichen Fahrergehirns macht süchtig. (mfe)