void
ReInitResults(void)
{
	struct tm *stm;
	time_t t;
	void *results;
	const int BUFSIZE = 1024;
	char buf[BUFSIZE];
	
	t = time(NULL);
	stm = localtime(&t);
	snprintf(buf, BUFSIZE, "%sresults/%s/results-%4d-%02d-%02d-%02d-%02d-%02d.xml",
		GetLocalDir(),
		ReInfo->_reFilename,
		stm->tm_year+1900,
		stm->tm_mon+1,
		stm->tm_mday,
		stm->tm_hour,
		stm->tm_min,
		stm->tm_sec
	);
	
	ReInfo->results = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
	results = ReInfo->results;
	GfParmSetNum(results, RE_SECT_HEADER, RE_ATTR_DATE, NULL, (tdble)t);
	GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1);
	GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1);
	GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_DRIVER, NULL, 1);	
}

// Write parameter data to xml file
int TGeneticParameter::SetVal(void* SetupHandle, int Index)
{
	char ParamSection[64];
	if (Index > 0)
	  sprintf(ParamSection,"%s/%d",Section,Index);
	else
	  sprintf(ParamSection,"%s",Section);

	if (LeftRight)
	{
		char SideParam[64];

		sprintf(SideParam,ParamSection,SECT_PH_LEFT);
		GfParmSetNum(SetupHandle, SideParam, Parameter, Unit, Val, Min, Max);

		sprintf(SideParam,ParamSection,SECT_PH_RGHT);

		if(SameSign)
			return GfParmSetNum(SetupHandle, SideParam, Parameter, Unit, Val, Min, Max);
		else
			return GfParmSetNum(SetupHandle, SideParam, Parameter, Unit, -Val, Min, Max);
	}
	else
		return GfParmSetNum(SetupHandle, ParamSection, Parameter, Unit, Val, Min, Max);
}

// Save the choosen values in the corresponding parameter file.
static void saveSoundOption(void *)
{
	// Force current edit to loose focus (if one has it) and update associated variable.
	GfuiUnSelectCurrent();

	char buf[1024];
	sprintf(buf, "%s%s", GfLocalDir(), SND_PARAM_FILE);
	void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
	GfParmSetStr(paramHandle, SND_SCT_SOUND, SND_ATT_SOUND_STATE, soundOptionList[curOption]);
	GfParmSetNum(paramHandle, SND_SCT_SOUND, SND_ATT_SOUND_VOLUME, "%", VolumeValue);
	GfParmSetStr(paramHandle, SND_SCT_MUSIC, SND_ATT_MUSIC_STATE, musicStateList[curMusicState]);
	GfParmSetNum(paramHandle, SND_SCT_MUSIC, SND_ATT_MUSIC_VOLUME, "%", MusicVolumeValue);

	GfParmWriteFile(NULL, paramHandle, "sound");
	GfParmReleaseHandle(paramHandle);

	 // Shutdown the user interface.
	LegacyMenu::self().shutdown();

    // Restart the game.
    GfuiApp().restart();

	// Return to previous screen.
	GfuiScreenActivate(prevHandle);
}

int
RePostRace(void)
{
	int curRaceIdx;
	void *results = ReInfo->results;
	void *params = ReInfo->params;

	//ReUpdateStandings();

	curRaceIdx = (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1);
	if (curRaceIdx < GfParmGetEltNb(params, RM_SECT_RACES)) {
		curRaceIdx++;
		GfOut("Race Nb %d\n", curRaceIdx);
		GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, curRaceIdx);
		ReUpdateStandings();
		return RM_SYNC | RM_NEXT_RACE;
	}

	ReUpdateStandings();
	GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1);

	taManager->RaceEnd(); // End of race for TA Manager

	return RM_SYNC | RM_NEXT_STEP;
}

