/*
* 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);
}
}
/* initialize track data, called for every selected driver */
static void initTrack(int index, tTrack* track, void *carHandle, void **carParmHandle, tSituation * situation)
{
if ((myTrackDesc != NULL) && (myTrackDesc->getTorcsTrack() != track)) {
delete myTrackDesc;
myTrackDesc = NULL;
}
if (myTrackDesc == NULL) {
myTrackDesc = new TrackDesc(track);
}
char buffer[BUFSIZE];
char* trackname = strrchr(track->filename, '/') + 1;
snprintf(buffer, BUFSIZE, "drivers/berniw_Recorder/%d/%s", index, trackname);
*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
if (*carParmHandle == NULL) {
snprintf(buffer, BUFSIZE, "drivers/berniw_Recorder/%d/default.xml", index);
*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
}
/* Load and set parameters */
float fuel = GfParmGetNum(*carParmHandle, BERNIW_RECORDER_SECT_PRIV, BERNIW_RECORDER_ATT_FUELPERLAP,
(char*)NULL, track->length*MyCar::MAX_FUEL_PER_METER);
fuel *= (situation->_totLaps + 1.0);
GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, (char*)NULL, MIN(fuel, 100.0));
}
/* 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);
}
static void
rmdsClickOnDriver(void * /* dummy */)
{
char *name;
tDrvElt *curDrv;
void *robhdle;
name = GfuiScrollListGetSelectedElement(scrHandle, selectedScrollList, (void**)&curDrv);
if (!name) {
name = GfuiScrollListGetSelectedElement(scrHandle, unselectedScrollList, (void**)&curDrv);
}
if (name) {
GfuiLabelSetText(scrHandle, PickDrvNameLabelId, curDrv->name);
/* search driver infos */
sprintf(buf, "%sdrivers/%s/%s.xml", GetLocalDir(), curDrv->dname, curDrv->dname);
robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD);
if (!robhdle) {
sprintf(buf, "drivers/%s/%s.xml", curDrv->dname, curDrv->dname);
robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD);
}
if (robhdle != NULL) {
sprintf(buf, "%s/%s/%d", ROB_SECT_ROBOTS, ROB_LIST_INDEX, curDrv->index);
GfuiLabelSetText(scrHandle, PickDrvCarLabelId, GfParmGetName(curDrv->car));
GfuiLabelSetText(scrHandle, PickDrvCategoryLabelId, GfParmGetStr(curDrv->car, SECT_CAR, PRM_CATEGORY, ""));
GfParmReleaseHandle(robhdle);
}
}
}
// 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;
}
//==========================================================================*
// Get filehandle for robot's xml-file
//--------------------------------------------------------------------------*
void* GetFileHandle(const char* RobotName)
{
void* RobotSettings = NULL;
strncpy(BufName, RobotName, BUFSIZE); // Save robot's name
snprintf(BufPathDirRel, BUFSIZE, // Robot's directory
"drivers/%s",RobotName); // relative to installation
snprintf(BufPathXMLRel, BUFSIZE, // Robot's xml-filename
"drivers/%s/%s.xml",RobotName,RobotName);// relative to installation
// Test local installation path
snprintf(BufPathXML, BUFSIZE, "%s%s",
GetLocalDir(), RobPathXMLRel);
snprintf(BufPathDir, BUFSIZE, "%s%s",
GetLocalDir(), RobPathDirRel);
RobotSettings = GfParmReadFile
(RobPathXML, GFPARM_RMODE_STD );
if (!RobotSettings)
{
// If not found, use global installation path
snprintf(BufPathXML, BUFSIZE, "%s%s",
GetDataDir(), RobPathXMLRel);
snprintf(BufPathDir, BUFSIZE, "%s%s",
GetDataDir(), RobPathDirRel);
RobotSettings = GfParmReadFile
(RobPathXML, GFPARM_RMODE_STD );
}
return RobotSettings;
}
int
ReRaceEventInit(void)
{
void *mainParams = ReInfo->mainParams;
void *params = ReInfo->params;
const bool careerMode = strcmp(GfParmGetStr(ReInfo->mainParams, RM_SECT_SUBFILES, RM_ATTR_HASSUBFILES, RM_VAL_NO), RM_VAL_YES) == 0;
/* Career mode : Look if it is necessary to open another file */
if (strcmp(GfParmGetStr(mainParams, RM_SECT_SUBFILES, RM_ATTR_HASSUBFILES, RM_VAL_NO), RM_VAL_YES) == 0)
{
/* Close previous params */
if (params != mainParams)
GfParmReleaseHandle(params);
/* Read the new params */
ReInfo->params = GfParmReadFile( GfParmGetStr( ReInfo->mainResults, RE_SECT_CURRENT, RE_ATTR_CUR_FILE, "" ), GFPARM_RMODE_STD );
GfLogTrace("Career : New params file is %s (from main results file)\n",
GfParmGetStr( ReInfo->mainResults, RE_SECT_CURRENT, RE_ATTR_CUR_FILE, ""));
if (!ReInfo->params)
GfLogWarning( "Career : MainResults params weren't read correctly\n" );
/* Close previous results */
if (ReInfo->results != ReInfo->mainResults)
{
GfParmWriteFile(NULL, ReInfo->results, NULL);
GfParmReleaseHandle(ReInfo->results);
}
/* Read the new results */
ReInfo->results = GfParmReadFile( GfParmGetStr( ReInfo->params, RM_SECT_SUBFILES, RM_ATTR_RESULTSUBFILE, ""), GFPARM_RMODE_STD );
if (!ReInfo->results)
GfLogWarning( "Career : New results weren't read correctly\n" );
}
// Initialize the race session name.
ReInfo->_reRaceName = ReGetCurrentRaceName();
GfLogInfo("Starting new event (%s session)\n", ReInfo->_reRaceName);
ReUI().onRaceEventInitializing();
ReInfo->s->_features = RmGetFeaturesList(ReInfo->params);
ReTrackInit();
ReEventInitResults();
NoCleanupNeeded = false;
const bool bGoOnLooping = ReUI().onRaceEventStarting(careerMode && !ReHumanInGroup());
return (bGoOnLooping ? RM_SYNC : RM_ASYNC) | RM_NEXT_STEP;
}
/** Add an image background to a screen.
@ingroup gui
@param scr Screen
@param filename file name of the bg image
@return None.
*/
void
GfuiScreenAddBgImg(void *scr, const char *filename)
{
tGfuiScreen *screen = (tGfuiScreen*)scr;
void *handle;
float screen_gamma;
GLbyte *tex;
int w,h;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
if (glIsTexture(screen->bgImage) == GL_TRUE) {
glDeleteTextures(1, &screen->bgImage);
}
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), GFSCR_CONF_FILE);
handle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
screen_gamma = (float)GfParmGetNum(handle, GFSCR_SECT_PROP, GFSCR_ATT_GAMMA, (char*)NULL, 2.0);
tex = (GLbyte*)GfImgReadPng(filename, &w, &h, screen_gamma);
if (!tex) {
GfParmReleaseHandle(handle);
return;
}
glGenTextures(1, &screen->bgImage);
glBindTexture(GL_TEXTURE_2D, screen->bgImage);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)(tex));
free(tex);
GfParmReleaseHandle(handle);
}
static void
gfuiColorInit(void)
{
void *hdle;
int i, j;
char *rgba[4] = {GFSCR_ATTR_RED, GFSCR_ATTR_GREEN, GFSCR_ATTR_BLUE, GFSCR_ATTR_ALPHA};
char *clr[GFUI_COLORNB] = {
GFSCR_ELT_BGCOLOR, GFSCR_ELT_TITLECOLOR, GFSCR_ELT_BGBTNFOCUS, GFSCR_ELT_BGBTNCLICK,
GFSCR_ELT_BGBTNENABLED, GFSCR_ELT_BGBTNDISABLED, GFSCR_ELT_BTNFOCUS, GFSCR_ELT_BTNCLICK,
GFSCR_ELT_BTNENABLED, GFSCR_ELT_BTNDISABLED, GFSCR_ELT_LABELCOLOR, GFSCR_ELT_TIPCOLOR,
GFSCR_ELT_MOUSECOLOR1, GFSCR_ELT_MOUSECOLOR2, GFSCR_ELT_HELPCOLOR1, GFSCR_ELT_HELPCOLOR2,
GFSCR_ELT_BGSCROLLIST, GFSCR_ELT_SCROLLIST, GFSCR_ELT_BGSELSCROLLIST, GFSCR_ELT_SELSCROLLIST,
GFSCR_ELT_EDITCURSORCLR
};
sprintf(buf, "%s%s", GetLocalDir(), GFSCR_CONF_FILE);
hdle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
for (i = 0; i < GFUI_COLORNB; i++) {
for (j = 0; j < 4; j++) {
sprintf(buf, "%s/%s/%s", GFSCR_SECT_MENUCOL, GFSCR_LIST_COLORS, clr[i]);
GfuiColor[i][j] = GfParmGetNum(hdle, buf, rgba[j], (char*)NULL, 1.0);
}
}
GfParmReleaseHandle(hdle);
/* Remove the X11/Windows cursor */
if (!GfuiMouseHW) {
glutSetCursor(GLUT_CURSOR_NONE);
}
GfuiMouseVisible = 1;
}
/* Register a race manager */
static void
reRegisterRaceman(tFList *racemanCur)
{
sprintf(buf, "%sconfig/raceman/%s", GetLocalDir(), racemanCur->name);
racemanCur->userData = GfParmReadFile(buf, GFPARM_RMODE_STD);
racemanCur->dispName = GfParmGetStr(racemanCur->userData, RM_SECT_HEADER, RM_ATTR_NAME, 0);
}
tTrack *
TrackBuildEx(const char *trackfile)
{
void *TrackHandle;
theTrack = (tTrack*)calloc(1, sizeof(tTrack));
theCamList = (tRoadCam*)NULL;
theTrack->params = TrackHandle = GfParmReadFile (trackfile, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT | GFPARM_RMODE_PRIVATE);
theTrack->filename = strdup(trackfile);
GetTrackHeader(TrackHandle);
switch(theTrack->version)
{
case 0:
case 1:
case 2:
case 3:
ReadTrack3(theTrack, TrackHandle, &theCamList, 1);
break;
case 4:
ReadTrack4(theTrack, TrackHandle, &theCamList, 1);
break;
case 5:
ReadTrack5(theTrack, TrackHandle, &theCamList, 1);
break;
}
return theTrack;
}
// 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);
}
// Config file management.
void* GfglFeatures::openConfigFile()
{
std::ostringstream ossParm;
ossParm << GfLocalDir() << GFSCR_CONF_FILE;
return GfParmReadFile(ossParm.str().c_str(), GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
}
// Read sound configuration.
static void readSoundCfg(void)
{
const char *optionName;
int i;
char buf[1024];
sprintf(buf, "%s%s", GetLocalDir(), GR_SOUND_PARM_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
optionName = GfParmGetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[0]);
for (i = 0; i < nbOptions; i++) {
if (strcmp(optionName, soundOptionList[i]) == 0) {
curOption = i;
break;
}
}
VolumeValue = GfParmGetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", 100.0f);
if (VolumeValue>100.0f) {
VolumeValue = 100.0f;
}
if (VolumeValue < 0.0f) {
VolumeValue = 0.0f;
}
GfParmReleaseHandle(paramHandle);
GfuiLabelSetText(scrHandle, SoundOptionId, soundOptionList[curOption]);
}
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);
}
extern "C" int
human(tModInfo *modInfo)
{
int i;
const char *driver;
const int BUFSIZE = 1024;
char buf[BUFSIZE];
char sstring[BUFSIZE];
memset(modInfo, 0, 10*sizeof(tModInfo));
snprintf(buf, BUFSIZE, "%sdrivers/human/human.xml", GetLocalDir());
void *DrvInfo = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
if (DrvInfo != NULL) {
for (i = 0; i < 10; i++) {
snprintf(sstring, BUFSIZE, "Robots/index/%d", i+1);
driver = GfParmGetStr(DrvInfo, sstring, "name", "");
if (strlen(driver) == 0) {
break;
}
modInfo->name = strdup(driver); /* name of the module (short) */
modInfo->desc = strdup("Joystick controlable driver"); /* description of the module (can be long) */
modInfo->fctInit = InitFuncPt; /* init function */
modInfo->gfId = ROB_IDENT; /* supported framework version */
modInfo->index = i+1;
modInfo++;
}
// Just release in case we got it.
GfParmReleaseHandle(DrvInfo);
}
return 0;
}
// Read sound configuration.
static void readSoundCfg(void)
{
const char *optionName;
int i;
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);
optionName = GfParmGetStr(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_STATE, soundOptionList[0]);
for (i = 0; i < nbOptions; i++) {
if (strcmp(optionName, soundOptionList[i]) == 0) {
curOption = i;
break;
}
}
VolumeValue = GfParmGetNum(paramHandle, GR_SCT_SOUND, GR_ATT_SOUND_VOLUME, "%", 100.0f);
if (VolumeValue>100.0f) {
VolumeValue = 100.0f;
}
if (VolumeValue < 0.0f) {
VolumeValue = 0.0f;
}
GfParmReleaseHandle(paramHandle);
GfuiLabelSetText(scrHandle, SoundOptionId, soundOptionList[curOption]);
// Read Menu music optons
snprintf(buf, BUFSIZE, "%s%s", GetLocalDir(), MM_SOUND_PARM_CFG);
paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
optionName = GfParmGetStr(paramHandle, MM_SCT_SOUND, MM_ATT_SOUND_ENABLE, MM_VAL_SOUND_DISABLED);
if (strcmp(optionName, MM_VAL_SOUND_ENABLED) == 0) {
GfuiLabelSetText(scrHandle, MenuMusicOptionId, MM_VAL_SOUND_ENABLED);
curOptionMenuMusic = 1;
} else {
GfuiLabelSetText(scrHandle, MenuMusicOptionId, MM_VAL_SOUND_DISABLED);
curOptionMenuMusic = 0;
}
GfParmReleaseHandle(paramHandle);
}
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);
}
// Read sound configuration.
static void readSoundCfg(void)
{
const char *optionName;
int i;
char buf[1024];
// Sound interface.
sprintf(buf, "%s%s", GfLocalDir(), SND_PARAM_FILE);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
optionName = GfParmGetStr(paramHandle, SND_SCT_SOUND, SND_ATT_SOUND_STATE, soundOptionList[0]);
for (i = 0; i < nbOptions; i++) {
if (strcmp(optionName, soundOptionList[i]) == 0) {
curOption = i;
break;
}
}
GfuiLabelSetText(scrHandle, SoundOptionId, soundOptionList[curOption]);
// Sound volume.
VolumeValue = GfParmGetNum(paramHandle, SND_SCT_SOUND, SND_ATT_SOUND_VOLUME, "%", 100.0f);
if (VolumeValue>100.0f) {
VolumeValue = 100.0f;
}
else if (VolumeValue < 0.0f) {
VolumeValue = 0.0f;
}
sprintf(buf, "%g", VolumeValue);
GfuiEditboxSetString(scrHandle, VolumeValueId, buf);
optionName = GfParmGetStr(paramHandle, SND_SCT_MUSIC, SND_ATT_MUSIC_STATE, musicStateList[0]);
for (i = 0; i < nbMusicStates; i++) {
if (strcmp(optionName, musicStateList[i]) == 0) {
curMusicState = i;
break;
}
}
GfuiLabelSetText(scrHandle, MusicStateId, musicStateList[curMusicState]);
// Music volume.
MusicVolumeValue = GfParmGetNum(paramHandle, SND_SCT_MUSIC, SND_ATT_MUSIC_VOLUME, "%", 100.0f);
if (MusicVolumeValue>100.0f) {
MusicVolumeValue = 100.0f;
}
else if (MusicVolumeValue < 0.0f) {
MusicVolumeValue = 0.0f;
}
sprintf(buf, "%g", MusicVolumeValue);
GfuiEditboxSetString(scrHandle, MusicVolumeValueId, buf);
GfParmReleaseHandle(paramHandle);
}
void gfuiLoadFonts(void)
{
void *param;
int size;
int i;
int nFontId;
snprintf(buf, sizeof(buf), "%s%s", GfLocalDir(), GFSCR_CONF_FILE);
param = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT);
snprintf(buf, sizeof(buf), "%sdata/fonts/%s", GfDataDir(),
GfParmGetStr(param, "Menu Font", "name", "b5.glf"));
GfLogTrace("Loading font 'Menu Font' from %s : Sizes", buf);
nFontId = GFUI_FONT_BIG;
for(i = 0; i < 4; i++, nFontId++) {
size = (int)GfParmGetNum(param, "Menu Font", keySize[i], (char*)NULL, 10.0);
GfLogTrace(" %d,", size);
gfuiFont[nFontId] = new GfuiFontClass(buf);
gfuiFont[nFontId]->create(size);
}
GfLogTrace("\n");
snprintf(buf, sizeof(buf), "%sdata/fonts/%s", GfDataDir(),
GfParmGetStr(param, "Console Font", "name", "b7.glf"));
GfLogTrace("Loading font 'Console Font' from %s : Sizes", buf);
nFontId = GFUI_FONT_BIG_C;
for(i = 0; i < 4; i++, nFontId++) {
size = (int)GfParmGetNum(param, "Console Font", keySize[i], (char*)NULL, 10.0);
GfLogTrace(" %d,", size);
gfuiFont[nFontId] = new GfuiFontClass(buf);
gfuiFont[nFontId]->create(size);
}
GfLogTrace("\n");
snprintf(buf, sizeof(buf), "%sdata/fonts/%s", GfDataDir(),
GfParmGetStr(param, "Text Font", "name", "b6.glf"));
GfLogTrace("Loading font 'Text Font' from %s : Sizes", buf);
nFontId = GFUI_FONT_BIG_T;
for(i = 0; i < 4; i++, nFontId++) {
size = (int)GfParmGetNum(param, "Text Font", keySize[i], (char*)NULL, 10.0);
GfLogTrace(" %d,", size);
gfuiFont[nFontId] = new GfuiFontClass(buf);
gfuiFont[nFontId]->create(size);
}
GfLogTrace("\n");
snprintf(buf, sizeof(buf), "%sdata/fonts/%s", GfDataDir(),
GfParmGetStr(param, "Digital Font", "name", "digital.glf"));
GfLogTrace("Loading font 'Digital Font' from %s : Sizes", buf);
nFontId = GFUI_FONT_DIGIT;
size = (int)GfParmGetNum(param, "Digital Font", keySize[0], (char*)NULL, 8.0);
GfLogTrace(" %d\n", size);
gfuiFont[nFontId] = new GfuiFontClass(buf);
gfuiFont[nFontId]->create(size);
GfParmReleaseHandle(param);
}
// Initialize track data, called for every selected driver.
static void initTrack(int index, tTrack* track, void *carHandle, void **carParmHandle, tSituation * situation)
{
if ((myTrackDesc != NULL) && (myTrackDesc->getTorcsTrack() != track)) {
delete myTrackDesc;
myTrackDesc = NULL;
}
if (myTrackDesc == NULL) {
myTrackDesc = new TrackDesc(track);
}
char buffer[BUFSIZE];
char* trackname = strrchr(track->filename, '/') + 1;
switch (situation->_raceType) {
case RM_TYPE_PRACTICE:
snprintf(buffer, BUFSIZE, "drivers/tita/%d/practice/%s", index, trackname);
break;
case RM_TYPE_QUALIF:
snprintf(buffer, BUFSIZE, "drivers/tita/%d/qualifying/%s", index, trackname);
break;
case RM_TYPE_RACE:
snprintf(buffer, BUFSIZE, "drivers/tita/%d/race/%s", index, trackname);
break;
default:
break;
}
*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
if (*carParmHandle == NULL) {
snprintf(buffer, BUFSIZE, "drivers/tita/%d/default.xml", index);
*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
}
// Load and set parameters.
float fuel = GfParmGetNum(*carParmHandle, BERNIW_SECT_PRIV, BERNIW_ATT_FUELPERLAP,
(char*)NULL, track->length*MyCar::MAX_FUEL_PER_METER);
//printf("fuelperlap: %f\n", fuel);
float fuelmargin = (situation->_raceType == RM_TYPE_RACE) ? 1.0 : 0.0;
fuel *= (situation->_totLaps + fuelmargin);
GfParmSetNum(*carParmHandle, SECT_CAR, PRM_FUEL, (char*)NULL, MIN(fuel, 100.0));
}
// name: getFileHandle
// Obtains the file handle for the robot XML file,
// trying the installation path first, then
// the global one, if the previous attempt failed.
// @param
// @return file handler for the robot XML file
void* getFileHandle()
{
// First we try to use the directories relative to the installation path
snprintf(pathBuffer, BUFSIZE, "%sdrivers/%s/%s.xml",
GetLocalDir(), robot_name, robot_name);
// Test local installation path
void *robot_settings = GfParmReadFile(xml_path, GFPARM_RMODE_STD);
if (!robot_settings)
{
// If not found, use global installation path
snprintf(pathBuffer, BUFSIZE, "%sdrivers/%s/%s.xml",
GetDataDir(), robot_name, robot_name);
robot_settings = GfParmReadFile(xml_path, GFPARM_RMODE_STD);
}
return robot_settings;
}
// Called for every track change or new race.
void Driver::initTrack(tTrack* t, void *carHandle, void **carParmHandle, tSituation *s)
{
track = t;
const int BUFSIZE = 256;
char buffer[BUFSIZE];
char indexstr[32];
// Load a custom setup if one is available.
// Get a pointer to the first char of the track filename.
char* trackname = strrchr(track->filename, '/') + 1;
RtGetCarindexString(INDEX, "bt", INDEX < 0 || INDEX >= 10, indexstr, 32);
switch (s->_raceType) {
case RM_TYPE_PRACTICE:
snprintf(buffer, BUFSIZE, "drivers/bt/%s/practice/%s", indexstr, trackname);
break;
case RM_TYPE_QUALIF:
snprintf(buffer, BUFSIZE, "drivers/bt/%s/qualifying/%s", indexstr, trackname);
break;
case RM_TYPE_RACE:
snprintf(buffer, BUFSIZE, "drivers/bt/%s/race/%s", indexstr, trackname);
break;
default:
break;
}
*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
if (*carParmHandle == NULL) {
snprintf(buffer, BUFSIZE, "drivers/bt/%s/default.xml", indexstr);
*carParmHandle = GfParmReadFile(buffer, GFPARM_RMODE_STD);
}
// Create a pit stop strategy object.
strategy = new SimpleStrategy2();
// Init fuel.
strategy->setFuelAtRaceStart(t, carParmHandle, s, INDEX);
// Load and set parameters.
MU_FACTOR = GfParmGetNum(*carParmHandle, BT_SECT_PRIV, BT_ATT_MUFACTOR, (char*)NULL, 0.69f);
}
void getUserTextureMaxSize(int &result)
{
char fnbuf[1024];
sprintf(fnbuf, "%s%s", GetLocalDir(), GR_PARAM_FILE);
void *paramHandle = GfParmReadFile(fnbuf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
result = (int) GfParmGetNum(paramHandle, GR_SCT_GLFEATURES, GR_ATT_TEXTURESIZE, (char*)NULL, (tdble) glTextureMaxSize);
if (result > glTextureMaxSize) {
result = glTextureMaxSize;
}
GfParmReleaseHandle(paramHandle);
}
static void loadSimuCfg(void)
{
const char *simuVersionName;
const char *multiThreadSchemeName;
const char *threadAffinitySchemeName;
int i;
char buf[1024];
snprintf(buf, sizeof(buf), "%s%s", GfLocalDir(), RACE_ENG_CFG);
void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
// Simulation engine name.
simuVersionName = GfParmGetStr(paramHandle, RM_SECT_MODULES, RM_ATTR_MOD_SIMU, SimuVersionList[DefaultSimuVersion]);
for (i = 0; i < NbSimuVersions; i++) {
if (strcmp(simuVersionName, SimuVersionList[i]) == 0) {
CurSimuVersion = i;
break;
}
}
// Check if the selected simulation module is there, and fall back to the default one if not.
snprintf(buf, sizeof(buf), "%smodules/simu/%s.%s", GfLibDir(), SimuVersionList[CurSimuVersion], DLLEXT);
if (!GfFileExists(buf))
{
GfLogWarning("User settings %s physics engine module not found ; falling back to %s\n",
SimuVersionList[CurSimuVersion], SimuVersionList[DefaultSimuVersion]);
CurSimuVersion = DefaultSimuVersion;
}
// Multi-threading.
multiThreadSchemeName = GfParmGetStr(paramHandle, RM_SECT_RACE_ENGINE, RM_ATTR_MULTI_THREADING, MultiThreadSchemeList[0]);
for (i = 0; i < NbMultiThreadSchemes; i++) {
if (strcmp(multiThreadSchemeName, MultiThreadSchemeList[i]) == 0) {
CurMultiThreadScheme = i;
break;
}
}
// Thread affinity.
threadAffinitySchemeName = GfParmGetStr(paramHandle, RM_SECT_RACE_ENGINE, RM_ATTR_THREAD_AFFINITY, ThreadAffinitySchemeList[0]);
for (i = 0; i < NbThreadAffinitySchemes; i++) {
if (strcmp(threadAffinitySchemeName, ThreadAffinitySchemeList[i]) == 0) {
CurThreadAffinityScheme = i;
break;
}
}
GfParmReleaseHandle(paramHandle);
GfuiLabelSetText(ScrHandle, SimuVersionId, SimuVersionDispNameList[CurSimuVersion]);
GfuiLabelSetText(ScrHandle, MultiThreadSchemeId, MultiThreadSchemeList[CurMultiThreadScheme]);
GfuiLabelSetText(ScrHandle, ThreadAffinitySchemeId, ThreadAffinitySchemeList[CurThreadAffinityScheme]);
}
void*
GfuiMenuLoad(const char* pszMenuPath)
{
std::string strPath("data/menu/");
strPath += pszMenuPath;
char buf[512];
sprintf(buf, "%s%s", GfDataDir(), strPath.c_str());
return GfParmReadFile(buf, GFPARM_RMODE_STD);
}
void SDScenery::LoadGraphicsOptions()
{
char buf[256];
if (!grHandle)
{
snprintf(buf, 256, "%s%s", GfLocalDir(), GR_PARAM_FILE);
grHandle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_REREAD);
}//if grHandle
LoadSkyOptions();
}
// Race Engine reset
void
ReReset(void)
{
// Allocate race engine info structures if not already done.
ReInfo = ReSituation::self().data();
ReInfo->robModList = &ReRacingRobotsModList;
// Load Race engine params.
char buf[256];
snprintf(buf, sizeof(buf), "%s%s", GfLocalDir(), RACE_ENG_CFG);
ReInfo->_reParam = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT);
}
// Restore the race from the given results file
void
ReRaceRestore(void* hparmResults)
{
// Update race engine info in order to set it in the exact state
// it was in when the race mode was saved.
GfRace* pRace = StandardGame::self().race();
ReInfo->mainParams = pRace->getManager()->getDescriptorHandle();
ReInfo->mainResults = pRace->getResultsDescriptorHandle();
if (!pRace->getManager()->hasSubFiles())
{
// Non-Career mode.
ReInfo->params = ReInfo->mainParams;
ReInfo->results = ReInfo->mainResults;
ReInfo->_reRaceName = pRace->getSessionName().c_str(); //ReInfo->_reName;
}
else
{
// Career mode : More complicated, as everything is not in one params/results file
// (the target state is right after the end of the previous event,
// which was from the previous group).
const char* pszPrevParamsFile =
GfParmGetStr(ReInfo->mainResults, RE_SECT_CURRENT, RE_ATTR_PREV_FILE, 0);
if (!pszPrevParamsFile)
GfLogWarning("Career : No previous file in MainResults\n");
ReInfo->params =
pszPrevParamsFile ? GfParmReadFile(pszPrevParamsFile, GFPARM_RMODE_STD) : ReInfo->mainParams;
const char* pszPrevResultsFile =
GfParmGetStr(ReInfo->params, RM_SECT_SUBFILES, RM_ATTR_RESULTSUBFILE, 0);
if (!pszPrevResultsFile)
GfLogWarning("Career : Failed to load previous results from previous params\n");
ReInfo->results =
pszPrevResultsFile ? GfParmReadFile(pszPrevResultsFile, GFPARM_RMODE_STD) : ReInfo->mainResults;
ReInfo->_reRaceName = ReGetPrevRaceName(/* bLoop = */true);
}
GfParmRemoveVariable(ReInfo->params, "/", "humanInGroup");
GfParmSetVariable(ReInfo->params, "/", "humanInGroup", ReHumanInGroup() ? 1.0f : 0.0f);
}
void
ReUpdateQualifCurRes(tCarElt *car)
{
int i;
int nCars;
int printed;
int maxLines;
void *carparam;
char *carName;
const char *race = ReInfo->_reRaceName;
void *results = ReInfo->results;
const int BUFSIZE = 1024;
char buf[BUFSIZE], path[BUFSIZE];
ReResEraseScreen();
maxLines = ReResGetLines();
snprintf(buf, BUFSIZE, "%s on %s - Lap %d", car->_name, ReInfo->track->name, car->_laps);
ReResScreenSetTitle(buf);
snprintf(buf, BUFSIZE, "cars/%s/%s.xml", car->_carName, car->_carName);
carparam = GfParmReadFile(buf, GFPARM_RMODE_STD);
carName = GfParmGetName(carparam);
printed = 0;
snprintf(path, BUFSIZE, "%s/%s/%s/%s", ReInfo->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK);
nCars = GfParmGetEltNb(results, path);
nCars = MIN(nCars + 1, maxLines);
for (i = 1; i < nCars; i++) {
snprintf(path, BUFSIZE, "%s/%s/%s/%s/%d", ReInfo->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK, i);
if (!printed) {
if ((car->_bestLapTime != 0.0) && (car->_bestLapTime < GfParmGetNum(results, path, RE_ATTR_BEST_LAP_TIME, NULL, 0))) {
snprintf(buf, BUFSIZE, "%d - %s - %s (%s)", i, GfTime2Str(car->_bestLapTime, 0), car->_name, carName);
ReResScreenSetText(buf, i - 1, 1);
printed = 1;
}
}
snprintf(buf, BUFSIZE, "%d - %s - %s (%s)", i + printed, GfTime2Str(GfParmGetNum(results, path, RE_ATTR_BEST_LAP_TIME, NULL, 0), 0),
GfParmGetStr(results, path, RE_ATTR_NAME, ""), GfParmGetStr(results, path, RE_ATTR_CAR, ""));
ReResScreenSetText(buf, i - 1 + printed, 0);
}
if (!printed) {
snprintf(buf, BUFSIZE, "%d - %s - %s (%s)", i, GfTime2Str(car->_bestLapTime, 0), car->_name, carName);
ReResScreenSetText(buf, i - 1, 1);
}
GfParmReleaseHandle(carparam);
ReInfo->_refreshDisplay = 1;
}
