rec.autos.simulators

The first RARS races will be held in the computer of Mitchell Timin
on April 30, 1995.  Entries will be received by e-mail, directed to

They may be in source code, either ANSI C or C++, or they may be
object files, to be linked with Borland C/C++version 3.1.  Source
files will be compiled with that compiler.  The races will be run with
the latest version of the RARS software, version 0.50.  (Robots that
are developed with ver. 0.39 or 0.45 will be fine; they may need
trivial changes and re-compiling.)  Object files should be uuencoded.

Entries must be received by 10:00 AM, EST, April 30.  If the net is
slow, too bad, so send them as early as possible.  It is better if
I receive them a week early, in case there are any problems with
compilation, linking, or execution.   (I will inform you A.S.A.P.)

Any robots that cause run-time problems with any part of the
software, including the other robots, will be disqualified.  Timin's
judgement will be final here.

There are three prizes.  The 1st place robot's author gets his pick
from the three.  The 2nd place author picks from the remaining two,
and 3rd place gets what's left.  The prizes are:

1. "Street Wizard 5.0" by Adept Computer Solutions.  This is street
mapping software which finds addresses, plots quickest routes, and
prints maps and directions.  The 120 largest U.S. metropolitan areas
are included on the CD-ROM version.  The winner may choose CD-ROM or
diskettes.  (runs under MS Windows on a PC)

2. A copy of Mark Watson's McGraw-Hill book "C++ Power Paradigms"
(constraint programming, neural networks, genetic algorithms, and
training recurrent NNs with genetic algorithms).

3. A copy of Mark Watson's Springer-Verlag book "Common LISP Modules.
Artificial Intteligence in the Era of Neural Networks and Chaos Theory".

There will be 12 races, two races on each of six tracks.  Starting
positions will be chosen at pseudo-random for the first race on each
track, and then the reverse order will be used for the second race.
Points will be awarded as follows for each race:

   1st - 10   2nd - 6   3rd - 4   4th - 3   5th - 2   6th - 1

Winning places will be based on the point total for the 12 races.
If there are six*** or less entries, then all will compete in these
races.  If there are more than six*** then qualifying heats will be
run to arrive at six*** finalists.

Track definition files for the six tracks are in the file TRACKS.ZIP
on the ftp site, the "tracks" subdirectory.  The track names and
the number of laps to be run on each race are as follows:

  ANEW.TRK      8   laps
  OVAL2.TRK     20  laps
  V03.TRK       15  laps
  STEF2.TRK     15  laps
  SPEED2.TRK    10  laps
  ZANDVORT.TRK  8   laps

Robot code should not make any direct DOS or BIOS calls, nor access
memory in any strange ways.  No peripheral hardware may be accessed,
with the possible exception of disk reading during initialization
(but see next paragraph).  Robots may use the "extern" keyword to
access any data that they can find, but may not alter such data.  Any
robot driver function that causes any problems with any other part of
the software will simply not be used.  Mitchell Timin's judgement
will be final in this matter.

Every entry must consist of just one file, a source file or a .OBJ
file.  It will be permissible, for the April 30 races, for the robot
to read this file to initialize data tables.  

Each robot must use no more than 25K of RAM, both for its code and
data.  Each robot must execute in no more than 3 milliseconds (on a
DX2-66) each time that it is called, after initilization.  
In practice this just means that the race can be run at realistic
speed, and no slower.

I won't personally submit an entry for the April 30 RARS races, nor will
any of my family or any close associates here in PA.

All robot drivers that I receive will be held in confidence until
after the races are completed.  After that I will put them on the ftp
site.  Also, I will not announce performance figures for the early
entries prior to race day.

Don't expect me to do any kind of tuning or adjusting or debugging to
any robot.  Every entry must be ready to race, or it won't.  I will
notify the author A.S.A.P if there are problems, but that might take
a day or two, or even three.

m

: I've missed the earlie parts of the thread.  Where is a spec on this?

The Robot Auto Racing Simulation (RARS) is a simulation of auto racing
in which the cars are driven by robots.  Its purpose is two-fold: to
serve as a vehicle for Artificial Intelligence development and as a
recreational competition among software authors.  The host software,
including source, is available at no charge.  It currently runs under
MSDOS and UNIX, including Linux, and on the Amiga. This announcement
introduces the sixth release of the software, which we call version
0.50.  New features of ver. 0.50 are summarized below.