void SDScreens::splitScreen(long p){
    switch (p) {
        case SD_SPLIT_ADD:
            if (m_NbActiveScreens < SD_NB_MAX_SCREEN)
                m_NbActiveScreens++;
                if (m_SpanSplit)
                    m_NbArrangeScreens=1;
                else
                    m_NbArrangeScreens=0;
            break;
        case SD_SPLIT_REM:
            if (m_NbActiveScreens > 1)
                m_NbActiveScreens--;
                if (m_SpanSplit)
                    m_NbArrangeScreens=1;
                else
                    m_NbArrangeScreens=0;
            break;
        case SD_SPLIT_ARR:
            m_NbArrangeScreens++;
    }

    // Ensure current screen index stays in the righ range.
    if (m_CurrentScreenIndex >= m_NbActiveScreens)
        m_CurrentScreenIndex = m_NbActiveScreens - 1;

    // Save nb of active screens to user settings.
    GfParmSetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_NB_SCREENS, NULL, m_NbActiveScreens);
    GfParmSetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_ARR_SCREENS, NULL, m_NbArrangeScreens);
    GfParmWriteFile(NULL, grHandle, "Graph");
    AdaptScreenSize();
}

/** 
 * SetFuelAtRaceStart
 * 
 * @param t the track
 * @param carParmHandle handle for car parameters
 * @param s current situation, provided by TORCS
 * @param index index of car in the team
 */
void KStrategy::SetFuelAtRaceStart(const tTrack * const t,
                                    void ** const carParmHandle,
                                    const tSituation * const s,
                                    const int index) {
  // Load and set parameters.
  const tdble fuel_cons_factor =
    GfParmGetNum(*carParmHandle, SECT_ENGINE, PRM_FUELCONS, NULL, 1.0f);
  const double fuel =
    GfParmGetNum(*carParmHandle, KILO_SECT_PRIV, KILO_ATT_FUELPERLAP,
         NULL, t->length * MAX_FUEL_PER_METER * fuel_cons_factor);
  expected_fuel_per_lap_ = fuel;
  // Pittime is pittime without refuel.
  pittime_ = GfParmGetNum(*carParmHandle, KILO_SECT_PRIV,
                            KILO_ATT_PITTIME, NULL, 25.0);
  best_lap_ = GfParmGetNum(*carParmHandle, KILO_SECT_PRIV,
                            KILO_ATT_BESTLAP, NULL, 87.0);
  worst_lap_ = GfParmGetNum(*carParmHandle, KILO_SECT_PRIV,
                            KILO_ATT_WORSTLAP, NULL, 87.0);
  // Fuel tank capacity
  const double maxfuel = GfParmGetNum(*carParmHandle, SECT_CAR,
                                      PRM_TANK, NULL, 100.0);

  // Fuel for the whole race. A race needs one more lap - why???
  const double fuelForRace = (s->_raceType == RM_TYPE_RACE)
    ? (s->_totLaps + 1.0) * fuel
    : s->_totLaps * fuel;

  // Compute race times for min to min + 9 pit stops.
  ComputeBestNumberOfPits(maxfuel, fuelForRace, s->_totLaps, true);
  last_fuel_ = fuel_per_stint_;

  // If the setup defines initial fuel amount, use that value in races.
  // Otherwise use computed amount.
  const double initial_fuel = GfParmGetNum(*carParmHandle, SECT_CAR,
                                            PRM_FUEL, NULL, 0.0);
  if (s->_raceType == RM_TYPE_RACE) {
    if (initial_fuel) {
      GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, NULL, initial_fuel);
    } else {
      // Add fuel dependent on index to avoid fuel stop in the same lap.
      GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, NULL,
                    last_fuel_ + index * expected_fuel_per_lap_);
    }
  } else {
    // Use fuel for whole 'race', ie qualy or practice N laps.
      GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, NULL, fuelForRace);
  }
}   // SetFuelAtRaceStart

// Save the choosen values in the corresponding parameter file.
static void saveSoundOption(void *)
{
	const int BUFSIZE = 1024;
	char buf[BUFSIZE];

	snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GR_SOUND_PARM_CFG);
	void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
	GfParmSetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[curOption]);
	GfParmSetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", VolumeValue);
	GfParmWriteFile(NULL, paramHandle, "sound");
	GfParmReleaseHandle(paramHandle);

	// Write Menu music optons
	snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), MM_SOUND_PARM_CFG);
	paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
	GfParmSetStr(paramHandle, MM_SCT_SOUND, MM_ATT_SOUND_ENABLE, menuMusicList[curOptionMenuMusic]);
	GfParmWriteFile(NULL, paramHandle, "sound");
	GfParmReleaseHandle(paramHandle);
	
	if (curOptionMenuMusic == 1) {
		startMenuMusic();
	} else {
		stopMenuMusic();
	}
	
	// Return to previous screen.
	GfuiScreenActivate(prevHandle);
	return;
}

