• Accurate lap time asked by Remi C.
• A way to draw the trajectory of cars asked by Marc G. (See bulle2.cpp)
• Windows: Correction of the bug in gview2d (Windows) asked by Jussi P.
• Windows: gview2D: improvement of the drawn of the road
• Windows: problem with CreateDIBSection on Windows 98 solved.
• Windows: Include directories are now in the project. VC++ does not need to be configured anymore.
• Linux:  linux_install.sh removed, and new better makefile that uses the directory structure.
• Linux: Source files adapted for the new and better compiler on Linux "egcs 1.1.2".
• Lot of new cars:
• • Apex84
  • Bug
  • Bulle2
  • DGN
  • Djoefe
  • Dodger1
  • Douge1 (new datafile)
  • Felix15
  • JOCOSA82
  • K1999V4
  • SAD01
  • Sparky4
  • Viper2hc

• New friction model available: -s2 gives more realistic friction model, with skidding modelled at high slip speeds. Maximum friction for this model is 1.8, which is more realistic for the race car on paved surface. Try it out. Of course, the robot should be aware that friction is increased if surface == 2 and use shorter braking distance and higher curve speeds.
• New situation data available for driver:
• 
  double fuel_mileage; // miles/lb at last lap
  int laps_to_go; // laps remaining to be completed
  Use that for calculating how much fuel you really need to complete the race. Consider also that the real fuel mileage will depend on the amount of your damage. This is because the air drag is dependent from your damage.
• New leaderboard in DOS and UNIX. More data shown. Rotate between data with 'd' and 'D' keys. Rotate between different speeds with 'a' key. Resize the leaderboard size with constants LEADERS_A and LEADERS_B in file gi.h. Scoreboard is not necessary any more!
• Instrument panel (YELLOW) shows less data (only damage and fuel) at higher display speeds.
• Skidmarks shown only for the single car - the same car that is designated for viewing at instrument panel. Skidmarks switched on/off with capital 'S'. Skidmarking automatically jumps to next car if new designated car is chosen by UP or DOWN arrow. Useful for evaluating trajectories and watching chosen car on track.
• Separate record files for different surfaces: record0.dat, record1.dat, record2.dat.

• help.htm added in Main directory
• Problems with long names solved
• Windows: OpenGL, problem with car colors corrected, 3 mode: full screen, windowed, normal mode.
• Windows: New interface for Movie: Disabled/Record/Replay
• Windows: Resize of the Rars window
• Windows: Rars.ini added to change the default value of the starting windows (laps, cars, ...)
• Correction of colors in driver.cpp
• Bug corrected in CARZ.CPP : line RACEMODE = 0 in RaceManager::AllInit() removed.
• Bug corected in CARZ.CPP line 1057: out_count removed.
• New directory added <movies> with a movie sample.

• Multiple tracks in one run (and season file)
• Race length defined in miles using -l option
• Track records and race fastest lap
• Some car and track data is made non-public
• s.dead_ahead based on braking distance instead of car length
• new active keys 'a', 'b'
• air drag is dependent of damage
• different scoring schemes available (F1, Indy, Nascar, BTCC)
• improved documentation (new tutorial + java applet showing tracks)

• support for Visual C++
• some memory leaks corrected in carz.cpp

• s.starting is initialized (thanks to Kim Laurio)
• A bug fixed in q_avgspeed calculations.
• While qualifying, cars that wouldn't qualify are grey on leaderboard.
• 
  Cars that would qualify in current situation are black.
• Race length in miles and km is reported in outfile.
• Robots will not pit in qualifications by default.

Major changes:
 

• Qualifications have cutoff value defined in car.h. It is currently set to 120%.
• 
  Cars that are slower than (fastest qualification speed / 120%) will not
  participate in race. Also if qualification mode is 2 (this is for average
  speed -q2), cars that could not finish all qualifying laps will not qualify.
   