The April 30 races will be run on version 0.50.  It has been tested
to assure that the robots have the same lap times as they do on
version 0.39.  (Get race.ann from the ftp site, see below.)

                The Robot Auto Racing Simulation

            A Challenge for Evolutionary Programming

                 A Competition for Programmers

                      by Mitchell E. Timin

Version 0.50 of RARS is ready.  It is written in C++.  The DOS
version was compiled and tested with Borland C++ ver. 3.1.  It should
be easy to port to any C++ that has functions for drawing lines and
arcs, a flood-fill or color fill function, and text output to the
graphic screen.  Hence it will not be difficult to make it run on a
Macintosh or Windows system.  C++ is not required for the robot
"driver" programs.

New features introduced with version 0.45 were:
- The drivers which are to race can be named on the command line.
- The computer can generate a random starting order.
- The race can be run with no graphics display.
- A series of races can be run, on the same track with the same drivers.
- A report is generated in a file, giving the results of all races in
  a series.  Points are accumulated using the F1 scoring system.
- Degrees or radians may be used in any track definition file.
- Clockwise tracks will work now.

Version 0.50 introduces a digital "instrument panel".  Any of the racers may
be cursor-selected using the up & down arrow keys.  Six key variables
for the selected car are shown during the race, updating every .25 sec.

The race tracks are defined by ASCII files.  Many pre-defined tracks
are supplied.  The desired track is named on the command line. Users
can create their own tracks using any text editor, although this is
not a trivial process unless a CAD program is used to find the exact
lengths, angles, and radii for the track segments.  It is possible to
do it by trial and error, however.

There is a RARS anonymous ftp site: magdanoz.mcafee.com in
directory /bin/ftp/rars.  Anyone can get any RARS stuff there,
code, announcements, car controllers, documentation, and tracks.

There is a listserver so that interested parties may discuss
RARS by e-mail.  To subscribe to the list service send e-mail to

    subscribe rars-list
(To unsubscribe, send "unsubscribe rars-list" to the same address.)

We have a page for the www at http://www.racesimcentral.net/~bsr/rars.html.
Ben Rometsch in England is taking care of the www part of the project.

RARS consists of a simulation of the physics of cars racing on a
track, with a simple bird's-eye view of the race.  The unique feature
is that each car is controlled by a separate and independent control
program.  Each car is "driven" by its own control program, which
receives information from the simulation telling it about the car's
local situation.  The "driver" (control program) adjusts the steering
and throttle, and then the physics simulation moves the car a little.
This happens many times per second, of course.  Every car has exactly
the same physical characteristics, only the "drivers" are different.
Hence, the result is a competition between the control programs.
Furthermore, the competition is visible as an auto race, with
acceleration, passing, cornering, braking, etc.

It is intended that many users will write their own robot "drivers".
Thir*** similar, but not identical, examples are supplied.  These
are meant to serve as examples for programmers wishing to develop
their own.  The control programs may be written in other languages if
they are linker-compatible on the the intended platform.  To date
the robot "driver" programs have used C++ or ANSI C.

For genetic programming, the races will be between several programs
selected from an evolving population of programs.  The racing may
take place continuously for long periods of time, with the graphic
display disabled for faster execution.  Of course losers will be
eliminated and winners will breed.  Genetic Algorithm proponents will
probably design robot drivers with a vector of parameters to be
determined by evolution.  Neural nets are also candidate "drivers".
It will be up to the experimenter to decide if human-designed robots
are allowed to compete with the evolving population.

Wanted - People to do or help with any of the following:

     Porting to other platforms
     Testing the software and suggesting enhancements
     Improving the graphics
     Locating a corporate or university sponsor
     Act as a race director to manage a "race meet"
     Reporting, both to academic journals and popular magazines
     Improving the software in any of dozens of ways
     Adding sound effects
     (and of course, building "drivers" to compete in the races!)

------------------------------------------------------------
Richard Berman                       Vox: (213) 258-7525
Software Technology Service          Fax: (213) 258-9483
3737 Division Street, Los Angeles, CA 90065

------------------------------------------------------------