static void
rmrpValidate(void * /* dummy */)
{
	if (rp->confMask & RM_CONF_RACE_LEN) {
		rmrpUpdDist(0);
		rmrpUpdLaps(0);
		GfParmSetNum(rp->param, rp->title, RM_ATTR_DISTANCE, "km", rmrpDistance);
		GfParmSetNum(rp->param, rp->title, RM_ATTR_LAPS, (char*)NULL, rmrpLaps);
	}

	if (rp->confMask & RM_CONF_DISP_MODE) {
		GfParmSetStr(rp->param, rp->title, RM_ATTR_DISPMODE, rmCurDispModeList[rmCurDispMode]);
	}

	rmrpDeactivate(rp->nextScreen);
}

/* Called for every track change or new race. */
void Driver::initTrack(tTrack* t, void *carHandle, void **carParmHandle, tSituation *s)
{
	track = t;

	char buffer[256];
	/* get a pointer to the first char of the track filename */
	char* trackname = strrchr(track->filename, '/') + 1;

	switch (s->_raceType) {
		case RM_TYPE_PRACTICE:
			sprintf(buffer, "drivers/sparkle/%d/practice/%s", INDEX, trackname);
			break;
		case RM_TYPE_QUALIF:
			sprintf(buffer, "drivers/sparkle/%d/qualifying/%s", INDEX, trackname);
			break;
		case RM_TYPE_RACE:
			sprintf(buffer, "drivers/sparkle/%d/race/%s", INDEX, trackname);
			break;
		default:
			break;
	}

	*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
	if (*carParmHandle == NULL) {
		sprintf(buffer, "drivers/sparkle/%d/default.xml", INDEX);
		*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
    }

	float fuel = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_FUELPERLAP, (char*)NULL, 5.0);
	fuel *= (s->_totLaps + 1.0);
	GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, (char*)NULL, MIN(fuel, 100.0));

	MU_FACTOR = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_MUFACTOR, (char*)NULL, 0.69);
}

/*
 * Function
 *
 *
 * Description
 *	search under drivers/human/tracks/<trackname>/car-<model>-<index>.xml
 *		     drivers/human/car-<model>-<index>.xml
 *		     drivers/human/tracks/<trackname>/car-<model>.xml
 *		     drivers/human/car-<model>.xml
 *
 * Parameters
 *
 *
 * Return
 *
 *
 * Remarks
 *
 */
static void initTrack(int index, tTrack* track, void *carHandle, void **carParmHandle, tSituation *s)
{
	const char *carname;
	const int BUFSIZE = 1024;
	char buf[BUFSIZE];
	char sstring[BUFSIZE];
	tdble fuel;
	int idx = index - 1;

	curTrack = track;

	snprintf(sstring, BUFSIZE, "Robots/index/%d", index);
	snprintf(buf, BUFSIZE, "%sdrivers/human/human.xml", GetLocalDir());
	void *DrvInfo = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
	carname = "";
	if (DrvInfo != NULL) {
		carname = GfParmGetStr(DrvInfo, sstring, "car name", "");
	}

	*carParmHandle = NULL;
	// If session type is "race" and we have a race setup use it
	if (s->_raceType == RM_TYPE_RACE) {
		*carParmHandle = RtParmReadSetup(RACE, "human", index, track->internalname, carname);
	}

	// If session type is "qualifying" and we have a qualifying setup use it, use qualifying setup as 
	// fallback if not race setup is available
	if (s->_raceType == RM_TYPE_QUALIF || (*carParmHandle == NULL && s->_raceType == RM_TYPE_RACE)) {
		*carParmHandle = RtParmReadSetup(QUALIFYING, "human", index, track->internalname, carname);
	}

	// If we have not yet loaded a setup we have not found a fitting one or want to use the practice setup,
	// so try to load this
	if (*carParmHandle == NULL) {
		*carParmHandle = RtParmReadSetup(PRACTICE, "human", index, track->internalname, carname);
	}

	// Absolute fallback, nothing found
	if (*carParmHandle == NULL) {
		snprintf(sstring, BUFSIZE, "%sdrivers/human/car.xml", GetLocalDir ());
		*carParmHandle = GfParmReadFile(sstring, GFPARM_RMODE_REREAD);
	}


	if (curTrack->pits.type != TR_PIT_NONE) {
		snprintf(sstring, BUFSIZE, "%s/%s/%d", HM_SECT_PREF, HM_LIST_DRV, index);
		HCtx[idx]->NbPitStopProg = (int)GfParmGetNum(PrefHdle, sstring, HM_ATT_NBPITS, (char*)NULL, 0);
		GfOut("Player: index %d , Pits stops %d\n", index, HCtx[idx]->NbPitStopProg);
	} else {
		HCtx[idx]->NbPitStopProg = 0;
	}
	fuel = 0.0008 * curTrack->length * (s->_totLaps + 1) / (1.0 + ((tdble)HCtx[idx]->NbPitStopProg)) + 20.0;
	if (*carParmHandle) {
		GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, (char*)NULL, fuel);
	}
	Vtarget = curTrack->pits.speedLimit;
	if (DrvInfo != NULL) {
		GfParmReleaseHandle(DrvInfo);
	}
}