• Pitting is now allowed in both qualification and practice. Just for reality.
• 
  It can have some point while qualifying for fastest lap. Don't forget disable
  it in your robot code if you DO NOT want to pit. And don't forget to reduce
  fuel load in start of qualifying!
   
• Tracks are read from subdirectory "tracks", so you don't have to copy them to main
• 
  directory. Results will still be printed into main directory.

NEW FEATURES FROM 0.70c to 0.71 (Feb.1998)
<Maido Remm> <email:mremm@ebc.ee>

Three major changes:

• Qualifications
• New structure of main program (RaceManager class etc.)
• build_track() and drawtrack() are separated.

Qualifying can have many separate sessions, controlled by -qs# value.
Qualifying lap count is chosen by -ql# value. Only one of those three
on command line is sufficient to trigger qualifivcation mode.

Default is mode 1, one session for 7 laps. Starting grid is based on
qualifying results. Qualifying speeds are written to report file.

If both practice and qualifications are requested, practice session is
hold before qualificatoions. This would allow practice for learning-capable
cars on unknown or randomly generated track.

Main loop of the program is restructured using ideas of Marc Gueury's
version for Visual C++. See the end of carz.cpp and car.h. I hope this
structure is more logical, easier to understand and modify, if necessary.

 Track data is read and computed by build_track() and track_setup()
in track.cpp. This is called only once in RARS initialization. All drawing
functions are defined void, using global variables from track.cpp.

Minor changes:

• For simplification, lap[] array is merged with new_data[]. This refreshes
• 
  leaderboard if necessary.
• Position[] is calculated within sortem() or qsortem(), together with order[]
• New member of track_description is double seg_dist[] - the distance from
• 
  SF lane to the end of each track segment.
• Race report has a new format, including more statistical data for each car.

Five major changes:

• Pits coded by track file
• Track can be placed at any angle (SF has still to be on straigth)
• Cars are placed from SF line, at desired number of rows and
• 
  the starting row can extend to previous curve(s).
• Cars can start with any fuel load and can refuel only in pits
• Drivers and their colors are defined in separate file: drivers.cpp

if (s.starting) result.fuel_amount = MAX_FUEL;  // to define initial fuel load
result.request_pit = 0;                          // normally we do not go to pits
if (s.damage > 25000 || s.fuel < 10) {           // if necessary:
  result.request_pit = 1;                        // enter pit road
  result.repair_amount=s.damage;                 // repair all
  result.fuel_amount = MAX_FUEL;                 // refuel full tank!
}

PIT_SIDE (+1 is right, -1 is left)
PIT_ENTRY PITLANE_START
PITLANE_END PIT_EXIT
PITLANE_SPEED (fps)

• s.distance is zero at SF line (used to be at start of first segment)
• These data (and track length) is accesible to drivers by
• 
  get_track_description() function.

• Track start angle and starting rows are defined by track file in:

TRK_STRT_X TRK_STRT_Y TRK_STRT_ANG (4th line)
and
FINISH START_ROWS (9th line)

As Ralph suggested, trackin and trackout structures are renamed to
lftwall and rgtwall, accordingly. Remember that track file defines
rgtwall! Old robots will work with trackin and trackout if they get
track description through get_track_description().

Wappucar needed a slight 'repair'.

Minor changes

For drivers important changes are in situation structure:

• s.nearby[i].coming_from_pits (is set when car is less than 200 feets
• 
  from pit exit. Designed for safety purposes - you will know that this car
  can soon cross your way)
• s.out_pits (use that if you want do special calculations for speed while
• 
  still kept close to track wall by main program for 300 feets after exit)

• out // set 1 when out, 2 if in pits
• done // 1 if finished race
• laps // how many laps completed
• seg_id // located at which segment
• distance // how many feets travelled from SF line
• started // starting position
• pit_stops // how many?
• last_pit_visit // at end of which lap?
• on_pit_lane // whether car is on pit lane (disappears from s.nearby)
• pitting //standing in pits
• coming_from_pits //just to appear on track (shown again in s.nearby)
• best_lap_speed // in fps
• last_lap_speed // in fps
• laps_lead // increases if lead at SF crossing
• lap_time // last lap time in seconds
• behind_leader // in seconds

