自学教程：C++ GfParmReadFile函数代码示例

/* * 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);	}}

/* 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 voidrmdsClickOnDriver(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;}

intReRaceEventInit(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. */voidGfuiScreenAddBgImg(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 voidgfuiColorInit(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 voidreRegisterRaceman(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]);}

voidReInitResults(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" inthuman(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 voidreSelectLoadFile(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 filevoid* 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 resetvoidReReset(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 filevoidReRaceRestore(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);}

voidReUpdateQualifCurRes(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;}