static void
SaveGraphicOptions(void *prevMenu)
{
	sprintf(buf, "%s%s", GetLocalDir(), GR_PARAM_FILE);
	void * grHandle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);

	GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_FOVFACT, "%", FovFactorValue);
	GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_SMOKENB, NULL, SmokeValue);
	GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_MAXSTRIPBYWHEEL, NULL, SkidValue);
	GfParmSetNum(grHandle, GR_SCT_GRAPHIC, GR_ATT_LODFACTOR, NULL, LodFactorValue);
	GfParmWriteFile(NULL, grHandle, "graph");

	GfParmReleaseHandle(grHandle);

	ExitGraphicOptions(prevMenu);
}

static void
reConfigureMenu(void * /* dummy */)
{
    void *params = ReInfo->params;

    /* Reset configuration automaton */
    GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1);
    reConfigRunState();
}

void RaceSet::genXML(){
	std::string path = xmlFolder+"quickrace"+std::to_string(carQty)+".xml";
	void *parmHandle = GfParmReadFile(path.c_str(), GFPARM_RMODE_CREAT);
	int ret =mkdir(folder.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);

	if(ret<0&&errno!=EEXIST){
		std::cout<<"Race failed: Unable to access xml directory"<<std::endl;
		throw 1;
	}

	for(int i=0;i<qty;i++){		
		GfParmSetNum(parmHandle, "Quick Race", "laps", NULL, races[i].laps);
		GfParmSetNum(parmHandle, "Quick Race", "distance", NULL, races[i].distance);
		GfParmSetStr(parmHandle, "Tracks/1", "name", races[i].track.c_str());
		GfParmSetStr(parmHandle, "Tracks/1", "category", races[i].category.c_str());
		GfParmWriteFile((folder+"r"+std::to_string(i)+".xml").c_str(), parmHandle, NULL);
	}
}