BTW, there was a bug in older versions that spoiled s.distance values.
As s.distance was used in s.nearby also, this caused some strange
errors in collision avoidance functions, some close cars not being
reported while at different segment than our car.

Another bug was repaired average speed was sometimes not correlated with
car positions because time was calculated from moment when given car first
time crossed SF lane (start_time). It is now calculated from race start
(time_count = 0), which is the same for all cars.

All physical constants, including maximum friction (MYU_MAX), are now
defined in car.h and accessible to all cars. This comes handy if we want
to change them or make different leagues for F1, BTCC, Indy, rally. I also
put the suggested F1 values on comment line (friction being 1.8g from tyres
only, downforce can add 2-2.5g to that). I would like to see lighter
and more powerful cars with higher max fuel load. This would make fuel
strategy more important. But this needs major recoding in all cars.

May be we should just keep that in mind and include those physical
definitions in our curvespeed and brakedistance calculations.

STARTING SPEED is reduced to 20 fps because many cars now start on curve.

Length is again calculated as average of inner and outer rails.
Length calculation is removed from draw.cpp to track.cpp where it
naturally belongs.

Number of pit stops are reported in report file.

Instrument panel now shows also damage, fuel and behind leader values.

Race number is shown on scoreboard.

Cars are shown 1.5 x larger than actual size. All changes for that are
in drawcar() in draw.cpp.

Some ideas of Henning Klaskala included:

• MAX_LEADERS defines number of leaders on leaderboard. See gi.h
• draw.cpp uses sprintf() instead of make_dec_string()
• Drivers that are out of race are marked different color (TRACK_COLOR)
• 
  on scoreboard and leaderboard. Leaderboard also shows cars red while
  they are on pit lane

NEW FEATURES FROM 0.65b to 0.67 (Nov.1997)
Torben Thellefsen <torben@dir.dk>

• Added the pitting code used in Ralph Scott's tournament.
• Added default pitting code to all drivers.
• Fixed up the makefile.
• Everything now compiles without errors or warnings on Linux.
• Moved definitions of car colours to carz.cpp.
• Fixed various little things.

• Added "random track" feature - specify "random" as your track and watch...
• Fixed several things about floodfills.
• Speeded up floodfills in Linux considerably.

• Additions to s.nearby (5 cars seen)
• Semielastic collisions
• Sideview mirrors
• Collision flash
• Movie recording

The following are new features of, or changes in, version 0.64 as compared with version 0.50:
 
 

• For the start of the race the cars are arranged so that only the back
• 
  row might have other than four cars. (It was the front row.)
• The collision code has been changed so that collisions are more
• 
  realistic. Cars cannot run over or through each other any more.
• A command line option has been added that lets you name a driver or
• 
  drivers that you don't want to race. It is -D and is used very much
  like -d. Here is the command to race all robots except Indretti for
  ten laps on the oval2 track:

  rars oval2 15 10 -D Indretti

• The P key is now a pause key; it freezes the race. Any key restarts it.
• The name of the public random variable generator, which the robots
• 
  should use if they need one, has been changed to r_rand(). Its
  declaration is in CAR.H.
• There is a fuel variable, and cars can run out of fuel. With the
• 
  current parameter values a car can travel anywhere from 50 to over
  100 miles depending on the track and the robot's style. The cars
  start with 150 pounds of fuel. This is used up at a rate
  proportional to power level. No fuel is used during braking. When a
  car runs out of fuel it will be automatically parked, frozen for 12
  seconds of simulated time, and then re-started with the initial fuel
  supply restored. The car will have somewhat greater acceleration
  with a near-empty tank because the total weight of car+fuel is used
  in the physical model. The car with a full tank weighs about the
  same as the car in version 0.50. Finally, s.fuel tells the robot how
  much fuel is left.
