void SimpleStrategy::updateFuelStrategy(tCarElt* car, tSituation *s)
{
double requiredfuel;
/* Required additional fuel for the rest of the race. +1 because
the computation happens right after crossing the start line. */
//requiredfuel = ((car->_remainingLaps + 1) - ceil(car->_fuel/fuelPerLap))*fuelPerLap;
requiredfuel = ((car->_remainingLaps + 1) *fuelPerLap) - ceil(car->_fuel);
if (!m_checkFuel && requiredfuel <= 0.0f && car->_remainingLaps <= 5)
{
// We have enough fuel to end the race, no further stop required.
GfOut("%s No Pitstop required > carFuel:%.2f, remLap:%d\n", car->_name,car->_fuel, car->_remainingLaps);
m_checkFuel = true;
return;
}
// We don't have enough fuel to end the race need at least one stop.
if (!m_checkFuel && requiredfuel > 0.0f && car->_fuel < fuelPerLap * 3.0)
{
GfOut("%s Pitstop needed to refuel >> reqFuel: %.2f, carFuel: %.2f, remLap: %d\n",
car->_name, requiredfuel, car->_fuel, car->_remainingLaps);
m_checkFuel = true;
}
return;
}
void
grShutdownSound(int ncars)
{
GfOut("-- grShutdownSound\n");
if (sound_mode == DISABLED) {
return;
}
int i;
for (i = 0; i < ncars; i++) {
delete car_sound_data[i];
}
delete [] car_sound_data;
if (!soundInitialized) {
return;
}
soundInitialized = 0;
delete sound_interface;
if (__slPendingError) {
GfOut("!!! error ignored: %s\n", __slPendingError);
__slPendingError = 0; /* ARG!!! ugly ugly bad thing... but should not occur anymore now */
}
}
bool SDScenery::LoadTrack(std::string strTrack)
{
char buf[256];
GfOut("Chemin Track : %s\n", strTrack.c_str());
osgLoader loader;
GfOut("Chemin Textures : %s\n", _strTexturePath.c_str());
loader.AddSearchPath(_strTexturePath);
std::string strTPath = GetDataDir();
snprintf(buf, 256, "data/textures/");
strTPath += buf;
loader.AddSearchPath(strTPath);
osg::Node *pTrack = loader.Load3dFile(strTrack, false);
if (pTrack)
{
pTrack->getOrCreateStateSet()->setRenderBinDetails(TRACKBIN,"RenderBin");
_scenery->addChild(pTrack);
#if 0
std::string Tpath = GetLocalDir();
Tpath = Tpath+"/track.osg";
osgDB::writeNodeFile( *pTrack, Tpath);
#endif
}
else
return false;
return true;
}
//==========================================================================*
// Is pit available?
//--------------------------------------------------------------------------*
bool TBaseStrategy::IsPitFree()
{
bool IsFree = RtTeamIsPitFree(oDriver->oTeamIndex);
if (IsFree)
GfOut("#%s pit is free (%d)\n",oDriver->GetBotName(),oDriver->oTeamIndex);
else
GfOut("#%s pit is locked (%d)\n",oDriver->GetBotName(),oDriver->oTeamIndex);
return IsFree;
}
void
shutdownCars(void)
{
int i;
GfOut("-- shutdownCars\n");
grShutdownSound(grNbCars);
if (grNbCars) {
grShutdownBoardCar();
grShutdownSkidmarks();
grShutdownSmoke();
grShudownCarlight();
/* Delete ssg objects */
CarsAnchor->removeAllKids();
ShadowAnchor->removeAllKids();
for (i = 0; i < grNbCars; i++) {
ssgDeRefDelete(grCarInfo[i].envSelector);
ssgDeRefDelete(grCarInfo[i].shadowBase);
ssgDeRefDelete(grCarInfo[i].wheelTexture);
if (grCarInfo[i].driverSelectorinsg == false) {
delete grCarInfo[i].driverSelector;
}
}
PitsAnchor->removeAllKids();
ThePits = 0;
free(grCarInfo);
}
GfParmReleaseHandle(grHandle);
for (i = 0; i < GR_NB_MAX_SCREEN; i++) {
grScreens[i]->setCurrentCar(NULL);
}
}
/*
* Function
* windowsModUnloadList
*
* Description
* Unload the modules of a list
*
* Parameters
* modlist list of modules to unload
*
* Return
* 0 Ok
* -1 Error
*
* Remarks
*
*/
static int windowsModUnloadList(tModList **modlist)
{
tModList *curMod;
tModList *nextMod;
curMod = *modlist;
if (curMod == 0) {
return 0;
}
nextMod = curMod->next;
do {
curMod = nextMod;
nextMod = curMod->next;
GfOut("<<< %s unloaded <<<\n", curMod->sopath);
FreeLibrary(curMod->handle);
int i;
for (i = 0; i < MAX_MOD_ITF; i++) {
if (curMod->modInfo[i].name) {
free(curMod->modInfo[i].name);
free(curMod->modInfo[i].desc);
}
}
free(curMod->sopath);
free(curMod);
} while (curMod != *modlist);
*modlist = (tModList *)NULL;
return 0;
}
/** remove the smoke information for a car */
void grShutdownSmoke ()
{
tgrSmoke *tmp, *tmp2;
GfOut("-- grShutdownSmoke\n");
if (!grSmokeMaxNumber) {
return;
}
SmokeAnchor->removeAllKids();
if (smokeManager) {
tmp = smokeManager->smokeList;
while( tmp!=NULL)
{
tmp2 = tmp->next;
/* SmokeAnchor->removeKid(tmp->smoke); */
free(tmp);
tmp = tmp2;
}
smokeManager->smokeList = NULL;
free(timeSmoke);
free(timeFire);
free(smokeManager);
smokeManager = 0;
smokeManager = NULL;
timeSmoke = NULL;
timeFire=NULL;
}
}
void
SimEngineShutdown(tCar *car)
{
free(car->engine.curve.data);
//GfOut("#Total Time CalculateTorque used: %g sec\n",SimTicks/1000.0);
GfOut("#Total Time CalculateTorque2 used: %g sec\n",SimTicks2/1000.0); // Profiling test
}
void ClothoidPath::OptimiseLine( const CarModel& cm, int idx, int step, double hLimit, PathPt* l3, const PathPt* l2, const PathPt* l4 )
{
LinearRegression l;
const int NSEG = m_pTrack->GetSize();
int i = (idx + NSEG - step) % NSEG;
while( m_pPath[i].h > hLimit )
{
l.Sample( m_pPath[i].pt.GetXY() );
i = (i + NSEG - step) % NSEG;
}
l.Sample( m_pPath[i].pt.GetXY() );
i = idx;
while( m_pPath[i].h > hLimit )
{
l.Sample( m_pPath[i].pt.GetXY() );
i = (i + step) % NSEG;
}
l.Sample( m_pPath[i].pt.GetXY() );
GfOut( "%4d ", idx );
Vec2d p, v;
l.CalcLine( p, v );
double t;
Utils::LineCrossesLine( l3->Pt().GetXY(), l3->Norm().GetXY(), p, v, t );
SetOffset( cm, 0, t, l3, l2, l4 );
}
void
TlmStartMonitoring(const char *filename)
{
const int BUFSIZE = 1024;
char buf[BUFSIZE];
FILE *fout;
FILE *fcmd;
tChannel *curChan;
int i;
GfOut("Telemetry: start monitoring\n");
snprintf(buf, BUFSIZE, "telemetry/%s.cmd", filename);
fcmd = fopen(buf, "w");
if (fcmd == NULL) {
return;
}
fprintf(fcmd, "#!/bin/sh\n");
fprintf(fcmd, "gnuplot -persist > telemetry/%s.png <<!!\n", filename);
fprintf(fcmd, "# set yrange [%f:%f]\n", TlmData.ymin, TlmData.ymax);
fprintf(fcmd, " set grid\n");
fprintf(fcmd, " set size 2.5,1.5\n");
fprintf(fcmd, " set terminal png color\n");
fprintf(fcmd, " set data style lines\n");
curChan = TlmData.chanList;
if (curChan != NULL) {
i = 2;
do {
curChan = curChan->next;
if (i == 2) {
fprintf(fcmd, "plot 'telemetry/%s.dat' using %d title '%s'", filename, i, curChan->name);
} else {
fprintf(fcmd, ", '' using %d title '%s'", i, curChan->name);
}
i++;
} while (curChan != TlmData.chanList);
fprintf(fcmd, "\n");
}
fprintf(fcmd, "!!\n");
fclose(fcmd);
TlmData.cmdfile = strdup(buf);
snprintf(buf, BUFSIZE, "telemetry/%s.dat", filename);
fout = TlmData.file = fopen(buf, "w");
if (fout == NULL) {
return;
}
curChan = TlmData.chanList;
fprintf(fout, "time");
if (curChan != NULL) {
do {
curChan = curChan->next;
fprintf(fout, " %s", curChan->name);
} while (curChan != TlmData.chanList);
fprintf(fout, "\n");
}
TlmData.state = 1;
}
/*
* 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);
}
}
/**
@ingroup racemantools
@param text Text to display.
@return None.
*/
void
RmLoadingScreenSetText(char *text)
{
int i, j;
GfOut("%s\n", text);
if (menuHandle) {
if (rmTextLines[rmCurText]) {
free(rmTextLines[rmCurText]);
}
if (text) {
rmTextLines[rmCurText] = strdup(text);
rmCurText = (rmCurText + 1) % TEXTLINES;
}
i = rmCurText;
j = 0;
do {
if (rmTextLines[i]) {
GfuiLabelSetText(menuHandle, rmTextId[j], rmTextLines[i]);
}
j++;
i = (i + 1) % TEXTLINES;
} while (i != rmCurText);
GfuiDisplay();
}
}
ssgState * grSsgEnvTexState(const char *img)
{
const int BUFSIZE = 1024;
char buf[BUFSIZE];
const char *s;
grManagedState *st;
// remove the directory
s = strrchr(img, '/');
if (s == NULL) {
s = img;
} else {
s++;
}
if (!grGetFilename(s, grFilePath, buf, BUFSIZE)) {
GfOut("grSsgLoadTexState: File %s not found\n", s);
return NULL;
}
/*st = grGetState(buf);
if (st != NULL) {
return (ssgState*)st;
}*/
st = new grMultiTexState();
grSetupState(st, buf);
st->setTexture(buf);
return (ssgState*)st;
}
ssgState *
grSsgLoadTexStateEx(char *img, char *filepath, int wrap, int mipmap)
{
char buf[256];
char *s;
grManagedState *st;
// remove the directory
s = strrchr(img, '/');
if (s == NULL) {
s = img;
} else {
s++;
}
if (!grGetFilename(s, filepath, buf)) {
GfOut("File %s not found\n", s);
return NULL;
}
st = grGetState(buf);
if (st != NULL) {
return (ssgState*)st;
}
st = grStateFactory();
grSetupState(st, buf);
st->setTexture(buf, wrap, wrap, mipmap);
return (ssgState*)st;
}
/*
* Function
* GfModTerminate
*
* Description
* Terminate the module with given handle and library file path
*
* Parameters
* soHandle (in) handle of the loaded shared library
* soPath (in) path of the loaded shared library
*
* Return
* 0 if termination succeeded
* -1 if any error occured
*
* Remarks
*
*/
int GfModTerminate(tSOHandle soHandle, const char *soPath)
{
tfModInfoTerminate fModInfoTerm; /* Termination function of the module */
int termSts = 0; /* Returned status */
/* Get the module termination function if any :
1) Try the new sheme (fixed name) */
if ((fModInfoTerm = (tfModInfoTerminate)dlsym(SOHandle(soHandle), GfModInfoTerminateFuncName)) == 0)
{
/* 2) Backward compatibility (dll name + "Shut") */
char soName[256];
const char* lastSlash = strrchr(soPath, '/');
if (lastSlash)
strcpy(soName, lastSlash+1);
else
strcpy(soName, soPath);
strcpy(&soName[strlen(soName) - SOFileExtLen], "Shut"); /* cut so file ext */
fModInfoTerm = (tfModInfoTerminate)dlsym(SOHandle(soHandle), soName);
}
/* Call the module termination function if any */
if (fModInfoTerm)
termSts = fModInfoTerm();
GfOut("Terminated module %s\n", soPath);
return termSts;
}
/** remove the skidmarks information for a car */
void grShutdownSkidmarks (void)
{
int i;
int z;
GfOut("-- grShutdownSkidmarks\n");
if (!grSkidMaxStripByWheel) {
return;
}
SkidAnchor->removeAllKids();
for (z = 0; z < grNbCars; z++) {
for (i = 0; i<4; i++) {
free(grCarInfo[z].skidmarks->strips[i].vtx);
free(grCarInfo[z].skidmarks->strips[i].vta);
free(grCarInfo[z].skidmarks->strips[i].tex);
free(grCarInfo[z].skidmarks->strips[i].state);
free(grCarInfo[z].skidmarks->strips[i].size);
free(grCarInfo[z].skidmarks->strips[i].clr);
}
free(grCarInfo[z].skidmarks);
grCarInfo[z].skidmarks = NULL;
}
skidState = NULL;
}
ssgState * grSsgEnvTexState(char *img)
{
char buf[256];
char *s;
grMultiTexState *st;
// remove the directory
s = strrchr(img, '/');
if (s == NULL) {
s = img;
} else {
s++;
}
if (!grGetFilename(s, grFilePath, buf)) {
GfOut("grSsgLoadTexState: File %s not found\n", s);
return NULL;
}
st = new grMultiTexState;
grSetupState(st, buf);
st->setTexture(buf);
return (ssgState*)st;
}
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
TlmStopMonitoring(void)
{
char buf[256];
if (TlmData.state == 1) {
fclose(TlmData.file);
}
TlmData.file = (FILE*)NULL;
TlmData.state = 0;
GfOut("Telemetry: stop monitoring\n");
sprintf(buf, "sh %s", TlmData.cmdfile);
if(system(buf) < 0)
GfOut("Telemetry: calling shell script failed");
free(TlmData.cmdfile);
}
static void
reSelectLoadFile(char *filename)
{
sprintf(buf, "%sresults/%s/%s", GetLocalDir(), ReInfo->_reFilename, filename);
GfOut("Loading Saved File %s...\n", buf);
ReInfo->results = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
ReInfo->_reRaceName = ReInfo->_reName;
RmShowStandings(ReInfo->_reGameScreen, ReInfo);
}
static void
rmNetworkClientDisconnect(void * /* dummy */)
{
GfOut("Disconnecting from server\n");
if (NetGetClient())
NetGetClient()->Disconnect();
GfuiScreenActivate(RmRaceSelectMenuHandle);
}
bool SimpleStrategy::isPitFree(tCarElt* car)
{
#ifdef SPEED_DREAMS
bool IsFree = RtTeamIsPitFree(teamIndex);
if (IsFree)
GfOut("#%s pit is free (%d)\n",car->_name,teamIndex);
else
GfOut("#%s pit is locked (%d)\n",car->_name,teamIndex);
return IsFree;
#else
if (car->_pit != NULL) {
if (car->_pit->pitCarIndex == TR_PIT_STATE_FREE) {
return true;
}
}
return false;
#endif
}
/* Race Engine Initialization */
void
ReInit(void)
{
char *dllname;
char key[256];
tRmMovieCapture *capture;
ReShutdown();
ReInfo = (tRmInfo *)calloc(1, sizeof(tRmInfo));
ReInfo->s = (tSituation *)calloc(1, sizeof(tSituation));
ReInfo->modList = &ReRaceModList;
char buf[1024];
snprintf(buf, 1024, "%s%s", GetLocalDir(), RACE_ENG_CFG);
ReInfo->_reParam = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
GfOut("Loading Track Loader...\n");
dllname = GfParmGetStr(ReInfo->_reParam, "Modules", "track", "");
sprintf(key, "%smodules/track/%s.%s", GetLibDir (), dllname, DLLEXT);
if (GfModLoad(0, key, &reEventModList)) return;
reEventModList->modInfo->fctInit(reEventModList->modInfo->index, &ReInfo->_reTrackItf);
GfOut("Loading Graphic Engine...\n");
dllname = GfParmGetStr(ReInfo->_reParam, "Modules", "graphic", "");
sprintf(key, "%smodules/graphic/%s.%s", GetLibDir (), dllname, DLLEXT);
if (GfModLoad(0, key, &reEventModList)) return;
reEventModList->modInfo->fctInit(reEventModList->modInfo->index, &ReInfo->_reGraphicItf);
capture = &(ReInfo->movieCapture);
if (strcmp(GfParmGetStr(ReInfo->_reParam, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_ENABLE, "no"), "no") == 0){
capture->enabled = 0;
} else {
capture->enabled = 1;
capture->state = 0;
capture->deltaFrame = 1.0 / GfParmGetNum(ReInfo->_reParam, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_FPS, NULL, 1.0);
capture->outputBase = GfParmGetStr(ReInfo->_reParam, RM_SECT_MOVIE_CAPTURE, RM_ATT_CAPTURE_OUT_DIR, "/tmp");
capture->deltaSimu = RCM_MAX_DT_SIMU;
}
ReInfo->_reGameScreen = ReHookInit();
}
int grGetFilename(const char *filename, char *filepath, char *buf, const int BUFSIZE)
{
char *c1, *c2;
int found = 0;
int lg;
int flen = strlen(filename);
if (filepath) {
c1 = filepath;
c2 = c1;
while ((!found) && (c2 != NULL)) {
c2 = strchr(c1, ';');
if (c2 == NULL) {
snprintf(buf, BUFSIZE, "%s/%s", c1, filename);
} else {
lg = c2 - c1;
if (lg + flen + 2 < BUFSIZE) {
strncpy(buf, c1, lg);
buf[lg] = '/';
strcpy(buf + lg + 1, filename);
} else {
buf[0] = '\0';
}
}
if (ulFileExists(buf)) {
found = 1;
}
c1 = c2 + 1;
}
} else {
strncpy(buf, filename, BUFSIZE);
if (ulFileExists(buf)) {
found = 1;
}
}
if (!found) {
GfOut("File %s not found\n", filename);
GfOut("File Path was %s\n", filepath);
return 0;
}
return 1;
}
// Module entry point (new fixed name scheme).
extern "C" int moduleInitialize(tModInfo *modInfo)
{
GfOut("\n\nusr::moduleInitialize, from %s ...\n", xml_path);
GfOut("NBBOTS: %d (of %d)\n", NBBOTS, MAXNBBOTS);
// Clear all structures.
memset(modInfo, 0, NBBOTS*sizeof(tModInfo));
int i;
for (i = 0; i < NBBOTS; ++i)
{
modInfo[i].name = &DriverNames[i * DRIVERLEN];
modInfo[i].desc = &DriverDescs[i * DRIVERLEN];
modInfo[i].fctInit = InitFuncPt; // Init function.
modInfo[i].gfId = ROB_IDENT; // Supported framework version.
modInfo[i].index = i + indexOffset; // Indices depend on xml-file
}
GfOut("... Initialized %d from %s\n\n\n", i, xml_path);
return 0;
}
/*
* Function
* windowsDirGetListFiltered
*
* Description
* Get a list of entries in a directory
*
* Parameters
* directory name
*
* Return
* list of directory entries
*/
static tFList *windowsDirGetListFiltered(const char *dir, const char *suffix)
{
tFList *flist = NULL;
tFList *curf;
int suffixLg;
int fnameLg;
if ((suffix == NULL) || (strlen(suffix) == 0))
return windowsDirGetList(dir);
suffixLg = strlen(suffix);
_finddata_t FData;
char Dir_name[ 1024 ];
sprintf( Dir_name, "%s\\*.*", dir );
GfOut("trying dir %s\n",dir);
long Dirent = _findfirst( Dir_name, &FData );
if ( Dirent != -1 ) {
do {
fnameLg = strlen(FData.name);
if ((fnameLg > suffixLg) && (strcmp(FData.name + fnameLg - suffixLg, suffix) == 0)) {
curf = (tFList*)calloc(1, sizeof(tFList));
curf->name = strdup(FData.name);
if (flist == (tFList*)NULL) {
curf->next = curf;
curf->prev = curf;
flist = curf;
} else {
/* sort entries... */
if (_stricmp(curf->name, flist->name) > 0) {
do {
flist = flist->next;
} while ((stricmp(curf->name, flist->name) > 0) && (stricmp(flist->name, flist->prev->name) > 0));
flist = flist->prev;
} else {
do {
flist = flist->prev;
} while ((stricmp(curf->name, flist->name) < 0) && (stricmp(flist->name, flist->next->name) < 0));
}
curf->next = flist->next;
flist->next = curf;
curf->prev = curf->next->prev;
curf->next->prev = curf;
flist = curf;
}
}
} while ( _findnext( Dirent, &FData ) != -1 );
}
return flist;
}
//==========================================================================*
// Refueling
//--------------------------------------------------------------------------*
float TBaseStrategy::PitRefuel()
{
float FuelConsum; // Spritverbrauch kg/m
float Fuel; // Menge in kg
GfOut("# Fuel consumption: %0.5f kg/m\n",oFuelPerM);
if (oFuelPerM == 0.0) // Wenn kein Messwert
FuelConsum = oExpectedFuelPerM; // vorliegt, schätzen
else // ansonsten
FuelConsum = oFuelPerM; // Messwert nehmen
GfOut("# Fuel consumption: %0.5f kg/m\n",FuelConsum);
FuelConsum *= oDriver->oScaleRefuel; // ggf. ohne Windschatten!
GfOut("# Fuel consumption: %0.5f kg/m\n",FuelConsum);
oRemainingDistance = // Restliche Strecke des
oRaceDistance - CarDistanceRaced; // Rennens ermitteln
GfOut("# Remaining distance: %0.5f m\n",oRemainingDistance);
Fuel = // Bedarf an Treibstoff
(oRemainingDistance + oReserve) * FuelConsum;// für restliche Strecke
GfOut("# Fuel : %0.5f kg\n",Fuel);
GfOut("# Tank capacity: %0.5f kg\n",oMaxFuel);
if (Fuel > oMaxFuel) // Wenn mehr als eine Tank-
{ // füllung benötigt wird
if (Fuel / 2 < oMaxFuel) // Bei zwei Tankfüllungen
Fuel = Fuel / 2; // die Hälfte tanken
else if (Fuel / 3 < oMaxFuel) // Bei drei Tankfüllungen.
Fuel = Fuel / 3; // ein Drittel tanken
else if (Fuel / 4 < oMaxFuel) // Bei vier Tankfüllungen.
Fuel = Fuel / 4; // ein Viertel tanken
else // Bei fünf Tankfüllungen
Fuel = Fuel / 5; // ein Fünftel tanken
}
GfOut("# Fuel : %0.5f kg\n",Fuel);
if (Fuel > oMaxFuel - CarFuel) // Menge ggf. auf freien
Fuel = oMaxFuel - CarFuel; // Tankinhalt begrenzen
else // ansonsten Bedarf
Fuel = Fuel - CarFuel; // abzügl. Tankinhalt
oLastPitFuel = (float) MAX(Fuel,0.0); // Wenn genug da ist = 0.0
GfOut("# Fuel : %0.5f kg\n",oLastPitFuel);
return oLastPitFuel; // Menge an TORCS melden
};
static void
reMovieCapture(void * /* dummy */)
{
tRmMovieCapture *capture = &(ReInfo->movieCapture);
if (!capture->enabled || (ReInfo->_displayMode == RM_DISP_MODE_NONE)) {
GfOut("Video Capture Mode Not Enabled\n");
return;
}
capture->state = 1 - capture->state;
if (capture->state) {
GfOut("Video Capture Mode On\n");
capture->currentFrame = 0;
capture->currentCapture++;
capture->lastFrame = GfTimeClock() - capture->deltaFrame;
ReInfo->_displayMode = RM_DISP_MODE_CAPTURE;
} else {
GfOut("Video Capture Mode Off\n");
ReInfo->_displayMode = RM_DISP_MODE_NORMAL;
ReStart();
}
}
/** Initialization of a telemetry session.
@ingroup telemetry
@param ymin Minimum value for Y.
@param ymax Maximum value for Y.
@return None
*/
void RtTelemInit(tdble ymin, tdble ymax)
{
#ifdef later
char buf[256];
tModInfoNC *curModInfo;
memset(&tlm, 0, sizeof(tTelemItf));
sprintf(buf, "%smodules/telemetry/%s.%s", "telemetry", GfLibDir (), DLLEXT);
if (GfModLoad(TLM_IDENT, buf, &modlist)) return;
GfOut("--- %s loaded ---\n", modlist->modInfo->name);
curModInfo = modlist->modInfo;
curModInfo->fctInit(curModInfo->index, &tlm);
tlm.init(ymin, ymax);
#endif
}
static void grSetupState(grManagedState *st, char *buf)
{
st->ref(); // cannot be removed
st->enable(GL_LIGHTING);
st->enable(GL_TEXTURE_2D);
st->enable(GL_BLEND);
st->setColourMaterial(GL_AMBIENT_AND_DIFFUSE);
stlist *curr = (stlist*)calloc(sizeof(stlist), 1);
curr->next = stateList;
stateList = curr;
curr->state = st;
curr->name = strdup(buf);
GfOut("Loading %s\n", buf);
}