void 
SimAeroConfig(tCar *car)
{
    void *hdle = car->params;
    tdble Cx, FrntArea;
    
    Cx       = GfParmGetNum(hdle, SECT_AERODYNAMICS, PRM_CX, (char*)NULL, 0.4);
    FrntArea = GfParmGetNum(hdle, SECT_AERODYNAMICS, PRM_FRNTAREA, (char*)NULL, 2.5);
    car->aero.Clift[0] = GfParmGetNum(hdle, SECT_AERODYNAMICS, PRM_FCL, (char*)NULL, 0.0);
    car->aero.Clift[1] = GfParmGetNum(hdle, SECT_AERODYNAMICS, PRM_RCL, (char*)NULL, 0.0);
    float aero_factor = car->options->aero_factor;

    car->aero.SCx2 = 0.5f * AIR_DENSITY * Cx * FrntArea;
    car->aero.Clift[0] *= aero_factor / 4.0f;
    car->aero.Clift[1] *= aero_factor / 4.0f;
    float max_lift = MaximumLiftGivenDrag (car->aero.SCx2, FrntArea);
    float current_lift = 2.0f * (car->aero.Clift[0] + car->aero.Clift[1]);
    if (current_lift > max_lift) {
        fprintf (stderr, "Warning: car %s, driver %s: lift coefficients (%f, %f), generate a lift of %f, while maximum theoretical value is %f\n",
                 car->carElt->_carName,
                 car->carElt->_name,
                 car->aero.Clift[0],
                 car->aero.Clift[1],
                 current_lift,
                 max_lift);
    }

    GfParmSetNum(hdle, SECT_AERODYNAMICS, PRM_FCL, (char*)NULL, car->aero.Clift[0]);
    GfParmSetNum(hdle, SECT_AERODYNAMICS, PRM_RCL, (char*)NULL, car->aero.Clift[1]);
    //printf ("%f %f\n", GfParmGetNum(hdle, SECT_AERODYNAMICS, PRM_FCL, (char*)NULL, 0.0), GfParmGetNum(hdle, SECT_AERODYNAMICS, PRM_RCL, (char*)NULL, 0.0));
    //printf ("cl: %f\n", car->aero.Clift[0]+car->aero.Clift[1]);
    car->aero.Cd += car->aero.SCx2;
    car->aero.rot_front[0] = 0.0;
    car->aero.rot_front[1] = 0.0;
    car->aero.rot_front[2] = 0.0;
    car->aero.rot_lateral[0] = 0.0;
    car->aero.rot_lateral[1] = 0.0;
    car->aero.rot_lateral[2] = 0.0;
    car->aero.rot_vertical[0] = 0.0;
    car->aero.rot_vertical[1] = 0.0;
    car->aero.rot_vertical[2] = 0.0;

}

// Write table of content to configuration file 
int TGeneticParameterTOC::Set()
{
	GfParmSetStr(Handle, 
		SECT_TOC, PRM_AUTHOR, Author);
	GfParmSetStr(Handle, 
		SECT_TOC, PRM_PRIVATE, Private);
	GfParmSetNum(Handle, 
		SECT_TOC, PRM_LOOPS, 0, (float) OptimisationLoops);
	GfParmSetNum(Handle, 
		SECT_TOC, PRM_DAMAGES, 0, (float) WeightOfDamages);
	if (GetInitialVal)
	  GfParmSetNum(Handle, 
	  	SECT_TOC, PRM_INITIAL, 0, 1);
	else
	  GfParmSetNum(Handle, 
	  	SECT_TOC, PRM_INITIAL, 0, 0);

	return 0;
}; 

static void
reConfigBack(void)
{
    void	*params = ReInfo->params;

    /* Go back one step in the conf */
    GfParmSetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL,
                 GfParmGetNum(params, RM_SECT_CONF, RM_ATTR_CUR_CONF, NULL, 1) - 2);

    reConfigRunState();
}

void
cGrBoard::selectBoard(int val)
{
	sprintf (path, "%s/%d", GR_SCT_DISPMODE, id);
	
	switch (val) {
		case 0:
			boardFlag = (boardFlag + 1) % NB_BOARDS;
			GfParmSetNum(grHandle, path, GR_ATT_BOARD, (char*)NULL, (tdble)boardFlag);
			break;
		case 1:
			counterFlag = (counterFlag + 1) % NB_BOARDS;
			GfParmSetNum(grHandle, path, GR_ATT_COUNTER, (char*)NULL, (tdble)counterFlag);
			break;
		case 2:
			leaderFlag = (leaderFlag + 1) % NB_LBOARDS;
			GfParmSetNum(grHandle, path, GR_ATT_LEADER, (char*)NULL, (tdble)leaderFlag);
			break;
		case 3:
			debugFlag = 1 - debugFlag;
			GfParmSetNum(grHandle, path, GR_ATT_DEBUG, (char*)NULL, (tdble)debugFlag);
			break;	
		case 4:
			GFlag = 1 - GFlag;
			GfParmSetNum(grHandle, path, GR_ATT_GGRAPH, (char*)NULL, (tdble)GFlag);
			break;	
		case 5:
			arcadeFlag = 1 - arcadeFlag;
			GfParmSetNum(grHandle, path, GR_ATT_ARCADE, (char*)NULL, (tdble)arcadeFlag);
			break;	
	}
	GfParmWriteFile(NULL, grHandle, "graph");
}