• There are several changes to the output file of race results. Its
• 
  name, instead of RACE.OUT will be the same as the track file's name,
  but with the .OUT extension. The number of laps completed, the fuel
  remaining, and the number of damage units is reported for each car.
• Finally, the seed used for the random variable generator is
• 
  reported. (see next item)
• We have a new way to replay a race. The user can enter a seed for
• 
  the random variable generator. If the seed that was reported in the
  output file is entered, then that race will be duplicated. Hence we
  have a way for a remote RARS fan to replay a race. If he has the
  output file, and the robots, and the same RARS version, he can enter
  the seed and see the same race. The seed is entered immediately
  after the -nr option, with no space. (example: RARS OVAL2 16 20 -nr3791)
• Also, the robots must be listed in CARZ.CPP in the same order that
• 
  they appear at the top of the race output file.
• There is one more source file, called MISC.CPP. It just has a few
• 
  miscellaneous function definitions. Its purpose was just to keep
  CARZ.CPP from growing any larger.
• When multiple race are run the track rails are redrawn prior to each race.
• The maximum rate-of-change of alpha has been decreased from 263
• 
   

   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

  deg/sec to 183 deg/sec.

• if a car is damaged only by collisions, and never leaves the road, it
• 
  will be forced to drive off the track and then be out of the race.
• Also, there is somewhat more damage per collision. The damage from
• 
  either collisions or off-road adventures is still accumulated in one
  variable, "damage". What is different is that damage is checked
  after every collision, not just when off-road. During practice the
  cars may accumulate any amount of damage and not be out of the race.
  ("damage" has been made into a long to accomodate that.)
• The robot code does not have to use the "extern" keyword to directly
• 
  access the track description information, nor to copy its name to the
  host. Two functions, get_track_description() and my_name_is(), are
  provided for those purposes.
• The large model is now used for compiling. Also, I am using full
• 
  optimization for speed.
• There is an optional pre-race practice period, requested by the -p
• 
  option. When the command line contains, say, -p50, there will be 50
  practice laps. During practice the damage can grow indefinitely; it
  will be "repaired" when the race starts.
• There is 4 K of private data for each robot instead of 512 bytes.
• The track files now must all have one more line added containing the
• 
  coordinates of the upper left corner of the Instrument Panel. The IP
  can now be place anywhere on the screen. This line goes right after
  the Leader Board coordinates.
• The build_track() function has been changed to ignore any characters
• 
  after the one or two numbers it expects to read from each line. This
  means that any type of commentary or other text may be placed to the
  right of the track definition data.
• In place of the track length in feet, we now show it in miles, and also
• 
  show the name of the track description file being used.
• There are two random variable generators. rand() is for use by
• 
  robots who want to use it. The inline version, raand() is used by
  the host software (in CARZ.CPP) random() should no longer be used by
  any robots. The -nr or -nR options affect both functions.
• There are now two alternate track friction functions. The old one is
• 
  the default. The new one is selected by -s1 on the command line.
• A better mathematical method is now used for integrating the differential
• 
  equations of the trajectories. It is called the Adam's second order open
  method. This affects the characteristics of the cars slightly. It may
  improve some of the robots and worsen some others; they should all be
  retuned if optimal performance is desired.
• The IP is now not erased if it has not been displayed. Since some tracks
• 
  don't have a space for it, it can now simply not be used, if desired, and
  it won't mess up the track display.
• The situation structure is now passed to the robots by reference instead of
• 
  by value. For C++ robots that only means that an "&" must follow
  "situation" in the function definition. For those that are written in
• ANSI C instead of C++ it means that they will receive a pointer to the
• 
  situation structure. They will use an "*" after "situation" and must
  change all of their dots to -> when using the situation members.
• To avoid name conflicts, functions defined in the robot files should
• 
  be made static. (This does not apply to the primary function which
  is called by the host, since the static keyword makes the name
  not public.) This has been done throughout most of the supplied
  robots.