static void
rmdsSetFocus(void * /* dummy */)
{
    char	*name;
    tDrvElt	*curDrv;

    name = GfuiScrollListGetSelectedElement(scrHandle, selectedScrollList, (void**)&curDrv);
    if (name) {
	GfParmSetStr(ds->param, RM_SECT_DRIVERS, RM_ATTR_FOCUSED, curDrv->dname);
	GfParmSetNum(ds->param, RM_SECT_DRIVERS, RM_ATTR_FOCUSEDIDX, (char*)NULL, curDrv->index);
	GfuiLabelSetText(scrHandle, FocDrvLabelId, curDrv->name);
    }
}

int
ReRaceEnd(void)
{
	int curDrvIdx;
	void *params = ReInfo->params;
	void *results = ReInfo->results;

	ReRaceCleanup();

	if (ReInfo->s->_raceType == RM_TYPE_QUALIF) {
		curDrvIdx = (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_DRIVER, NULL, 1);
		curDrvIdx++;
		if (curDrvIdx > GfParmGetEltNb(params, RM_SECT_DRIVERS)) {
			GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_DRIVER, NULL, 1);
			return ReDisplayResults();
		}
		GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_DRIVER, NULL, curDrvIdx);
		return RM_SYNC | RM_NEXT_RACE;
	}

	return ReDisplayResults();
}

void SimpleStrategy2::setFuelAtRaceStart(tTrack* t, void **carParmHandle, tSituation *s, int index)
{
    // Load and set parameters.
    float consfactor = GfParmGetNum(*carParmHandle, SECT_CAR, PRM_FUELCONS, (char*) NULL, 1.0f);
    float cons2 = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, "FuelCons", (char*) NULL, 1.0f);
    float fuel = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_FUELPERLAP, (char*) NULL, t->length*MAX_FUEL_PER_METER*consfactor*cons2);
    m_expectedfuelperlap = fuel;
    // Pittime is pittime without refuel.
    m_pittime = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_PITTIME, (char*) NULL, 25.0f);
    m_bestlap = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_BESTLAP, (char*) NULL, 87.0f);
    m_worstlap = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_WORSTLAP, (char*) NULL, 87.0f);
    float maxfuel = GfParmGetNum(*carParmHandle, SECT_CAR, PRM_TANK, (char*) NULL, 100.0f);
    PitDamage = (int) GfParmGetNum(*carParmHandle, "private", "PitDamage", (char *)NULL, 5000.0f);

    // Fuel for the whole race.
    float fuelforrace = (s->_totLaps + 1.0f)*fuel;
    // Estimate minimum number of pit stops, -1 because the tank can be filled at the start.
    int pitstopmin = int(ceil(fuelforrace/maxfuel) - 1.0f);
    // Compute race times for min to min + 9 pit stops.
    int i;
    float mintime = FLT_MAX;
    int beststops = pitstopmin;
    m_lastfuel = maxfuel;
    for (i = 0; i < 10; i++)
    {
        float stintfuel = fuelforrace/(pitstopmin + i + 1);
        float fillratio = stintfuel/maxfuel;
        float avglapest = m_bestlap + (m_worstlap - m_bestlap)*fillratio;
        float racetime = (pitstopmin + i)*(m_pittime + stintfuel/8.0f) + s->_totLaps*avglapest;

        if (mintime > racetime)
        {
            mintime = racetime;
            beststops = i + pitstopmin;
            m_lastfuel = stintfuel;
            m_fuelperstint = stintfuel;
        }
    }

    m_remainingstops = beststops;

    fuel = m_lastfuel + m_expectedfuelperlap;
    float ifuel = GfParmGetNum(*carParmHandle, "private", "MaxFuel", (char *)NULL, 0.0f);
    if (ifuel)
        fuel = ifuel;
    ifuel = GfParmGetNum(*carParmHandle, "private", "InitFuel", (char *)NULL, 0.0f);
    if (ifuel)
        fuel = ifuel;
    // Add fuel dependent on index to avoid fuel stop in the same lap.
    GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, (char*) NULL, fuel);
}