void NetClient::ReadRaceSetupPacket(ENetPacket *pPacket) { GfLogTrace("\nRecieving race setup\n"); SetRaceInfoChanged(true); }
void RmNetworkClientMenu(void * /* dummy */) { GfLogTrace("Entering Network Client menu.\n"); ShowWaitingToConnectScreen(); if (!NetGetClient()) { NetSetServer(false); NetSetClient(true); NetDriver driver; GetHumanDriver(driver,1); driver.client = true; driver.active = true; strcpy(driver.name,g_strDriver.c_str()); if (!NetGetClient()->ConnectToServer((char*)g_strHostIP.c_str(),SPEEDDREAMSPORT,&driver)) { //failed so back to connect menu NetworkClientConnectMenu(NULL); return; } //NetGetClient()->SendDriverInfoPacket(&driver); } if (racemanMenuHdle) GfuiScreenRelease(racemanMenuHdle); racemanMenuHdle = GfuiScreenCreate(NULL, NULL, (tfuiCallback)OnActivateNetworkClient, NULL, (tfuiCallback)NULL, 1); void *mparam = GfuiMenuLoad("networkclientmenu.xml"); GfuiMenuCreateStaticControls(racemanMenuHdle, mparam); GfuiMenuDefaultKeysAdd(racemanMenuHdle); RmSetRacemanMenuHandle(racemanMenuHdle); g_trackHd = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,"trackname"); g_lapsHd = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,"lapcountname"); g_catHd = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,"carcatname"); g_OutlineId = GfuiMenuCreateStaticImageControl(racemanMenuHdle,mparam,"outlineimage"); //Show players for (int i = 0; i < MAXNETWORKPLAYERS; i++) { char buf[1024]; sprintf(buf,"ready%i",i); g_readystatus[i] = GfuiMenuCreateStaticImageControl(racemanMenuHdle,mparam,buf); GfuiVisibilitySet(racemanMenuHdle,g_readystatus[i],false); sprintf(buf,"driver%i",i); g_playerNames[i] = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,buf); GfuiLabelSetText(racemanMenuHdle,g_playerNames[i],""); sprintf(buf,"car%i",i); g_carNames[i] = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,buf); GfuiLabelSetText(racemanMenuHdle,g_carNames[i],""); } g_ReadyCheckboxId = GfuiMenuCreateCheckboxControl(racemanMenuHdle, mparam, "playerreadycheckbox", NULL, onClientPlayerReady); g_CarSetupButtonId = GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "garage", racemanMenuHdle, rmCarSettingsMenu); g_DisconnectButtonId = GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "disconnect", NULL,rmNetworkClientDisconnect); GfParmReleaseHandle(mparam); UpdateNetworkPlayers(); GfuiScreenActivate(racemanMenuHdle); GfuiApp().eventLoop().setRecomputeCB(ClientIdle); }
/** Dump the track segments on screen @param track track to dump @param verbose if set to 1 all the segments are described (long) @ingroup racemantools */ static void reTrackDump(const tTrack *track, int verbose) { char buf[128]; snprintf(buf, sizeof(buf), " by %s (%.0f m long, %.0f m wide) ...", track->authors, track->length, track->width); ReUI().addLoadingMessage(buf); GfLogInfo("++++++++++++ Track ++++++++++++\n"); GfLogInfo("Name = %s\n", track->name); GfLogInfo("Authors = %s\n", track->authors); GfLogInfo("Filename = %s\n", track->filename); GfLogInfo("NSeg = %d\n", track->nseg); GfLogInfo("Version = %d\n", track->version); GfLogInfo("Length = %f m\n", track->length); GfLogInfo("Width = %f m\n", track->width); GfLogInfo("XSize = %f m\n", track->max.x); GfLogInfo("YSize = %f m\n", track->max.y); GfLogInfo("ZSize = %f m\n", track->max.z); switch (track->pits.type) { case TR_PIT_NONE: GfLogInfo("Pits = none\n"); break; case TR_PIT_ON_TRACK_SIDE: GfLogInfo("Pits = present on track side\n"); break; case TR_PIT_ON_SEPARATE_PATH: GfLogInfo("Pits = present on separate path\n"); break; case TR_PIT_NO_BUILDING: GfLogInfo("Pits = present, no building style\n"); break; }//switch pits.type const int seconds = (int)track->local.timeofday; GfLogInfo("TimeOfDay= %02d:%02d:%02d\n", seconds / 3600, (seconds % 3600) / 60, seconds % 60); GfLogInfo("Sun asc. = %.1f d\n", RAD2DEG(track->local.sunascension)); GfLogInfo("Clouds = %d (0=none, 1=few, 2=scarce, 3=many, 4=full)\n", track->local.clouds); GfLogInfo("Rain = %d (0=none, 1=little, 2=medium, 3=heavy)\n", track->local.rain); GfLogInfo("Water = %d (0=none, 1=some, 2=more, 3=swampy)\n", track->local.water); if (verbose) { int i; tTrackSeg *seg; #ifdef SD_DEBUG const char *stype[4] = { "", "RGT", "LFT", "STR" }; #endif for (i = 0, seg = track->seg->next; i < track->nseg; i++, seg = seg->next) { GfLogTrace(" segment %d -------------- \n", seg->id); #ifdef SD_DEBUG GfLogTrace(" type %s\n", stype[seg->type]); #endif GfLogTrace(" length %f m\n", seg->length); GfLogTrace(" radius %f m\n", seg->radius); GfLogTrace(" arc %f d Zs %f d Ze %f d Zcs %f d\n", RAD2DEG(seg->arc), RAD2DEG(seg->angle[TR_ZS]), RAD2DEG(seg->angle[TR_ZE]), RAD2DEG(seg->angle[TR_CS])); GfLogTrace(" Za %f d\n", RAD2DEG(seg->angle[TR_ZS])); GfLogTrace(" vertices: %-8.8f %-8.8f %-8.8f ++++ ", seg->vertex[TR_SR].x, seg->vertex[TR_SR].y, seg->vertex[TR_SR].z); GfLogTrace("%-8.8f %-8.8f %-8.8f\n", seg->vertex[TR_SL].x, seg->vertex[TR_SL].y, seg->vertex[TR_SL].z); GfLogTrace(" vertices: %-8.8f %-8.8f %-8.8f ++++ ", seg->vertex[TR_ER].x, seg->vertex[TR_ER].y, seg->vertex[TR_ER].z); GfLogTrace("%-8.8f %-8.8f %-8.8f\n", seg->vertex[TR_EL].x, seg->vertex[TR_EL].y, seg->vertex[TR_EL].z); GfLogTrace(" prev %d\n", seg->prev->id); GfLogTrace(" next %d\n", seg->next->id); }//for i GfLogTrace("From Last To First\n"); GfLogTrace("Dx = %-8.8f Dy = %-8.8f Dz = %-8.8f\n", track->seg->next->vertex[TR_SR].x - track->seg->vertex[TR_ER].x, track->seg->next->vertex[TR_SR].y - track->seg->vertex[TR_ER].y, track->seg->next->vertex[TR_SR].z - track->seg->vertex[TR_ER].z); }//if verbose }//reTrackDump
void NetClient::ReadPlayerAcceptedPacket(ENetPacket *pPacket) { m_eClientAccepted = CLIENTACCEPTED; GfLogTrace ("Server accepted connection.\n"); }
/** * RmShowStandings * * Shows a results page, with optional prev/next results page buttons * * @param prevHdle handle for previous results page * @param info race results information * @param start page number */ void RmShowStandings(void *prevHdle, tRmInfo *info, int start) { int i; static char buf[256]; static char path[512]; void *results = info->results; GfLogTrace("Entering Standings menu\n"); // Create screen, load menu XML descriptor and create static controls. rmScrHdle = GfuiScreenCreate(); void *hmenu = GfuiMenuLoad("standingsmenu.xml"); GfuiMenuCreateStaticControls(rmScrHdle, hmenu); // Create variable title label (with group info for the Career mode). const int titleId = GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Title"); GfRaceManager* pRaceMan = LmRaceEngine().race()->getManager(); if (pRaceMan->hasSubFiles()) { const char* pszGroup = GfParmGetStr(info->params, RM_SECT_HEADER, RM_ATTR_NAME, "<no group>"); snprintf(buf, sizeof(buf), "%s - %s", info->_reName, pszGroup); } else snprintf(buf, sizeof(buf), "%s", info->_reName); GfuiLabelSetText(rmScrHdle, titleId, buf); // Create variable subtitle label. const char* pszSessionName; const char* pszTrackName; if (pRaceMan->hasSubFiles()) { // Career mode : Can't rely on GfRaceManager/GfRace, they don't support Career mode yet. pszSessionName = info->_reRaceName; const int curTrackIdx = (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1) - 1; snprintf(path, sizeof(path), "%s/%d", RM_SECT_TRACKS, curTrackIdx); pszTrackName = GfParmGetStr(info->params, path, RM_ATTR_NAME, "<unkown track>"); } else { // Non-Career mode : The session is the _last_ one ; the track is the _previous_ one. const unsigned nCurrEventIndex = (unsigned)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1); pszSessionName = pRaceMan->getSessionName(pRaceMan->getSessionCount() - 1).c_str(); pszTrackName = pRaceMan->getPreviousEventTrack(nCurrEventIndex - 1)->getName().c_str(); } snprintf(buf, sizeof(buf), "%s at %s", pszSessionName, pszTrackName); const int subTitleId = GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "SubTitle"); GfuiLabelSetText(rmScrHdle, subTitleId, buf); // Get layout properties. const int nMaxLines = (int)GfuiMenuGetNumProperty(hmenu, "nMaxResultLines", 15); const int yTopLine = (int)GfuiMenuGetNumProperty(hmenu, "yTopLine", 400); const int yLineShift = (int)GfuiMenuGetNumProperty(hmenu, "yLineShift", 20); // List results line by line, paginated int y = yTopLine; const int nbCars = (int)GfParmGetEltNb(results, RE_SECT_STANDINGS); for (i = start; i < MIN(start + nMaxLines, nbCars); i++) { snprintf(path, sizeof(path), "%s/%d", RE_SECT_STANDINGS, i + 1); //Rank snprintf(buf, sizeof(buf), "%d", i+1); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Rank", true, // From template. buf, GFUI_TPL_X, y); //Driver short name GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "DriverName", true, // From template. GfParmGetStr(results, path, RE_ATTR_SNAME, ""), GFUI_TPL_X, y); //Driver type const std::string strModName = GfParmGetStr(results, path, RE_ATTR_MODULE, ""); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "DriverType", true, // From template. GfDriver::getType(strModName).c_str(), GFUI_TPL_X, y); //Car GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "CarModel", true, // From template. GfParmGetStr(results, path, RE_ATTR_CAR, ""), GFUI_TPL_X, y); //Points snprintf(buf, sizeof(buf), "%d", (int)GfParmGetNum(results, path, RE_ATTR_POINTS, NULL, 0)); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Points", true, // From template. buf, GFUI_TPL_X, y); // Next line. y -= yLineShift; //Next line }//for i // If not on first page, show 'previous results' button on the bottom left if (start > 0) { RmPrevRace.prevHdle = prevHdle; RmPrevRace.info = info; RmPrevRace.start = start - nMaxLines; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "PreviousPageArrow", (void*)&RmPrevRace, rmChgStandingScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEUP, "Previous Results", (void*)&RmPrevRace, rmChgStandingScreen, NULL); }//if start // Add "Continue" button in the bottom left GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "ContinueButton", prevHdle, GfuiScreenReplace); // Add "save" button in the bottom right, but disable it when Career mode. rmSaveButtonId = GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "SaveButton", info, rmSaveRes); if (LmRaceEngine().race()->getManager()->hasSubFiles()) GfuiEnable(rmScrHdle, rmSaveButtonId, GFUI_DISABLE); // If there is a next page, show 'next results' button on the bottom extreme right if (i < nbCars) { RmNextRace.prevHdle = prevHdle; RmNextRace.info = info; RmNextRace.start = start + nMaxLines; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "NextPageArrow", (void*)&RmNextRace, rmChgStandingScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEDOWN, "Next Results", (void*)&RmNextRace, rmChgStandingScreen, NULL); }//if i GfuiAddKey(rmScrHdle, GFUIK_ESCAPE, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_RETURN, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_F1, "Help", rmScrHdle, GfuiHelpScreen, NULL); GfuiAddKey(rmScrHdle, GFUIK_F12, "Take a Screen Shot", NULL, GfuiScreenShot, NULL); GfuiScreenActivate(rmScrHdle); }//RmShowStandings
int RePreRace(void) { char path[128]; const char *raceName; const char *raceType; void *params = ReInfo->params; void *results = ReInfo->results; int curRaceIdx; int timedLapsReplacement = 0; char *prevRaceName; raceName = ReInfo->_reRaceName = ReGetCurrentRaceName(); GfParmRemoveVariable (params, "/", "humanInGroup"); GfParmRemoveVariable (params, "/", "eventNb"); GfParmSetVariable (params, "/", "humanInGroup", ReHumanInGroup() ? 1.0f : 0.0f); GfParmSetVariable (params, "/", "eventNb", GfParmGetNum (ReInfo->results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1.0 ) ); if (!raceName) { return RM_ERROR; } if (strcmp(GfParmGetStr(params, raceName, RM_ATTR_ENABLED, RM_VAL_YES), RM_VAL_NO) == 0) { GfLogTrace( "Race %s disabled\n", raceName); curRaceIdx = (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1); if (curRaceIdx < GfParmGetEltNb(params, RM_SECT_RACES)) { curRaceIdx++; GfLogTrace( "Race %s is not the last one, but the #%d\n", raceName, curRaceIdx); GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, (tdble)curRaceIdx); return RM_SYNC | RM_NEXT_RACE; } GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_RACE, NULL, 1); return RM_SYNC | RM_NEXT_RACE | RM_NEXT_STEP; } // Get session max dammages. ReInfo->s->_maxDammage = (int)GfParmGetNum(params, raceName, RM_ATTR_MAX_DMG, NULL, 10000); // Get session type (race, qualification or practice). raceType = GfParmGetStr(params, raceName, RM_ATTR_TYPE, RM_VAL_RACE); if (!strcmp(raceType, RM_VAL_RACE)) { ReInfo->s->_raceType = RM_TYPE_RACE; } else if (!strcmp(raceType, RM_VAL_QUALIF)) { ReInfo->s->_raceType = RM_TYPE_QUALIF; } else if (!strcmp(raceType, RM_VAL_PRACTICE)) { ReInfo->s->_raceType = RM_TYPE_PRACTICE; } // Get session duration (defaults to "All sessions" one, or else -60). ReInfo->s->_totTime = GfParmGetNum(params, raceName, RM_ATTR_SESSIONTIME, NULL, -1); if (ReInfo->s->_totTime < 0) ReInfo->s->_totTime = GfParmGetNum(params, RM_VAL_ANYRACE, RM_ATTR_SESSIONTIME, NULL, -60.0f); // Determine the actual session duration and/or number of laps. ReInfo->s->_extraLaps = 0; // TODO: Does this is ever needed ? ReInfo->s->_totLaps = 0; // Make sure it is initialized if (ReInfo->s->_totTime > 0 && !(ReInfo->s->_features & RM_FEATURE_TIMEDSESSION)) { // Timed session not supported: add 1 km for every minute in parctise or qualifying, // and 150 km for every hour (2.5 km for every minute) in race if (ReInfo->s->_raceType == RM_TYPE_RACE) { ReInfo->s->_totLaps = (int)floor(ReInfo->s->_totTime * 2500.0f / 60.0f / ReInfo->track->length + 0.5f); } else { ReInfo->s->_totLaps = (int)floor(ReInfo->s->_totTime * 1000.0f / 60.0f / ReInfo->track->length + 0.5f); } timedLapsReplacement = ReInfo->s->_totLaps; ReInfo->s->_totTime = -60.0f; } // Timed session doesn't exclude additional laps after the time finishes // Make sure that if no time set, we set far below zero if(ReInfo->s->_totTime <= 0.0f ) ReInfo->s->_totTime = -60.0f; // Get session distance (defaults to "All sessions" one, or else 0). tdble dist = GfParmGetNum(params, raceName, RM_ATTR_DISTANCE, NULL, -1); if (dist < 0) dist = GfParmGetNum(params, RM_VAL_ANYRACE, RM_ATTR_DISTANCE, NULL, 0); // If a (> 0) session distance was specified, deduce the number of laps // in case the race settings don't specify it, and it is not a timed race. if ( (dist >= 0.001) && (ReInfo->s->_totTime < 0.0f) ) { // Why not 'if (dist > 0)' ??? ReInfo->s->_totLaps = (int)(dist / ReInfo->track->length) + 1; ReInfo->s->_extraLaps = ReInfo->s->_totLaps; // Extralaps are used to find out how many laps there are after the time is up in timed sessions } else {dist = -1;} // Get the number of laps (defaults to "All sessions" one, // or else the already computed one from the session distance, or 0). int laps = (int)GfParmGetNum(params, raceName, RM_ATTR_LAPS, NULL, -1); if (laps < 0) laps = (int)GfParmGetNum(params, RM_VAL_ANYRACE, RM_ATTR_LAPS, NULL, 0); // Use lap number only when race distance is not in use. if ( (laps > 0) && (dist <= 0.0) && (timedLapsReplacement <= 0) ) { ReInfo->s->_totLaps = laps; ReInfo->s->_extraLaps = ReInfo->s->_totLaps; //Extralaps are used to find out how many laps there are after the time is up in timed sessions } // Make sure we have at least 1 lap race length. if ( (laps <= 0) && (dist <=0) && (ReInfo->s->_totTime < 0) ) { ReInfo->s->_totLaps = 1; ReInfo->s->_extraLaps = ReInfo->s->_totLaps; //Extralaps are used to find out how many laps there are after the time is up in timed sessions } // Correct extra laps (possible laps run after the winner arrived ?) : // during timed practice or qualification, there are none. if (ReInfo->s->_raceType != RM_TYPE_RACE && ReInfo->s->_totTime > 0) { ReInfo->s->_extraLaps = 0; //Extralaps are used to find out how many laps there are after the time is up in timed sessions ReInfo->s->_totLaps = 0; } GfLogInfo("Race length : time=%.0fs, laps=%d (extra=%d)\n", ReInfo->s->_totTime, ReInfo->s->_totLaps, ReInfo->s->_extraLaps); // Initialize race state. ReInfo->s->_raceState = 0; // Cleanup results snprintf(path, sizeof(path), "%s/%s/%s", ReInfo->track->name, RE_SECT_RESULTS, raceName); GfParmListClean(results, path); // Drivers starting order // The starting order is decided here, // then car indexes are stored in ReStartingOrderIdx, in the starting order. // The actual grid is assembled in ReRaceStart(). // In case of a race, when all cars start at the same time, // cars are simply added to the starting list in the order stored in ReStartingOrderIdx. // If only one car is at the track at a time (not timed session qualifying or practice), // the race is divided into many sub-races. // For a sub-race, only the car pointed by results/RE_ATTR_CUR_DRIVER // is added to the starting grid. // RE_ATTR_CUR_DRIVER is refreshed after every sub-race in ReRaceEnd(). ReCurrDriverNr = 0; int nCars = GfParmGetEltNb(params, RM_SECT_DRIVERS); GfParmListClean(params, RM_SECT_DRIVERS_RACING); if (nCars == 0) { // This may happen, when playing with the text-only mode, // and forgetting that human are automatically excluded then, // or when getting back to the GUI mode, and not reconfiguring the competitors list. GfLogError("No competitor in this race : cancelled.\n"); return RM_ERROR; } else { ReUI().addLoadingMessage("Determining Starting Order ..."); const char* gridType = GfParmGetStr(params, raceName, RM_ATTR_START_ORDER, RM_VAL_DRV_LIST_ORDER); int maxCars = (int)GfParmGetNum(params, raceName, RM_ATTR_MAX_DRV, NULL, 100); nCars = MIN(nCars, maxCars); tReGridPart *GridList = NULL; int nGridList = 0; // Initialize the array of car indexes for starting order if (ReStartingOrderIdx != NULL) { delete[] ReStartingOrderIdx; ReStartingOrderIdx = NULL; } ReStartingOrderIdx = new int[nCars]; for (int i = 0; i < nCars; i++) { ReStartingOrderIdx[i] = -1; } // Starting grid in the arrival order of the previous race (or qualification session) if (!strcmp(gridType, RM_VAL_LAST_RACE_ORDER)) { GfLogTrace("Starting grid in the order of the last race\n"); prevRaceName = ReGetPrevRaceName(/* bLoop = */false); if (!prevRaceName) { return RM_ERROR; } for (int i = 1; i < nCars + 1; i++) { snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", ReInfo->track->name, RE_SECT_RESULTS, prevRaceName, RE_SECT_RANK, i); ReStartingOrderIdx[i-1] = ReFindDriverIdx (GfParmGetStr(results, path, RE_ATTR_MODULE, ""), (int)GfParmGetNum(results, path, RE_ATTR_IDX, NULL, 0)); } } // Starting grid in the reversed arrival order of the previous race else if (!strcmp(gridType, RM_VAL_LAST_RACE_RORDER)) { GfLogTrace("Starting grid in the reverse order of the last race\n"); prevRaceName = ReGetPrevRaceName(/* bLoop = */false); if (!prevRaceName) { return RM_ERROR; } for (int i = 1; i < nCars + 1; i++) { snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", ReInfo->track->name, RE_SECT_RESULTS, prevRaceName, RE_SECT_RANK, nCars - i + 1); ReStartingOrderIdx[i-1] = ReFindDriverIdx (GfParmGetStr(results, path, RE_ATTR_MODULE, ""), (int)GfParmGetNum(results, path, RE_ATTR_IDX, NULL, 0)); } } // Starting grid as a mix from the results of earlier sessions else if (ReParseStartingOrder(gridType, &GridList, nCars, nGridList)) { GfLogTrace("Starting grid as a mix from the results of earlier sessions\n"); int idx; int gridpos = 1; int carnr; const char *modulename; for (int i = 0; i < nGridList; i++) { if (gridpos > nCars) {break;} if (GridList[i].diffpos == -1) {//reversed for ( int j = GridList[i].startpos; j >= GridList[i].endpos; j--) { if (gridpos > nCars) {break;} snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", ReInfo->track->name, RE_SECT_RESULTS, GridList[i].racename, RE_SECT_RANK, j); idx = (int)GfParmGetNum(results, path, RE_ATTR_IDX, NULL, 0); modulename = GfParmGetStr(results, path, RE_ATTR_MODULE, ""); carnr = ReFindDriverIdx(modulename, idx); for (int k = 0; k < gridpos-1; k++) { if ( carnr == ReStartingOrderIdx[k] ) { //oops: same car twice GfLogWarning("The same car appears twice in the advanced grid!\n"); carnr = -1; break; } } //adding car to the list if (carnr != -1) { ReStartingOrderIdx[gridpos-1] = carnr; gridpos++; } } } else if (GridList[i].diffpos == 1){//straight order for ( int j = GridList[i].startpos; j <= GridList[i].endpos; j++) { if (gridpos > nCars) {break;} snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", ReInfo->track->name, RE_SECT_RESULTS, GridList[i].racename, RE_SECT_RANK, j); idx = (int)GfParmGetNum(results, path, RE_ATTR_IDX, NULL, 0); modulename = GfParmGetStr(results, path, RE_ATTR_MODULE, ""); carnr = ReFindDriverIdx(modulename, idx); for (int k = 0; k < gridpos-1; k++) { if ( carnr == ReStartingOrderIdx[k] ) { //oops: same car twice GfLogWarning("The same car appears twice in the advanced grid!\n"); carnr = -1; break; } } //adding car to the list if (carnr != -1) { ReStartingOrderIdx[gridpos-1] = carnr; gridpos++; } } } } //cleaning up memory if (nGridList > 0){delete[] GridList;} } // Starting grid in the drivers list order else { GfLogTrace("Starting grid in the order of the driver list\n"); for (int i = 1; i < nCars + 1; i++) { snprintf(path, sizeof(path), "%s/%d", RM_SECT_DRIVERS, i); ReStartingOrderIdx[i-1] = ReFindDriverIdx (GfParmGetStr(params, path, RE_ATTR_MODULE, ""), (int)GfParmGetNum(params, path, RE_ATTR_IDX, NULL, 0)); } } } ReCurrDriverNr = 0; GfParmSetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_DRIVER, NULL, (tdble)ReStartingOrderIdx[ReCurrDriverNr]); return RM_SYNC | RM_NEXT_STEP; }
// Best supported features detection for the given specs of the frame buffer. bool GfglFeatures::detectBestSupport(int& nWidth, int& nHeight, int& nDepth, bool& bAlpha, bool& bFullScreen, bool& bBumpMapping, bool& bStereoVision, int &nAniFilt) { GfLogInfo("Detecting best supported features for a %dx%dx%d%s frame buffer.\n", nWidth, nHeight, nDepth, bFullScreen ? " full-screen" : ""); // I) Detection of the max possible values for requested features. // (to do that, we need to try setting up the video modes for real). SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); SDL_Surface* pWinSurface = 0; int nAlphaChannel = bAlpha ? 1 : 0; int nCurrDepth = nDepth; int nFullScreen = bFullScreen ? 1 : 0; int nStereoVision = bStereoVision ? 1 : 0; while (!pWinSurface && nFullScreen >= 0) { GfLogTrace("Trying %s mode\n", nFullScreen ? "full-screen" : "windowed"); const int bfVideoMode = SDL_OPENGL | (nFullScreen ? SDL_FULLSCREEN : 0); nAlphaChannel = bAlpha ? 1 : 0; while (!pWinSurface && nAlphaChannel >= 0) { GfLogTrace("Trying with%s alpha channel\n", nAlphaChannel ? "" : "out"); nCurrDepth = nDepth; while (!pWinSurface && nCurrDepth >= 16) { GfLogTrace("Trying %d bits RVB+A color depth\n", nCurrDepth); SDL_GL_SetAttribute(SDL_GL_RED_SIZE, nCurrDepth/4); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, nCurrDepth/4); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, nCurrDepth/4); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, (3*nCurrDepth)/4); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, nAlphaChannel ? nCurrDepth/4 : 0); while (!pWinSurface && nStereoVision >= 0) { GfLogTrace("Trying with%s stereo vision\n", nStereoVision ? "" : "out"); if (nStereoVision) SDL_GL_SetAttribute(SDL_GL_STEREO, GL_TRUE); else SDL_GL_SetAttribute(SDL_GL_STEREO, GL_FALSE); // Anti-aliasing : detect the max supported number of samples // (assumed to be <= 32). int nMaxMultiSamples = 32; // Hard coded max value for the moment. while (!pWinSurface && nMaxMultiSamples > 1) { // Set the anti-aliasing attributes and setup the video mode. GfLogTrace("Trying %dx anti-aliasing\n", nMaxMultiSamples); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, nMaxMultiSamples); pWinSurface = SDL_SetVideoMode(nWidth, nHeight, nCurrDepth, bfVideoMode); // Now check if we have a video mode, and if it actually features // what we specified. int nActualSampleBuffers = 0; int nActualMultiSamples = 0; if (pWinSurface) { SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &nActualSampleBuffers); SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &nActualMultiSamples); } //GfLogDebug("nMaxMultiSamples=%d : nActualSampleBuffers=%d, nActualMultiSamples=%d\n", // nMaxMultiSamples, nActualSampleBuffers, nActualMultiSamples); // If not, try a lower number of samples. if (nActualSampleBuffers == 0 || nActualMultiSamples != nMaxMultiSamples) pWinSurface = 0; if (!pWinSurface) { GfLogTrace("%d+%d bit %dx anti-aliased double-buffer not supported\n", 3*nCurrDepth/4, nCurrDepth/4, nMaxMultiSamples); nMaxMultiSamples /= 2; } } // Failed : try without anti-aliasing. if (!pWinSurface) { SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0); pWinSurface = SDL_SetVideoMode(nWidth, nHeight, nCurrDepth, bfVideoMode); if (!pWinSurface) GfLogTrace("%d+%d bit double-buffer not supported\n", 3*nCurrDepth/4, nCurrDepth/4); } // Failed : try without StereoVision if (!pWinSurface) nStereoVision--; } // Failed : try with lower color depth. if (!pWinSurface) nCurrDepth -= 8; } // Failed : try without alpha channel if not already done // (Note: it this really relevant ?). if (!pWinSurface) nAlphaChannel--; } // Failed : try a windowed mode if not already done. if (!pWinSurface) nFullScreen--; } // Failed : no more idea :-( if (!pWinSurface) { // Reset support data (will result in emptying the section when storing, // thus forcing new detection when checkSupport will be called again). _mapSupportedBool.clear(); _mapSupportedInt.clear(); GfLogError("No supported 'best' video mode found for a %dx%dx%d%s frame buffer.\n", nWidth, nHeight, nDepth, bFullScreen ? " full-screen" : ""); return false; } // II) Read-out what we have from the up-and-running frame buffer // and set "supported" values accordingly. // 1) Standard features. detectStandardSupport(); // 2) Multi-sampling = anti-aliasing int nValue; SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS, &nValue); _mapSupportedBool[MultiSampling] = nValue != 0; //GfLogDebug("SDL_GL_GetAttribute(SDL_GL_MULTISAMPLEBUFFERS) = %d\n", nValue); if (nValue) { SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES, &nValue); //GfLogDebug("SDL_GL_GetAttribute(SDL_GL_MULTISAMPLESAMPLES) = %d\n", nValue); if (nValue > 1) _mapSupportedInt[MultiSamplingSamples] = nValue; else _mapSupportedBool[MultiSampling] = false; } // III) Return the updated frame buffer specs. //nWidth = nWidth; // Unchanged. //nHeight = nHeight; // Unchanged. nDepth = nCurrDepth; bFullScreen = nFullScreen ? true : false; bAlpha = nAlphaChannel ? true : false; return true; }
static void rmRaceResults(void *prevHdle, tRmInfo *info, int start) { void *results = info->results; const char *race = info->_reRaceName; static char buf[256]; static char path[512]; char *str; GfLogTrace("Entering Race Results menu\n"); // Create screen, load menu XML descriptor and create static controls. rmScrHdle = GfuiScreenCreate(); void *hmenu = GfuiMenuLoad("raceresultsmenu.xml"); GfuiMenuCreateStaticControls(rmScrHdle, hmenu); // Create variable title label. snprintf(buf, sizeof(buf), "%s at %s", race, info->track->name); const int titleId = GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Title"); GfuiLabelSetText(rmScrHdle, titleId, buf); // Get layout properties. const int nMaxLines = (int)GfuiMenuGetNumProperty(hmenu, "nMaxResultLines", 15); const int yTopLine = (int)GfuiMenuGetNumProperty(hmenu, "yTopLine", 400); const int yLineShift = (int)GfuiMenuGetNumProperty(hmenu, "yLineShift", 20); const GfuiColor cPlaceGain = GfuiColor::build(GfuiMenuGetStrProperty(hmenu, "colorGainedPlaces", "0x32CD32")); const float* acPlaceGain = cPlaceGain.toFloatRGBA(); const GfuiColor cPlaceLoss = GfuiColor::build(GfuiMenuGetStrProperty(hmenu, "colorLostPlaces", "0xF28500")); const float* acPlaceLoss = cPlaceLoss.toFloatRGBA(); // Never used : remove ? //Get total laps, winner time //snprintf(path, sizeof(path), "%s/%s/%s", info->track->name, RE_SECT_RESULTS, race); //int totLaps = (int)GfParmGetNum(results, path, RE_ATTR_LAPS, NULL, 0); //snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", info->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK, 1); //tdble refTime = GfParmGetNum(results, path, RE_ATTR_TIME, NULL, 0); //Get number of cars snprintf(path, sizeof(path), "%s/%s/%s/%s", info->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK); int nbCars = (int)GfParmGetEltNb(results, path); // Display the result table. int y = yTopLine; int i; for (i = start; i < MIN(start + nMaxLines, nbCars); i++) { snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", info->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK, i + 1); int laps = (int)GfParmGetNum(results, path, RE_ATTR_LAPS, NULL, 0);//Laps covered //Rank snprintf(buf, sizeof(buf), "%d", i+1); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Rank", true, // From template. buf, GFUI_TPL_X, y); //Advance (The num.attrib 'index' holds the starting position) int advance = (int)(GfParmGetNum(results, path, RE_ATTR_INDEX, NULL, 0)) - i; snprintf(buf, sizeof(buf), "%d", advance); const float *aColor = advance > 0 ? acPlaceGain : (advance < 0 ? acPlaceLoss : GFUI_TPL_COLOR); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Advance", true, // From template. buf, GFUI_TPL_X, y, GFUI_TPL_FONTID, GFUI_TPL_WIDTH, GFUI_TPL_ALIGN, GFUI_TPL_MAXLEN, aColor); //Driver short name GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "DriverName", true, // From template. GfParmGetStr(results, path, RE_ATTR_SNAME, ""), GFUI_TPL_X, y); //Driver type const std::string strModName = GfParmGetStr(results, path, RE_ATTR_MODULE, ""); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "DriverType", true, // From template. GfDriver::getType(strModName).c_str(), GFUI_TPL_X, y); //Car GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "CarModel", true, // From template. GfParmGetStr(results, path, RE_ATTR_CAR, ""), GFUI_TPL_X, y); //Total Time str = GfTime2Str(GfParmGetNum(results, path, RE_ATTR_TIME, NULL, 0), 0, false, 3); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "TotalTime", true, // From template. str, GFUI_TPL_X, y); free(str); //Best lap str = GfTime2Str(GfParmGetNum(results, path, RE_ATTR_BEST_LAP_TIME, NULL, 0), 0, false, 3); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "BestLapTime", true, // From template. str, GFUI_TPL_X, y); free(str); //Laps covered snprintf(buf, sizeof(buf), "%d", laps); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Laps", true, // From template. buf, GFUI_TPL_X, y); //Top speed snprintf(buf, sizeof(buf), "%3.1f", (GfParmGetNum(results, path, RE_ATTR_TOP_SPEED, NULL, 0) * 3.6)); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "TopSpeed", true, // From template. buf, GFUI_TPL_X, y); //Damage snprintf(buf, sizeof(buf), "%d", (int)(GfParmGetNum(results, path, RE_ATTR_DAMMAGES, NULL, 0))); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Damages", true, // From template. buf, GFUI_TPL_X, y); //Pitstops snprintf(buf, sizeof(buf), "%d", (int)(GfParmGetNum(results, path, RE_ATTR_NB_PIT_STOPS, NULL, 0))); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Pits", true, // From template. buf, GFUI_TPL_X, y); y -= yLineShift; //Line feed }//for i //If it is not the first screen of the results, show a 'Prev' button if (start > 0) { RmPrevRace.prevHdle = prevHdle; RmPrevRace.info = info; RmPrevRace.start = start - nMaxLines; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "PreviousPageArrow", (void*)&RmPrevRace, rmChgRaceScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEUP, "Previous Results", (void*)&RmPrevRace, rmChgRaceScreen, NULL); }//if start // Add "Continue" button GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "ContinueButton", prevHdle, GfuiScreenReplace); //Create 'save' button in the bottom right //rmSaveButtonId = GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "SaveButton", info, rmSaveRes); //If we did not display all the results yet, let's show a 'Next' button if (i < nbCars) { RmNextRace.prevHdle = prevHdle; RmNextRace.info = info; RmNextRace.start = start + nMaxLines; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "NextPageArrow", (void*)&RmNextRace, rmChgRaceScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEDOWN, "Next Results", (void*)&RmNextRace, rmChgRaceScreen, NULL); }//if i //Link key handlers GfuiAddKey(rmScrHdle, GFUIK_ESCAPE, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_RETURN, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_F12, "Take a Screen Shot", NULL, GfuiScreenShot, NULL); GfuiAddKey(rmScrHdle, GFUIK_F1, "Help", rmScrHdle, GfuiHelpScreen, NULL); //Show! GfuiScreenActivate(rmScrHdle); }//rmRaceResults
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); }
/* * Function * linuxModInfoDir * * Description * Retrieve info about the modules whose shared library files are contained in a given directory * (for each shared library, load it, retrieve info about the module (tModInfo struct), * and finally unload the library). * * Parameters * dir (in) directory to search (relative) * level (in) if 1, load any shared library contained in the subdirs of dir * and whose name is the same as the containing subdir (ex: bt/bt.so) * if 0, load any shared library contained in dir (ignore subdirs) * modlist (in/out) list of module description structure (may begin empty) * * Return * >=0 number of modules loaded * -1 error * * Remarks * The loaded module info structures are added in the list according to each module's priority * (NOT at the head of the list). * */ static int linuxModInfoDir(unsigned int /* gfid */, const char *dir, int level, tModList **modlist) { char sopath[256]; /* path of the lib[x].so */ tSOHandle handle; DIR *dp; struct dirent *ep; int modnb; /* number on loaded modules */ tModList *curMod; modnb = 0; /* open the current directory */ dp = opendir(dir); if (dp) { /* some files in it */ while ((ep = readdir (dp)) != 0) { if (((strlen(ep->d_name) > 4) && (strcmp(".so", ep->d_name+strlen(ep->d_name)-3) == 0)) /* xxxx.so */ || ((level == 1) && (ep->d_name[0] != '.'))) { if (level == 1) sprintf(sopath, "%s/%s/%s.so", dir, ep->d_name, ep->d_name); else sprintf(sopath, "%s/%s", dir, ep->d_name); /* Try and avoid loading the same module twice (WARNING: Only checks sopath equality !) */ if (!GfModIsInList(sopath, *modlist)) { /* Load the shared library */ GfLogTrace("Querying module %s\n", sopath); handle = dlopen(sopath, RTLD_LAZY); if (handle) { /* Initialize the module */ if (GfModInitialize(handle, sopath, GfIdAny, &curMod) == 0) { if (curMod) /* Retained against gfid */ { /* Get associated info */ modnb++; GfModAddInList(curMod, modlist, /* priosort */ 1); } /* Terminate the module */ GfModTerminate(handle, sopath); } /* Close the shared library */ dlclose(handle); } else { GfLogError("linuxModInfoDir: ... %s\n", dlerror()); } } } } (void)closedir(dp); } else { GfLogError("linuxModInfoDir: ... Couldn't open the directory %s.\n", dir); return -1; } return modnb; }
void NetServer::ReadPacket(ENetEvent event) { ENetPacket *pPacket = event.packet; assert(pPacket->dataLength>=1); unsigned char packetId = pPacket->data[0]; //int datasize = pPacket->dataLength-1; switch (packetId) { case PLAYERINFO_PACKET: GfLogTrace("PlayerInfo Packet\n"); ReadDriverInfoPacket(pPacket,event.peer); break; case CLIENTREADYTOSTART_PACKET: { int l; char name[256]; memset(&name[0],0,256); PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadPacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); l = msg.unpack_int(); msg.unpack_string(name, l); } catch (PackedBufferException &e) { GfLogFatal("ReadPacket: packed buffer error\n"); } std::vector<NetDriver>::iterator p; p = m_vecWaitForPlayers.begin(); while(p!=m_vecWaitForPlayers.end()) { if (strcmp(p->name,name)==0) { GfLogTrace("%s ready to start\n",&name[0]); m_vecWaitForPlayers.erase(p); break; } p++; } if (m_vecWaitForPlayers.size()==0) m_bBeginRace = true; } break; case SERVER_TIME_REQUEST_PACKET: SendTimePacket(pPacket,event.peer); break; case CARCONTROLS_PACKET: ReadCarControlsPacket(event.packet); break; case CARSTATUS_PACKET: ReadCarStatusPacket(event.packet); break; case LAPSTATUS_PACKET: ReadLapStatusPacket(event.packet); break; case DRIVERREADY_PACKET: ReadDriverReadyPacket(event.packet); break; default: GfLogTrace ("A packet of length %u containing %s was received from %s on channel %u.\n", event.packet -> dataLength, event.packet -> data, (char*)event.peer -> data, event.channelID); } enet_packet_destroy (event.packet); }
void NetServer::ReadDriverInfoPacket(ENetPacket *pPacket, ENetPeer * pPeer) { NetDriver driver; char hostName[256]; enet_address_get_host_ip (&driver.address,hostName,256); GfLogTrace ("Client Player Info connected from %s\n",hostName); PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadDriverInfoPacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); driver.idx = msg.unpack_int(); msg.unpack_string(driver.name, sizeof driver.name); msg.unpack_string(driver.car, sizeof driver.car); msg.unpack_string(driver.team, sizeof driver.team); msg.unpack_string(driver.author, sizeof driver.author); driver.racenumber = msg.unpack_int(); msg.unpack_string(driver.skilllevel, sizeof driver.skilllevel); driver.red = msg.unpack_float(); driver.green = msg.unpack_float(); driver.blue = msg.unpack_float(); msg.unpack_string(driver.module, sizeof driver.module); msg.unpack_string(driver.type, sizeof driver.type); driver.client = msg.unpack_int(); } catch (PackedBufferException &e) { GfLogFatal("ReadDriverInfoPacket: packed buffer error\n"); } GfLogTrace("ReadDriverInfoPacket: driver\n"); GfLogTrace(".host=%d\n", driver.address.host); GfLogTrace(".port=%d\n", driver.address.port); GfLogTrace(".idx=%d\n", driver.idx); GfLogTrace(".name=%s\n", driver.name); GfLogTrace(".car=%s\n", driver.car); GfLogTrace(".team=%s\n", driver.team); GfLogTrace(".author=%s\n", driver.author); GfLogTrace(".racenumber=%d\n", driver.racenumber); GfLogTrace(".skilllevel=%s\n", driver.skilllevel); GfLogTrace(".red=%.1f\n", driver.red); GfLogTrace(".green=%.1f\n", driver.green); GfLogTrace(".blue=%.1f\n", driver.blue); GfLogTrace(".module=%s\n", driver.module); GfLogTrace(".type=%s\n", driver.type); GfLogTrace(".client=%d\n", driver.client); //Make sure player name is unique otherwise disconnect player NetServerMutexData *pSData = LockServerData(); for(unsigned int i=0;i<pSData->m_vecNetworkPlayers.size();i++) { if (strcmp(driver.name,pSData->m_vecNetworkPlayers[i].name)==0) { SendPlayerRejectedPacket(pPeer,"Player name already used. Please choose a different name."); UnlockServerData(); return; } } UnlockServerData(); driver.address.host = pPeer->address.host; driver.hostPort = pPeer->address.port; SendPlayerAcceptedPacket(pPeer); UpdateDriver(driver); GfLogTrace("Reading Driver Info Packet: Driver: %s,Car: %s\n",driver.name,driver.car); }
void NetServer::RemoveDriver(ENetEvent event) { int playerStartIndex; ENetAddress address = event.peer->address; char hostName[256]; enet_address_get_host_ip (&address,hostName,256); GfLogTrace ("Client Player Info disconnect from %s\n",hostName); std::vector<NetDriver>::iterator p; if (m_vecWaitForPlayers.size()>0) { p = m_vecWaitForPlayers.begin(); while(p!=m_vecWaitForPlayers.end()) { if ((p->address.host == address.host)&&(p->hostPort == address.port)) { m_vecWaitForPlayers.erase(p); break; } p++; } if (m_vecWaitForPlayers.size()==0) m_bBeginRace = true; } //look for driver id NetServerMutexData *pSData = LockServerData(); for (p = pSData->m_vecNetworkPlayers.begin();p!=pSData->m_vecNetworkPlayers.end();p++) { if (p->client) { if ((p->address.host == address.host)&&(p->hostPort == address.port)) { if(m_bRaceActive) { playerStartIndex = p->idx-1; pSData->m_vecNetworkPlayers.erase(p); RemovePlayerFromRace(playerStartIndex); GenerateDriversForXML(); RobotXml rXml; rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); SetRaceInfoChanged(true); } else { pSData->m_vecNetworkPlayers.erase(p); GenerateDriversForXML(); RobotXml rXml; rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); SetRaceInfoChanged(true); } UnlockServerData(); return; } } } UnlockServerData(); }
static void initPits(void) { tTrackPitInfo *pits; int i, j; /* typedef std::map<std::string, int> tTeamsMap; typedef tTeamsMap::const_iterator tTeamsMapIterator; tTeamsMap teams; tTeamsMapIterator teamsIterator; // create a list with the teams, a pit can just be used by one team. for (i = 0; i < ReInfo->s->_ncars; i++) { tCarElt *car = &(ReInfo->carList[i]); teams[car->_teamname] = teams[car->_teamname] + 1; } for (teamsIterator = teams.begin(); teamsIterator != teams.end(); ++teamsIterator) { GfLogDebug("----------------- %s\t%d\n", (teamsIterator->first).c_str(), teamsIterator->second); } */ // How many cars are sharing a pit? int carsPerPit = (int) GfParmGetNum(ReInfo->params, ReInfo->_reRaceName, RM_ATTR_CARSPERPIT, NULL, 1.0f); if (carsPerPit < 1) { carsPerPit = 1; } else if (carsPerPit > TR_PIT_MAXCARPERPIT) { carsPerPit = TR_PIT_MAXCARPERPIT; } GfLogInfo("Cars per pit: %d\n", carsPerPit); switch (ReInfo->track->pits.type) { case TR_PIT_ON_TRACK_SIDE: case TR_PIT_NO_BUILDING: pits = &(ReInfo->track->pits); pits->driversPitsNb = ReInfo->s->_ncars; pits->carsPerPit = carsPerPit; // Initialize pit data for every pit, necessary because of restarts // (track gets not reloaded, no calloc). for (i = 0; i < pits->nMaxPits; i++) { tTrackOwnPit *pit = &(pits->driversPits[i]); pit->freeCarIndex = 0; pit->pitCarIndex = TR_PIT_STATE_FREE; for (j = 0; j < TR_PIT_MAXCARPERPIT; j++) { pit->car[j] = NULL; } } // Assign cars to pits. Inefficient (O(n*n)), but just at initialization, so do not care. // One pit can just host cars of one team (this matches with the reality) for (i = 0; i < ReInfo->s->_ncars; i++) { // Find pit for the cars team. tCarElt *car = &(ReInfo->carList[i]); for (j = 0; j < pits->nMaxPits; j++) { tTrackOwnPit *pit = &(pits->driversPits[j]); // Put car in this pit if the pit is unused or used by a teammate and there is // space left. if (pit->freeCarIndex <= 0 || (strcmp(pit->car[0]->_teamname, car->_teamname) == 0 && pit->freeCarIndex < carsPerPit)) { // Assign car to pit. pit->car[pit->freeCarIndex] = car; // If this is the first car, set up more pit values ; assumption: the whole team // uses the same car. If not met, it does not matter much, but the car might be // captured a bit too easy or too hard. if (pit->freeCarIndex == 0) { pit->pitCarIndex = TR_PIT_STATE_FREE; pit->lmin = pit->pos.seg->lgfromstart + pit->pos.toStart - pits->len / 2.0f + car->_dimension_x / 2.0f; if (pit->lmin > ReInfo->track->length) { pit->lmin -= ReInfo->track->length; } pit->lmax = pit->pos.seg->lgfromstart + pit->pos.toStart + pits->len / 2.0f - car->_dimension_x / 2.0f; if (pit->lmax > ReInfo->track->length) { pit->lmax -= ReInfo->track->length; } } (pit->freeCarIndex)++; ReInfo->carList[i]._pit = pit; // Assigned, continue with next car. break; } } } // Print out assignments. for (i = 0; i < pits->nMaxPits; i++) { tTrackOwnPit *pit = &(pits->driversPits[i]); for (j = 0; j < pit->freeCarIndex; j++) { if (j == 0) { GfLogTrace("Pit %d, Team: %s, ", i, pit->car[j]->_teamname); } GfLogTrace("%d: %s ", j, pit->car[j]->_name); } if (j > 0) { GfOut("\n"); } } break; case TR_PIT_ON_SEPARATE_PATH: break; case TR_PIT_NONE: break; } }
bool GfglFeatures::loadSupport(int &nWidth, int &nHeight, int &nDepth, bool &bAlpha, bool &bFullScreen, bool &bBump, bool &bStereo, int &nAniFilt,void* hparmConfig) { // Clear support data. _mapSupportedBool.clear(); _mapSupportedInt.clear(); // Open the config file if not already done. void* hparm = hparmConfig ? hparmConfig : openConfigFile(); // Load the frame buffer specs for the stored supported features. nWidth = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_WIN_X, pszNoUnit, 0); nHeight = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_WIN_Y, pszNoUnit, 0); nDepth = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_BPP, pszNoUnit, 0); nAniFilt = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_ANISOTROPICFILTERING, pszNoUnit, 0); bAlpha = std::string(GfParmGetStr(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_ALPHACHANNEL, GFSCR_VAL_NO)) == GFSCR_VAL_YES; bFullScreen = std::string(GfParmGetStr(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_FSCR, GFSCR_VAL_NO)) == GFSCR_VAL_YES; bStereo = std::string(GfParmGetStr(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_STEREOVISION, GFSCR_VAL_NO)) == GFSCR_VAL_YES; bBump = std::string(GfParmGetStr(hparm, GFSCR_SECT_GLDETSPECS, GFSCR_ATT_BUMPMAPPING, GFSCR_VAL_NO)) == GFSCR_VAL_YES; // Check that we have something supported, and return if not. if (nWidth == 0 || nHeight == 0 || nDepth == 0) { GfLogTrace("No info found about best supported features for these specs ; " "will need a detection pass.\n"); // Close config file if we open it. if (!hparmConfig) closeConfigFile(hparm); return false; } // Here, we only update _mapSupportedXXX only if something relevant in the config file // If there's nothing or something not expected, it means no support. // 1) Double-buffer. const std::string strDoubleBuffer = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_DOUBLEBUFFER, ""); if (strDoubleBuffer == GFSCR_VAL_YES) _mapSupportedBool[DoubleBuffer] = true; else if (strDoubleBuffer == GFSCR_VAL_NO) _mapSupportedBool[DoubleBuffer] = false; // 2) Color buffer depth. const int nColorDepth = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_COLORDEPTH, pszNoUnit, (tdble)0); if (nColorDepth > 0) _mapSupportedInt[ColorDepth] = nColorDepth; // 3) Alpha-channel depth. const int nAlphaDepth = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_ALPHADEPTH, pszNoUnit, (tdble)-1); if (nAlphaDepth >= 0) _mapSupportedInt[AlphaDepth] = nAlphaDepth; // 4) Max texture size. const int nMaxTexSize = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_MAXTEXTURESIZE, pszNoUnit, (tdble)0); if (nMaxTexSize > 0) _mapSupportedInt[TextureMaxSize] = nMaxTexSize; // 5) Texture compression. const std::string strTexComp = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_TEXTURECOMPRESSION, ""); if (strTexComp == GFSCR_VAL_YES) _mapSupportedBool[TextureCompression] = true; else if (strTexComp == GFSCR_VAL_NO) _mapSupportedBool[TextureCompression] = false; // 6) Multi-texturing. const std::string strMultiTex = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_MULTITEXTURING, ""); if (strMultiTex == GFSCR_VAL_YES) _mapSupportedBool[MultiTexturing] = true; else if (strMultiTex == GFSCR_VAL_NO) _mapSupportedBool[MultiTexturing] = false; const int nMultiTexUnits = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_MULTITEXTURINGUNITS, pszNoUnit, (tdble)0); if (nMultiTexUnits > 0) _mapSupportedInt[MultiTexturingUnits] = nMultiTexUnits; // 7) Rectangle textures). const std::string strRectTex = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_RECTANGLETEXTURES, ""); if (strRectTex == GFSCR_VAL_YES) _mapSupportedBool[TextureRectangle] = true; else if (strRectTex == GFSCR_VAL_NO) _mapSupportedBool[TextureRectangle] = false; // 8) Non-power-of-2 textures. const std::string strNonPoTTex = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_NONPOTTEXTURES, ""); if (strNonPoTTex == GFSCR_VAL_YES) _mapSupportedBool[TextureNonPowerOf2] = true; else if (strNonPoTTex == GFSCR_VAL_NO) _mapSupportedBool[TextureNonPowerOf2] = false; // 9) Multi-sampling. const std::string strMultiSamp = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_MULTISAMPLING, ""); if (strMultiSamp == GFSCR_VAL_YES) _mapSupportedBool[MultiSampling] = true; else if (strMultiSamp == GFSCR_VAL_NO) _mapSupportedBool[MultiSampling] = false; const int nMultiSampSamples = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_MULTISAMPLINGSAMPLES, pszNoUnit, (tdble)0); if (nMultiSampSamples > 0) _mapSupportedInt[MultiSamplingSamples] = nMultiSampSamples; // 10) Stereo Vision const std::string strStereoVision = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_STEREOVISION, ""); if (strStereoVision == GFSCR_VAL_YES) _mapSupportedBool[StereoVision] = true; else if (strStereoVision == GFSCR_VAL_NO) _mapSupportedBool[StereoVision] = false; // 11) Bump Mapping. const std::string strBumpMapping = GfParmGetStr(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_BUMPMAPPING, ""); if (strTexComp == GFSCR_VAL_YES) //strTexComp ? Bug ? _mapSupportedBool[BumpMapping] = true; else if (strTexComp == GFSCR_VAL_NO) _mapSupportedBool[BumpMapping] = false; // 11) Anisotropic Filtering. const int nAF = (int)GfParmGetNum(hparm, GFSCR_SECT_GLDETFEATURES, GFSCR_ATT_ANISOTROPICFILTERING, pszNoUnit, (tdble)0); if (nMaxTexSize > 0) _mapSupportedInt[AnisotropicFiltering] =nAF; // Close config file if we open it. if (!hparmConfig) closeConfigFile(hparm); // Trace best supported features. dumpSupport(); return true; }
/** * Function to load a car. * * @param carindex The index whichs will be used as car->index for the car. * @param listindex The listindex in RM_SECT_DRIVERS_RACING * @param modindex The index of the mod; must be MAX_MOD_ITF if normal_carname is FALSE. * @param robotIdx The index of the robot. * @param normal_carname If this member is TRUE, the car is treated as an ordinary car; * if this member is FALSE, then the car used is the one given * in the xml-file, and there is no restriction on the number of instances. * @param cardllname The dllname of the driver * @return A pointer to the newly created car if successfull; NULL otherwise */ static tCarElt* reLoadSingleCar( int carindex, int listindex, int modindex, int relativeRobotIdx, char normal_carname, char const *cardllname ) { tCarElt *elt; tMemoryPool oldPool; char path[256]; char path2[256]; char buf[256]; char buf2[256]; char const *str; char const *category; char const *subcategory; char const *teamname; std::string carname; tModInfoNC *curModInfo; tRobotItf *curRobot; void *robhdle; void *cathdle; void *carhdle; void *handle; int k; int xx; char isHuman; int robotIdx = relativeRobotIdx; /* good robot found */ curModInfo = &((*(ReInfo->robModList))->modInfo[modindex]); subcategory = ReInfo->track->subcategory; #if 0 //SDW if (replayReplay) GfLogInfo("Driver in car %d being driven by replay\n", carindex); else #endif GfLogInfo("Driver's name: %s\n", curModInfo->name); isHuman = strcmp( cardllname, "human" ) == 0 || strcmp( cardllname, "networkhuman" ) == 0; /* Extended is forced for humans, so no need to increase robotIdx */ if (!normal_carname && !isHuman) robotIdx += curModInfo->index; /* Retrieve the driver interface (function pointers) */ curRobot = (tRobotItf*)calloc(1, sizeof(tRobotItf)); /* ... and initialize the driver */ #if 0 // SDW if (replayReplay) { // Register against the Replay driver (which does nothing) curModInfo->fctInit(carindex, (void*)(curRobot)); } else if (!(ReInfo->_displayMode & RM_DISP_MODE_SIMU_SIMU)) { #else if (!(ReInfo->_displayMode & RM_DISP_MODE_SIMU_SIMU)) { #endif curModInfo->fctInit(robotIdx, (void*)(curRobot)); } else { curRobot->rbNewTrack = NULL; curRobot->rbNewRace = NULL; curRobot->rbResumeRace = NULL; curRobot->rbDrive = NULL; curRobot->rbPitCmd = NULL; curRobot->rbEndRace = NULL; curRobot->rbShutdown = NULL; curRobot->index = 0; } /* Retrieve and load the robotXML file : 1) from user settings dir (local dir) 2) from installed data dir */ snprintf(buf, sizeof(buf), "%sdrivers/%s/%s.xml", GfLocalDir(), cardllname, cardllname); robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD); if (!robhdle) { snprintf(buf, sizeof(buf), "drivers/%s/%s.xml", cardllname, cardllname); robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD); } if (normal_carname || isHuman) snprintf(path, sizeof(path), "%s/%s/%d", ROB_SECT_ROBOTS, ROB_LIST_INDEX, robotIdx); else snprintf(path, sizeof(path), "%s", ROB_SECT_ARBITRARY); /* Load car/driver info (in race engine data structure) */ if (robhdle) { elt = &(ReInfo->carList[carindex]); GF_TAILQ_INIT(&(elt->_penaltyList)); const std::string strDType = GfParmGetStr(robhdle, path, ROB_ATTR_TYPE, ROB_VAL_ROBOT); if (strDType == ROB_VAL_ROBOT){ elt->_driverType = RM_DRV_ROBOT; elt->_networkPlayer = 0; } else if (strDType == ROB_VAL_HUMAN) { elt->_driverType = RM_DRV_HUMAN; std::string strNetPlayer = GfParmGetStr(robhdle, path, "networkrace", "no"); elt->_networkPlayer = (strNetPlayer == "yes") ? 1 : 0; } elt->index = carindex; elt->robot = curRobot; elt->_paramsHandle = robhdle; elt->_driverIndex = robotIdx; elt->_moduleIndex = relativeRobotIdx; strncpy(elt->_modName, cardllname, MAX_NAME_LEN - 1); elt->_modName[MAX_NAME_LEN - 1] = 0; //snprintf(path, sizeof(path), "%s/%s/%d", ROB_SECT_ROBOTS, ROB_LIST_INDEX, robotIdx); snprintf( path2, sizeof(path2), "%s/%s/%d/%d", RM_SECT_DRIVERINFO, elt->_modName, normal_carname ? 0 : 1, elt->_moduleIndex ); if (normal_carname || elt->_driverType == RM_DRV_HUMAN) { strncpy(elt->_name, GfParmGetStr(robhdle, path, ROB_ATTR_NAME, "none"), MAX_NAME_LEN - 1); strncpy(elt->_sname, GfParmGetStr(robhdle, path, ROB_ATTR_SNAME, "none"), MAX_NAME_LEN - 1); strncpy(elt->_cname, GfParmGetStr(robhdle, path, ROB_ATTR_CODE, "---"), 3); } else { strncpy(elt->_name, GfParmGetStr(ReInfo->params, path2, ROB_ATTR_NAME, "none"), MAX_NAME_LEN - 1); strncpy(elt->_sname, GfParmGetStr(ReInfo->params, path2, ROB_ATTR_SNAME, "none"), MAX_NAME_LEN - 1); strncpy(elt->_cname, GfParmGetStr(ReInfo->params, path2, ROB_ATTR_CODE, "---"), 3); } elt->_name[MAX_NAME_LEN - 1] = 0; elt->_sname[MAX_NAME_LEN - 1] = 0; elt->_cname[3] = 0; teamname = GfParmGetStr(robhdle, path, ROB_ATTR_TEAM, "none"); teamname = GfParmGetStr(ReInfo->params, path2, ROB_ATTR_TEAM, teamname ); //Use the name in params if it has a team name strncpy(elt->_teamname, teamname, MAX_NAME_LEN - 1); elt->_teamname[MAX_NAME_LEN - 1] = 0; elt->_driveSkill = GfParmGetNum(ReInfo->params, path2, RM_ATTR_SKILLLEVEL, NULL, -1.0f); if (normal_carname) /* Even if we get a normal_carname for humans we use it despite of forced extended mode*/ strncpy(elt->_carName, GfParmGetStr(robhdle, path, ROB_ATTR_CAR, ""), MAX_NAME_LEN - 1); else strncpy(elt->_carName, GfParmGetStr(ReInfo->params, path2, RM_ATTR_CARNAME, ""), MAX_NAME_LEN - 1); elt->_carName[MAX_NAME_LEN - 1] = 0; /* XML file name */ // Load custom skin name and targets from race info (if specified). snprintf(path2, sizeof(path2), "%s/%d", RM_SECT_DRIVERS_RACING, listindex); if (GfParmGetStr(ReInfo->params, path2, RM_ATTR_SKINNAME, 0)) { strncpy(elt->_skinName, GfParmGetStr(ReInfo->params, path2, RM_ATTR_SKINNAME, ""), MAX_NAME_LEN - 1); elt->_skinName[MAX_NAME_LEN - 1] = 0; // Texture name } elt->_skinTargets = (int)GfParmGetNum(ReInfo->params, path2, RM_ATTR_SKINTARGETS, (char*)NULL, 0); // Load other data from robot descriptor. elt->_raceNumber = (int)GfParmGetNum(robhdle, path, ROB_ATTR_RACENUM, (char*)NULL, 0); if (!normal_carname && elt->_driverType != RM_DRV_HUMAN) // Increase racenumber if needed elt->_raceNumber += elt->_moduleIndex; elt->_skillLevel = 0; str = GfParmGetStr(robhdle, path, ROB_ATTR_LEVEL, ROB_VAL_SEMI_PRO); for(k = 0; k < NSkillLevels; k++) { if (strcmp(aPszSkillLevelNames[k], str) == 0) { elt->_skillLevel = k; break; } } elt->_startRank = carindex; elt->_pos = carindex+1; elt->_remainingLaps = ReInfo->s->_totLaps; elt->_newTrackMemPool = NULL; elt->_newRaceMemPool = NULL; elt->_endRaceMemPool = NULL; elt->_shutdownMemPool = NULL; carname = elt->_carName; GfLogTrace("Driver #%d(%d) : module='%s', name='%s', car='%s', cat='%s', skin='%s' on %x\n", carindex, listindex, elt->_modName, elt->_name, elt->_carName, elt->_category, elt->_skinName, elt->_skinTargets); if ((strncmp(carname.c_str(), "mpa1", 4) == 0)) { if (strcmp(subcategory, "long") == 0) carname = carname+"-long"; else if (strcmp(subcategory, "short") == 0) carname = carname+"-short"; else carname = carname+"-road"; GfLogTrace("MPA... Category car = %s \n", carname.c_str()); /* Retrieve and load car specs : merge car default specs, category specs and driver modifications (=> handle) */ /* Read Car model specifications */ snprintf(buf, sizeof(buf), "cars/models/%s/%s.xml", elt->_carName, carname.c_str()); carhdle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT); } else { /* Retrieve and load car specs : merge car default specs, category specs and driver modifications (=> handle) */ /* Read Car model specifications */ snprintf(buf, sizeof(buf), "cars/models/%s/%s.xml", elt->_carName, elt->_carName); carhdle = GfParmReadFile(buf, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT); } category = GfParmGetStr(carhdle, SECT_CAR, PRM_CATEGORY, NULL); if (category) { GfLogTrace("Checking/Merging %s specs into %s base setup for %s ...\n", category, elt->_carName, curModInfo->name); strncpy(elt->_category, category, MAX_NAME_LEN - 1); elt->_category[MAX_NAME_LEN - 1] = 0; /* Read Car Category specifications */ snprintf(buf2, sizeof(buf2), "cars/categories/%s.xml", elt->_category); cathdle = GfParmReadFile(buf2, GFPARM_RMODE_STD | GFPARM_RMODE_CREAT); int errorcode = 0; if ((errorcode = GfParmCheckHandle(cathdle, carhdle))) { switch (errorcode) { case -1: GfLogError("Car %s NOT in category %s (driver %s) !!!\n", elt->_carName, category, elt->_name); break; case -2: GfLogError("Parameters out of bound for car %s (driver %s)!!!\n",elt->_carName, elt->_name); break; case -3: GfLogError("Parameter not allowed for car %s (driver %s)!!!\n",elt->_carName, elt->_name); break; default: GfLogError("Unknown error for %s (driver %s)!!!\n",elt->_carName, elt->_name); break; } return NULL; } carhdle = GfParmMergeHandles(cathdle, carhdle, GFPARM_MMODE_SRC | GFPARM_MMODE_DST | GFPARM_MMODE_RELSRC | GFPARM_MMODE_RELDST); /* The code below stores the carnames to a separate xml-file such that at newTrack it is known which car is used. TODO: find a better method for this */ snprintf (buf, sizeof(buf), "%sdrivers/curcarnames.xml", GfLocalDir()); handle = GfParmReadFile(buf, GFPARM_RMODE_CREAT); if (handle) { snprintf(path, sizeof(path), "drivers/%s/%d", cardllname, elt->_driverIndex); GfParmSetStr (handle, path, RM_ATTR_CARNAME, elt->_carName); GfParmWriteFile (0, handle, "Car names"); GfParmReleaseHandle (handle); } if (!(ReInfo->_displayMode & RM_DISP_MODE_SIMU_SIMU)) { GfPoolMove(&elt->_newTrackMemPool, &oldPool); curRobot->rbNewTrack(elt->_driverIndex, ReInfo->track, carhdle, &handle, ReInfo->s); GfPoolFreePool( &oldPool ); } else handle = NULL; if (handle && !replayReplay) { GfLogTrace("Checking/Merging %s specific setup into %s setup.\n", curModInfo->name, elt->_carName); if (GfParmCheckHandle(carhdle, handle)) { GfLogError("Bad Car parameters for driver %s\n", elt->_name); return NULL; } handle = GfParmMergeHandles(carhdle, handle, GFPARM_MMODE_SRC | GFPARM_MMODE_DST | GFPARM_MMODE_RELSRC | GFPARM_MMODE_RELDST); } else { GfLogTrace("Keeping %s setup as is for %s (no specific setup).\n", elt->_carName, curModInfo->name); handle = carhdle; } elt->_carHandle = handle; /* Initialize sectors */ elt->_currentSector = 0; elt->_curSplitTime = (double*)malloc( sizeof(double) * ( ReInfo->track->numberOfSectors - 1 ) ); elt->_bestSplitTime = (double*)malloc( sizeof(double) * ( ReInfo->track->numberOfSectors - 1 ) ); for (xx = 0; xx < ReInfo->track->numberOfSectors - 1; ++xx) { elt->_curSplitTime[xx] = -1.0f; elt->_bestSplitTime[xx] = -1.0f; } } else { elt->_category[ 0 ] = '\0'; GfLogError("Bad Car category for driver %s\n", elt->_name); return NULL; } return elt; } else { GfLogError("No description file for robot %s\n", cardllname); } return NULL; } /** Initialize the cars for a race. The cars are positionned on the starting grid. @return 0 Ok, -1 Error */ int ReInitCars(void) { char buf[512]; char path[512]; int nCars; int index; int i, j; const char *robotModuleName; int robotIdx; void *robhdle; tCarElt *elt; //const char *focused; // Never used. //int focusedIdx; // Never used. void *params = ReInfo->params; /* Get the number of cars (= drivers) racing */ nCars = GfParmGetEltNb(params, RM_SECT_DRIVERS_RACING); GfLogTrace("Loading %d car(s)\n", nCars); FREEZ(ReInfo->carList); ReInfo->carList = (tCarElt*)calloc(nCars, sizeof(tCarElt)); FREEZ(ReInfo->rules); ReInfo->rules = (tRmCarRules*)calloc(nCars, sizeof(tRmCarRules)); //focused = GfParmGetStr(ReInfo->params, RM_SECT_DRIVERS, RM_ATTR_FOCUSED, ""); //focusedIdx = (int)GfParmGetNum(ReInfo->params, RM_SECT_DRIVERS, RM_ATTR_FOCUSEDIDX, NULL, 0); index = 0; /* For each car/driver : */ for (i = 1; i < nCars + 1; i++) { /* Get the name of the module (= shared library) of the robot */ snprintf(path, sizeof(path), "%s/%d", RM_SECT_DRIVERS_RACING, i); robotModuleName = GfParmGetStr(ReInfo->params, path, RM_ATTR_MODULE, ""); robotIdx = (int)GfParmGetNum(ReInfo->params, path, RM_ATTR_IDX, NULL, 0); #if 0 // SDW if (replayReplay) // Register against the Replay driver snprintf(path, sizeof(path), "%sdrivers/replay/replay.%s", GfLibDir(), DLLEXT); else #endif snprintf(path, sizeof(path), "%sdrivers/%s/%s.%s", GfLibDir(), robotModuleName, robotModuleName, DLLEXT); /* Load the robot shared library */ if (GfModLoad(CAR_IDENT, path, ReInfo->robModList)) { GfLogError("Failed to load robot module %s\n", path); continue; } /* Load the racing driver info in the race data structure */ elt = NULL; snprintf(path, sizeof(path), "%s/%d", RM_SECT_DRIVERS_RACING, i); if ((int)GfParmGetNum(ReInfo->params, path, RM_ATTR_EXTENDED, NULL, 0) == 0) { /* Search for the index of the racing driver in the list of interfaces of the module */ for (j = 0; j < (*(ReInfo->robModList))->modInfoSize; j++) { if ((*(ReInfo->robModList))->modInfo[j].name && (*(ReInfo->robModList))->modInfo[j].index == robotIdx) { /* We have the right driver : load it */ elt = reLoadSingleCar( index, i, j, robotIdx, TRUE, robotModuleName ); if (!elt) { GfLogError("No descriptor file for robot %s or parameter errors (1)\n", robotModuleName); snprintf(buf, sizeof(buf), "Error: May be no driver, or some parameters are out of bound"); ReUI().addLoadingMessage(buf); snprintf(buf, sizeof(buf), " Have a look at the console window for mode details about the error"); ReUI().addLoadingMessage(buf); snprintf(buf, sizeof(buf), " Back to the config menu in 10 s ..."); ReUI().addLoadingMessage(buf); // Wait some time to allow the user to read the message! GfSleep(10.0); // 10 seconds } } } } else { GfLogTrace("Loading robot %s descriptor file\n", robotModuleName ); snprintf(buf, sizeof(buf), "%sdrivers/%s/%s.xml", GfLocalDir(), robotModuleName, robotModuleName); robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD); if (!robhdle) { snprintf(buf, sizeof(buf), "drivers/%s/%s.xml", robotModuleName, robotModuleName); robhdle = GfParmReadFile(buf, GFPARM_RMODE_STD); } if (robhdle && ( strcmp( robotModuleName, "human" ) == 0 || strcmp( robotModuleName, "networkhuman" ) == 0 ) ) { /* Human driver */ elt = reLoadSingleCar( index, i, robotIdx - (*(ReInfo->robModList))->modInfo[0].index, robotIdx, FALSE, robotModuleName ); } else if (robhdle && ( strcmp( GfParmGetStr( robhdle, ROB_SECT_ARBITRARY, ROB_ATTR_TEAM, "foo" ), GfParmGetStr( robhdle, ROB_SECT_ARBITRARY, ROB_ATTR_TEAM, "bar" ) ) == 0 ) ) { elt = reLoadSingleCar( index, i, (*(ReInfo->robModList))->modInfoSize, robotIdx, FALSE, robotModuleName ); } else GfLogError("No descriptor for robot %s (2)\n", robotModuleName ); } if (elt) ++index; } nCars = index; /* real number of cars */ if (nCars == 0) { GfLogError("No driver for that race ; exiting ...\n"); return -1; } else { GfLogInfo("%d driver(s) ready to race\n", nCars); } if (replayReplay) replayRecord = 0; else { char buf[1024]; const char *replayRateSchemeName; snprintf(buf, sizeof(buf), "%s%s", GfLocalDir(), RACE_ENG_CFG); void *paramHandle = GfParmReadFile(buf, GFPARM_RMODE_REREAD | GFPARM_RMODE_CREAT); replayRateSchemeName = GfParmGetStr(paramHandle, RM_SECT_RACE_ENGINE, RM_ATTR_REPLAY_RATE, "0"); GfParmReleaseHandle(paramHandle); replayRecord = atoi(replayRateSchemeName); } if (replayRecord || replayReplay) { #ifdef THIRD_PARTY_SQLITE3 int result; result = sqlite3_open("/tmp/race.sqlite", &replayDB); if (result) { GfLogError("Replay: Unable to open Database: %s\n", sqlite3_errmsg(replayDB)); sqlite3_close(replayDB); replayDB = NULL; } else { GfLogInfo("Replay: Database Opened 0x8%8.8X\n", replayDB); if (replayRecord) GfLogInfo("Replay: Record Timestep = %f\n", 1/(float)replayRecord); if (replayReplay) GfLogInfo("Replay: Playback from file\n"); /* speed up database by turning of synchronous behaviour/etc */ sqlite3_exec(replayDB, "PRAGMA synchronous = OFF", NULL, NULL, NULL); sqlite3_exec(replayDB, "PRAGMA journal_mode = OFF", NULL, NULL, NULL); sqlite3_exec(replayDB, "PRAGMA count_changes = OFF", NULL, NULL, NULL); #if 0 // This pragma seems to prevent re-opening the sqlite3 database sqlite3_exec(replayDB, "PRAGMA locking_mode = EXCLUSIVE", NULL, NULL, NULL); #endif sqlite3_exec(replayDB, "PRAGMA default_temp_store = MEMORY", NULL, NULL, NULL); //replayBlobs = (sqlite3_stmt *) calloc(nCars, sizeof(void *)); //sqlite3_stmt)); replayTimestamp = -5; ghostcarActive = 0; } #endif } ReInfo->s->_ncars = nCars; FREEZ(ReInfo->s->cars); ReInfo->s->cars = (tCarElt **)calloc(nCars, sizeof(tCarElt *)); for (i = 0; i < nCars; i++) { ReInfo->s->cars[i] = &(ReInfo->carList[i]); #ifdef THIRD_PARTY_SQLITE3 //open a table for each car if (replayDB) { char command[200]; int result; if (replayRecord) { sprintf(command, "DROP TABLE IF EXISTS car%d", i); result = sqlite3_exec(replayDB, command, 0, 0, 0); if (result) GfLogInfo("Replay: Unable to drop table car%d: %s\n", i, sqlite3_errmsg(replayDB)); } sprintf(command, "CREATE TABLE IF NOT EXISTS car%d (timestamp, lap, datablob BLOB)", i); result = sqlite3_exec(replayDB, command, 0, 0, 0); if (result) { GfLogInfo("Replay: Unable to create table car%d: %s\n", i, sqlite3_errmsg(replayDB)); exit(0); } if (replayReplay) { // Build index to allow faster read access sprintf(command, "CREATE UNIQUE INDEX IF NOT EXISTS index%d ON car%d (timestamp)", i, i); result = sqlite3_exec(replayDB, command, 0, 0, 0); if (result) GfLogInfo("Replay: Unable to create index car%d: %s\n", i, sqlite3_errmsg(replayDB)); } } #endif } ReInfo->_rePitRequester = 0; // TODO: reconsider splitting the call into one for cars, track and maybe other objects. // I stuff for now anything into one call because collision detection works with the same // library on all objects, so it is a bit dangerous to distribute the handling to various // locations (because the library maintains global state like a default collision handler etc.). RePhysicsEngine().initialize(nCars, ReInfo->track); initStartingGrid(); initPits(); return 0; }
void GfFileSetup() { void *dataVersionHandle; void *localVersionHandle; char *filename; size_t filenameLength; char *dataLocation; char *localLocation; char *absLocalLocation; char *absDataLocation; bool *isIndexUsed; int isIndexUsedLen; int index; bool anyLocalChange, fileFound; int major; int minor; struct stat st; // Open data (installation) version.xml. filenameLength = strlen(GfDataDir()) + 12 + 40; filename = (char*)malloc( sizeof(char) * filenameLength ); sprintf( filename, "%sversion.xml", GfDataDir() ); dataVersionHandle = GfParmReadFile( filename, GFPARM_RMODE_STD ); if( !dataVersionHandle ) { free( filename ); return; } // Exit if nothing inside. if( GfParmListSeekFirst( dataVersionHandle, "versions" ) != 0 ) { free( filename ); GfParmReleaseHandle( dataVersionHandle ); return; } // Create LocalDir (user settings root) if not already done. GfDirCreate( GfLocalDir() ); // Open local (user settings) version.xml (create it if not there). if( filenameLength < strlen(GfLocalDir()) + 12 ) { free( filename ); filenameLength = strlen(GfLocalDir()) + 12 + 40; filename = (char*)malloc( sizeof(char) * filenameLength ); } sprintf( filename, "%sversion.xml", GfLocalDir() ); anyLocalChange = !GfFileExists(filename); localVersionHandle = GfParmReadFile( filename, GFPARM_RMODE_CREAT ); // Exit if open/creation failed. if( !localVersionHandle ) { free( filename ); GfParmReleaseHandle( dataVersionHandle ); return; } // Setup the index of the XML files referenced in the local version.xml. isIndexUsedLen = GfParmGetEltNb( localVersionHandle, "versions" ) + GfParmGetEltNb( dataVersionHandle, "versions" ) + 2; isIndexUsed = (bool*)malloc( sizeof(bool) * isIndexUsedLen ); for( index = 0; index < isIndexUsedLen; index++ ) isIndexUsed[index] = false; if( GfParmListSeekFirst( localVersionHandle, "versions" ) == 0 ) { do { index = atoi( GfParmListGetCurEltName( localVersionHandle, "versions" ) ); if( 0 <= index && index < isIndexUsedLen ) isIndexUsed[index] = true; } while( GfParmListSeekNext( localVersionHandle, "versions" ) == 0 ); } // For each file referenced in the installation version.xml do { fileFound = false; // Get its installation path (data), user settings path (local), // and new major and minor version numbers dataLocation = strdup( GfParmGetCurStr( dataVersionHandle, "versions", "Data location", "" ) ); localLocation = strdup( GfParmGetCurStr( dataVersionHandle, "versions", "Local location", "" ) ); major = (int)GfParmGetCurNum( dataVersionHandle, "versions", "Major version", NULL, 0 ); minor = (int)GfParmGetCurNum( dataVersionHandle, "versions", "Minor version", NULL, 0 ); absLocalLocation = (char*)malloc( sizeof(char)*(strlen(GfLocalDir())+strlen(localLocation)+3) ); sprintf( absLocalLocation, "%s%s", GfLocalDir(), localLocation ); absDataLocation = (char*)malloc( sizeof(char)*(strlen(GfDataDir())+strlen(dataLocation)+3) ); sprintf( absDataLocation, "%s%s", GfDataDir(), dataLocation ); GfLogTrace("Checking %s : user settings version ", localLocation); // Search for its old major and minor version numbers in the user settings. if( GfParmListSeekFirst( localVersionHandle, "versions" ) == 0 ) { do { if( strcmp( absLocalLocation, GfParmGetCurStr( localVersionHandle, "versions", "Local location", "" ) ) == 0 ) { fileFound = true; const int locMinor = (int)GfParmGetCurNum( localVersionHandle, "versions", "Minor version", NULL, 0 ); const int locMajor = (int)GfParmGetCurNum( localVersionHandle, "versions", "Major version", NULL, 0 ); GfLogTrace("%d.%d is ", locMajor, locMinor); if( locMajor != major || locMinor < minor) { GfLogTrace("obsolete (installed one is %d.%d) => updating ...\n", major, minor); if ( gfFileSetupCopy( absDataLocation, absLocalLocation, major, minor, localVersionHandle, -1 ) ) anyLocalChange = true; } else { GfLogTrace("up-to-date"); if (stat(absLocalLocation, &st)) { GfLogTrace(", but not there => installing ...\n"); if ( gfFileSetupCopy( absDataLocation, absLocalLocation, major, minor, localVersionHandle, -1 ) ) anyLocalChange = true; } else GfLogTrace(".\n"); } break; } } while( GfParmListSeekNext( localVersionHandle, "versions" ) == 0 ); } if( !fileFound) { index = 0; while( isIndexUsed[index] ) ++index; GfLogTrace("not found => installing ...\n"); if ( gfFileSetupCopy( absDataLocation, absLocalLocation, major, minor, localVersionHandle, index ) ) anyLocalChange = true; isIndexUsed[index] = true; } free( dataLocation ); free( localLocation ); free( absDataLocation ); free( absLocalLocation ); } while( GfParmListSeekNext( dataVersionHandle, "versions" ) == 0 ); // Write the user settings version.xml if changed. if (anyLocalChange) GfParmWriteFile( NULL, localVersionHandle, "versions" ); GfParmReleaseHandle( localVersionHandle ); GfParmReleaseHandle( dataVersionHandle ); free( isIndexUsed ); free( filename ); }
static void rmQualifResults(void *prevHdle, tRmInfo *info, const char* pszTitle, int start) { void *results = info->results; const char *race = info->_reRaceName; int i; static char buf[256]; static char path[512]; char *str; GfLogTrace("Entering %s Results menu\n", pszTitle); // Create screen, load menu XML descriptor and create static controls. rmScrHdle = GfuiScreenCreate(); void *hmenu = GfuiMenuLoad("qualifsresultsmenu.xml"); GfuiMenuCreateStaticControls(rmScrHdle, hmenu); // Create variable title label. const int titleId = GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Title"); snprintf(buf, sizeof(buf), "%s at %s", race, info->track->name); GfuiLabelSetText(rmScrHdle, titleId, buf); // Get layout properties. const int nMaxLines = (int)GfuiMenuGetNumProperty(hmenu, "nMaxResultLines", 15); const int yTopLine = (int)GfuiMenuGetNumProperty(hmenu, "yTopLine", 400); const int yLineShift = (int)GfuiMenuGetNumProperty(hmenu, "yLineShift", 20); // Never used : remove ? //snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", info->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK, 1); //tdble refTime = GfParmGetNum(results, path, RE_ATTR_TIME, NULL, 0); //snprintf(path, sizeof(path), "%s/%s/%s", info->track->name, RE_SECT_RESULTS, race); //const int totLaps = (int)GfParmGetNum(results, path, RE_ATTR_LAPS, NULL, 0); snprintf(path, sizeof(path), "%s/%s/%s/%s", info->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK); const int nbCars = (int)GfParmGetEltNb(results, path); GfLogDebug("rmQualifResults: path=%s, file=%s\n", path, GfParmGetFileName(results)); GfLogDebug("rmQualifResults: start=%d, nbCars=%d, nMaxLines=%d\n", start, nbCars, nMaxLines); int y = yTopLine; for (i = start; i < MIN(start + nMaxLines, nbCars); i++) { snprintf(path, sizeof(path), "%s/%s/%s/%s/%d", info->track->name, RE_SECT_RESULTS, race, RE_SECT_RANK, i + 1); // Never used : remove ? //const int laps = (int)GfParmGetNum(results, path, RE_ATTR_LAPS, NULL, 0); //Rank snprintf(buf, sizeof(buf), "%d", i+1); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Rank", true, // From template. buf, GFUI_TPL_X, y); //Driver short name GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "DriverName", true, // From template. GfParmGetStr(results, path, RE_ATTR_SNAME, ""), GFUI_TPL_X, y); //Driver type const std::string strModName = GfParmGetStr(results, path, RE_ATTR_MODULE, ""); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "DriverType", true, // From template. GfDriver::getType(strModName).c_str(), GFUI_TPL_X, y); //Car GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "CarModel", true, // From template. GfParmGetStr(results, path, RE_ATTR_CAR, ""), GFUI_TPL_X, y); //Best lap str = GfTime2Str(GfParmGetNum(results, path, RE_ATTR_BEST_LAP_TIME, NULL, 0), 0, false, 3); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "BestLapTime", true, // From template. str, GFUI_TPL_X, y); free(str); // Next line. y -= yLineShift; }//for i if (start > 0) { RmPrevRace.prevHdle = prevHdle; RmPrevRace.info = info; RmPrevRace.start = start - nMaxLines; RmPrevRace.title = pszTitle; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "PreviousPageArrow", (void*)&RmPrevRace, rmChgQualifScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEUP, "Previous Results", (void*)&RmPrevRace, rmChgQualifScreen, NULL); } // Add "Continue" button GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "ContinueButton", prevHdle, GfuiScreenReplace); //Create 'save' button in the bottom right //rmSaveButtonId = GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "savebutton", info, rmSaveRes); if (i < nbCars) { RmNextRace.prevHdle = prevHdle; RmNextRace.info = info; RmNextRace.start = start + nMaxLines; RmNextRace.title = pszTitle; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "NextPageArrow", (void*)&RmNextRace, rmChgQualifScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEDOWN, "Next Results", (void*)&RmNextRace, rmChgQualifScreen, NULL); } GfuiAddKey(rmScrHdle, GFUIK_ESCAPE, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_RETURN, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_F12, "Take a Screen Shot", NULL, GfuiScreenShot, NULL); GfuiAddKey(rmScrHdle, GFUIK_F1, "Help", rmScrHdle, GfuiHelpScreen, NULL); GfuiScreenActivate(rmScrHdle); }
// The event loop itself. void GfuiEventLoop::operator()() { SDL_Event event; // Event structure #if SDL_MAJOR_VERSION >= 2 static int unicode = 0; static SDL_Keymod modifier = KMOD_NONE; #endif // Check for events. while (!quitRequested()) { // Loop until there are no events left in the queue. while (!quitRequested() && SDL_PollEvent(&event)) { // Process events we care about, and ignore the others. switch(event.type) { case SDL_KEYDOWN: #if SDL_MAJOR_VERSION < 2 injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 0,event.key.keysym.unicode); #else if((event.key.keysym.sym & SDLK_SCANCODE_MASK) == SDLK_SCANCODE_MASK) { injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 0,0); } else if(false == isprint(event.key.keysym.sym)) { injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 0,0); } else if((event.key.keysym.mod != KMOD_NONE) &&(event.key.keysym.mod != KMOD_LSHIFT) &&(event.key.keysym.mod != KMOD_RSHIFT)) { injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 0,0); } #if 0 else { printf("SDL_KEYDOWN: %c\r\n",(char)event.key.keysym.sym); } #endif #endif break; #if SDL_MAJOR_VERSION >= 2 case SDL_TEXTINPUT: unicode = (int)(event.text.text[0]); modifier = SDL_GetModState(); injectKeyboardEvent(unicode,modifier, 0,0); //printf("SDL_TEXTINPUT: %c %X\r\n",(char)unicode,modifier); break; #endif case SDL_KEYUP: #if SDL_MAJOR_VERSION < 2 injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 1,event.key.keysym.unicode); #else if((event.key.keysym.sym & SDLK_SCANCODE_MASK) == SDLK_SCANCODE_MASK) { injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 1,0); } else if(false == isprint(event.key.keysym.sym)) { injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 1,0); } else if((event.key.keysym.mod != KMOD_NONE) &&(event.key.keysym.mod != KMOD_LSHIFT) &&(event.key.keysym.mod != KMOD_RSHIFT)) { injectKeyboardEvent(event.key.keysym.sym, event.key.keysym.mod, 1,0); } else { injectKeyboardEvent(unicode, event.key.keysym.mod, 1,0); //printf("SDL_KEYUP: %c unicode = %c\r\n",(char)event.key.keysym.sym,unicode); } #endif break; case SDL_MOUSEMOTION: injectMouseMotionEvent(event.motion.state, event.motion.x, event.motion.y); break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: injectMouseButtonEvent(event.button.button, event.button.state, event.button.x, event.button.y); break; case SDL_QUIT: postQuit(); break; #if SDL_MAJOR_VERSION >= 2 #if SDL_JOYSTICK case SDL_JOYAXISMOTION: injectJoystickAxisEvent(event.jaxis.which, event.jaxis.axis, (float) event.jaxis.value / 32768); break; case SDL_JOYBUTTONDOWN: injectJoystickButtonEvent(event.jbutton.which, event.jbutton.button, SDL_PRESSED); break; case SDL_JOYBUTTONUP: injectJoystickButtonEvent(event.jbutton.which, event.jbutton.button, 0); break; #endif case SDL_WINDOWEVENT_EXPOSED: #else case SDL_VIDEOEXPOSE: #endif forceRedisplay(); break; } } if (!quitRequested()) { // Recompute if anything to. recompute(); // Redisplay if anything to. redisplay(); } } GfLogTrace("Quitting GFUI event loop.\n"); }
static void rmPracticeResults(void *prevHdle, tRmInfo *info, int start) { // Used across rmPracticeResults calls when multiple pages. static int NLastLapDamages = 0; void *results = info->results; const char *race = info->_reRaceName; int i; int y; static char buf[256]; static char path[1024]; char *str; int damages; // Create screen, load menu XML descriptor and create static controls. rmScrHdle = GfuiScreenCreate(); GfLogTrace("Entering Practice Results menu\n"); void *hmenu = GfuiMenuLoad("practiceresultsmenu.xml"); GfuiMenuCreateStaticControls(rmScrHdle, hmenu); // Create variable title labels. snprintf(buf, sizeof(buf), "%s at %s", race, info->track->name); const int titleId = GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Title"); GfuiLabelSetText(rmScrHdle, titleId, buf); snprintf(path, sizeof(path), "%s/%s/%s", info->track->name, RE_SECT_RESULTS, race); snprintf(buf, sizeof(buf), "%s (%s)", GfParmGetStr(results, path, RM_ATTR_DRVNAME, NULL), GfParmGetStr(results, path, RM_ATTR_CAR, NULL)); const int subTitleId = GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "SubTitle"); GfuiLabelSetText(rmScrHdle, subTitleId, buf); // Get layout properties. const int nMaxLines = (int)GfuiMenuGetNumProperty(hmenu, "nMaxResultLines", 15); const int yTopLine = (int)GfuiMenuGetNumProperty(hmenu, "yTopLine", 400); const int yLineShift = (int)GfuiMenuGetNumProperty(hmenu, "yLineShift", 20); // Display the result table. y = yTopLine; snprintf(path, sizeof(path), "%s/%s/%s", info->track->name, RE_SECT_RESULTS, race); const int totLaps = (int)GfParmGetEltNb(results, path); // Reset last damage value if top of the table. if (start == 0) NLastLapDamages = 0; else { snprintf(path, sizeof(path), "%s/%s/%s/%d", info->track->name, RE_SECT_RESULTS, race, start - 1); NLastLapDamages = (int)(GfParmGetNum(results, path, RE_ATTR_DAMMAGES, NULL, 0)); } for (i = 0 + start; i < MIN(start + nMaxLines, totLaps); i++) { snprintf(path, sizeof(path), "%s/%s/%s/%d", info->track->name, RE_SECT_RESULTS, race, i + 1); /* Lap */ snprintf(buf, sizeof(buf), "%d", i+1); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "LapNumber", true, // From template. buf, GFUI_TPL_X, y); /* Time */ str = GfTime2Str(GfParmGetNum(results, path, RE_ATTR_TIME, NULL, 0), " ", false, 3); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "LapTime", true, // From template. str, GFUI_TPL_X, y); free(str); /* Best Lap Time */ str = GfTime2Str(GfParmGetNum(results, path, RE_ATTR_BEST_LAP_TIME, NULL, 0), " ", false, 3); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "BestTime", true, // From template. str, GFUI_TPL_X, y); free(str); /* Top Spd */ snprintf(buf, sizeof(buf), "%3.1f", (GfParmGetNum(results, path, RE_ATTR_TOP_SPEED, NULL, 0) * 3.6)); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "TopSpeed", true, // From template. buf, GFUI_TPL_X, y); /* Min Spd */ snprintf(buf, sizeof(buf), "%3.1f", (GfParmGetNum(results, path, RE_ATTR_BOT_SPEED, NULL, 0) * 3.6)); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "MinSpeed", true, // From template. buf, GFUI_TPL_X, y); /* Damages in current lap + (total so far) */ damages = (int)(GfParmGetNum(results, path, RE_ATTR_DAMMAGES, NULL, 0)); snprintf(buf, sizeof(buf), "%d (%d)", damages ? damages - NLastLapDamages : 0, damages); GfuiMenuCreateLabelControl(rmScrHdle, hmenu, "Damages", true, // From template. buf, GFUI_TPL_X, y); NLastLapDamages = damages; y -= yLineShift; } if (start > 0) { RmPrevRace.prevHdle = prevHdle; RmPrevRace.info = info; RmPrevRace.start = start - nMaxLines; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "PreviousPageArrow", (void*)&RmPrevRace, rmChgPracticeScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEUP, "Previous Results", (void*)&RmPrevRace, rmChgPracticeScreen, NULL); } // Add "Continue" button GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "ContinueButton", prevHdle, GfuiScreenReplace); //Create 'save' button in the bottom right //rmSaveButtonId = GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "SaveButton", info, rmSaveRes); if (i < totLaps) { RmNextRace.prevHdle = prevHdle; RmNextRace.info = info; RmNextRace.start = start + nMaxLines; GfuiMenuCreateButtonControl(rmScrHdle, hmenu, "NextPageArrow", (void*)&RmNextRace, rmChgPracticeScreen); GfuiAddKey(rmScrHdle, GFUIK_PAGEDOWN, "Next Results", (void*)&RmNextRace, rmChgPracticeScreen, NULL); } GfuiAddKey(rmScrHdle, GFUIK_ESCAPE, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_RETURN, "Continue", prevHdle, GfuiScreenReplace, NULL); GfuiAddKey(rmScrHdle, GFUIK_F12, "Take a Screen Shot", NULL, GfuiScreenShot, NULL); GfuiAddKey(rmScrHdle, GFUIK_F1, "Help", rmScrHdle, GfuiHelpScreen, NULL); GfuiScreenActivate(rmScrHdle); }
/* * Function * GfModInitialize * * Description * Initialize 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 * gfid (in) id of the gaming framework that the module MUST implement to be initialized * (Not taken into account if == GfIdAny) * mod (in) address of module entry to allocate and initialize * (0 if any error occured or modules not retained for bad GFId) * * Return * 0 if initialization succeeded (even if the module was rejected for bad GFId) * -1 if any error occured * * Remarks * */ int GfModInitialize(tSOHandle soHandle, const char *soPath, unsigned int gfid, tModList **mod) { tfModInfoWelcome fModInfoWelcome; /* function to exchange information with the module at welcome time */ tfModInfoInitialize fModInfoInit = 0; /* init function of the module */ int initSts = 0; /* returned status */ int retained = 1; char soName[256]; char soDir[1024]; char* lastSlash; /* Allocate module entry in list */ if (!(*mod = (tModList*)calloc(1, sizeof(tModList)))) { GfLogError("GfModInitialize: Failed to allocate tModList for module %s\n", soPath); return -1; } /* Determine the shared library / DLL name and load dir */ strcpy(soDir, soPath); lastSlash = strrchr(soDir, '/'); if (lastSlash) { strcpy(soName, lastSlash+1); *lastSlash = 0; } else { strcpy(soName, soPath); *soDir = 0; } soName[strlen(soName) - SOFileExtLen] = 0; /* cut so file extension */ /* Welcome the module : exchange informations with it : 1) Call the dedicated module function if present */ if ((fModInfoWelcome = (tfModInfoWelcome)dlsym(SOHandle(soHandle), GfModInfoWelcomeFuncName)) != 0) { /* Prepare information to give to the module */ tModWelcomeIn welcomeIn; welcomeIn.itfVerMajor = 1; welcomeIn.itfVerMinor = 0; welcomeIn.name = soName; /* Prepare a place for the module-given information */ tModWelcomeOut welcomeOut; /* Call the welcome function */ if ((initSts = fModInfoWelcome(&welcomeIn, &welcomeOut)) != 0) { GfLogError("GfModInitialize: Module welcome function failed %s\n", soPath); } else { /* Save information given by the module */ (*mod)->modInfoSize = welcomeOut.maxNbItf; } } /* 2) If not present, default number of interfaces (backward compatibility) */ else { (*mod)->modInfoSize = GfModInfoDefaultMaxItf; } /* Get module initialization function if welcome succeeded : 1) Try the new sheme (fixed name) */ if (initSts == 0) { fModInfoInit = (tfModInfoInitialize)dlsym(SOHandle(soHandle), GfModInfoInitializeFuncName); //GfLogDebug("GfModInitialize: fModInfoInit(%s) @ %p\n", // GfModInfoInitializeFuncName, fModInfoInit); } /* 2) Backward compatibility (dll name) */ if (initSts == 0 && !fModInfoInit) { fModInfoInit = (tfModInfoInitialize)dlsym(SOHandle(soHandle), soName); //GfLogDebug("GfModInitialize: fModInfoInit(%s) @ %p\n", soName, fModInfoInit); } /* Call module initialization function if welcome succeeded and init function found */ if (initSts == 0 && fModInfoInit) { /* Allocate module interfaces info array according to the size we got */ tModInfo* constModInfo; if ((constModInfo = GfModInfoAllocate((*mod)->modInfoSize)) != 0) { /* Library loaded, init function exists, call it... */ if ((initSts = fModInfoInit(constModInfo)) == 0) { /* Duplicate strings in each interface, in case the module gave us static data ! */ if (((*mod)->modInfo = GfModInfoDuplicate(constModInfo, (*mod)->modInfoSize)) != 0) { /* Reject module if not of requested gaming framework Id */ if (gfid != GfIdAny && (*mod)->modInfo[0].gfId != gfid) { GfLogTrace("GfModInitialize: Module not retained %s\n", soPath); GfModInfoFreeNC((*mod)->modInfo, (*mod)->modInfoSize); retained = 0; } /* Free the module info data returned by the module (we have a copy) */ GfModInfoFree(constModInfo); } else { initSts = -1; } } else { GfLogError("GfModInitialize: Module init function failed %s\n", soPath); } } else { initSts = -1; } } /* If init function not found, we have a problem ... */ else { GfLogError("GfModInitialize: Module init function %s not found ... %s\n", soPath, dlerror()); initSts = -1; } /* Store other module information */ if (initSts == 0 && retained) { GfOut("Initialized module %s (maxItf=%d)\n", soPath, (*mod)->modInfoSize); (*mod)->handle = (tSOHandle)soHandle; (*mod)->sopath = strdup(soPath); } else { free(*mod); *mod = 0; } return initSts; }
// Initialize track weather info from race settings void reTrackInitWeather(void) { static const char* CloudsValues[] = RM_VALS_CLOUDS; static const int NCloudsValues = sizeof(CloudsValues) / sizeof(const char*); static const char *RainValues[] = RM_VALS_RAIN; static const int NRainValues = sizeof(RainValues) / sizeof(const char*); tTrackLocalInfo *trackLocal = &ReInfo->track->local; // Load cloud cover settings for the session // (defaults to "All sesions" one, or else "none"). int clouds = TR_CLOUDS_NONE; const char* pszClouds = GfParmGetStr(ReInfo->params, ReInfo->_reRaceName, RM_ATTR_CLOUDS, 0); if (!pszClouds) pszClouds = GfParmGetStr(ReInfo->params, RM_VAL_ANYRACE, RM_ATTR_CLOUDS, RM_VAL_CLOUDS_NONE); for (int i = 0; i < NCloudsValues; i++) if (!strcmp(pszClouds, CloudsValues[i])) { clouds = i; break; } // Load rain fall (and track dry/wet conditions) settings for the session // if feature supported (defaults to "All sesions" one, or else "none"). int rain = TR_RAIN_NONE; if (ReInfo->s->_features & RM_FEATURE_WETTRACK) { const char* pszRain = GfParmGetStr(ReInfo->params, ReInfo->_reRaceName, RM_ATTR_RAIN, 0); if (!pszRain) pszRain = GfParmGetStr(ReInfo->params, RM_VAL_ANYRACE, RM_ATTR_RAIN, RM_VAL_RAIN_NONE); for (int i = 0; i < NRainValues; i++) if (!strcmp(pszRain, RainValues[i])) { rain = i; break; } } // Take care of the random case for rain falls and ground water. const bool bRandomRain = (rain == TR_RAIN_RANDOM); if (bRandomRain) { // Force random clouds, in case there is no rain at the end. clouds = TR_CLOUDS_RANDOM; // Random rain (if random[0,1] < trackLocal->anyrainlkhood, then it rains). const tdble randDraw = (tdble)(rand()/(double)RAND_MAX); GfLogTrace("Rain likelyhoods : overall=%.2f, little=%.2f, medium=%.2f\n", trackLocal->anyrainlkhood, trackLocal->littlerainlkhood, trackLocal->mediumrainlkhood); GfLogDebug("Overall rain random draw = %.2f,\n", randDraw); if (randDraw < trackLocal->anyrainlkhood) { // Now, let's determine how much it rains : // if random[0,1] < little rain likelyhood => rain = little rain const tdble randDraw2 = (tdble)(rand()/(double)RAND_MAX); GfLogDebug("Specific rain random draw = %.2f,\n", randDraw2); if (randDraw2 < trackLocal->littlerainlkhood) rain = TR_RAIN_LITTLE; // else if random[0,1] < medium + little rain likelyhood => rain = medium rain else if (randDraw2 < trackLocal->littlerainlkhood + trackLocal->mediumrainlkhood) rain = TR_RAIN_MEDIUM; // otherwise, random[0,1] >= medium + little rain likelyhood => rain = Heavy rain else rain = TR_RAIN_HEAVY; } else { // No Rain. rain = TR_RAIN_NONE; } } // Take care of the random case for clouds cover. const bool bRandomClouds = (clouds == TR_CLOUDS_RANDOM); if (bRandomClouds) { if (rain != TR_RAIN_NONE) { // If any rain level, heavy clouds. clouds = TR_CLOUDS_FULL; } else { // Really random clouds. clouds = rand() % (TR_CLOUDS_FULL + 1); } } // Ground water = rain for the moment (might change in the future). const int water = rain; GfLogInfo("Weather : Using %s rain (%d) and ground water (%d) + %s clouds (%d) settings\n", bRandomRain ? "random" : "user defined", rain, water, bRandomClouds ? "random" : "user defined", clouds); // Update track local info. trackLocal->rain = rain; trackLocal->clouds = clouds; trackLocal->water = water; // Update track physics from computed local info. reTrackUpdatePhysics(); }
OpenalSound::OpenalSound(const char* filename, OpenalSoundInterface* sitf, int flags, bool loop, bool static_pool) : Sound(flags, loop) { this->static_pool = static_pool; poolindex = -1; itf = sitf; MAX_DISTANCE = 10000.0f; MAX_DISTANCE_LOW = 5.0f; REFERENCE_DISTANCE = 5.0f; ROLLOFF_FACTOR = 0.5f; int i; for (i = 0; i<3; i++) { source_position[i] = 0.0f; source_velocity[i] = 0.0f; zeroes[i] = 0.0f; } GfLogTrace("OpenAL : Creating %s source from %s\n", static_pool ? "static" : "dynamic", filename); int error = alGetError(); if (error != AL_NO_ERROR) { printf("Uncatched OpenAL Error on entry: %d with file %s\n", error, filename); } alGenBuffers (1, &buffer); error = alGetError(); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alGenBuffers failed %s\n", error, filename); is_enabled = false; return; } SDL_AudioSpec wavspec; Uint32 wavlen; Uint8 *wavbuf; if (!SDL_LoadWAV(filename, &wavspec, &wavbuf, &wavlen)) { if (alIsBuffer(buffer)) alDeleteBuffers(1, &buffer); GfError("OpenAL Error: Could not load %s (%s)\n", filename, SDL_GetError()); is_enabled = false; return; } if (wavspec.channels > 1) { if (alIsBuffer(buffer)) alDeleteBuffers(1, &buffer); GfError("OpenAL Error: Unsupported stereo sample %s\n", filename); is_enabled = false; return; } // Map WAV header to OpenAL format ALenum format; switch(wavspec.format) { case AUDIO_U8: case AUDIO_S8: format = AL_FORMAT_MONO8; break; case AUDIO_U16: case AUDIO_S16: format = AL_FORMAT_MONO16; break; default: SDL_FreeWAV(wavbuf); if (alIsBuffer(buffer)) alDeleteBuffers(1, &buffer); GfError("OpenAL Error: Unsupported WAV format %d for %s (not among U8, S8, U16, S16)\n", wavspec.format, filename); is_enabled = false; return; } alBufferData(buffer, format, wavbuf, wavlen, wavspec.freq); error = alGetError(); if (error != AL_NO_ERROR) { GfError("OpenAL Error: %d, alBufferData %s\n", error, filename); SDL_FreeWAV(wavbuf); if (alIsBuffer(buffer)) { alDeleteBuffers(1, &buffer); alGetError(); } is_enabled = false; return; } SDL_FreeWAV(wavbuf); if (!static_pool) { is_enabled = true; return; } if (!sitf->getStaticSource(&source)) { is_enabled = false; printf(" No static sources left: %s\n", filename); if (alIsBuffer(buffer)) { alDeleteBuffers(1, &buffer); alGetError(); } return; } else { is_enabled = true; } alSourcefv (source, AL_POSITION, source_position); error = alGetError(); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcefv AL_POSITION %s\n", error, filename); } alSourcefv (source, AL_VELOCITY, source_velocity); error = alGetError(); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcefv AL_VELOCITY %s\n", error, filename); } alSourcei (source, AL_BUFFER, buffer); error = alGetError(); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcei AL_BUFFER %s\n", error, filename); } alSourcei (source, AL_LOOPING, loop); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcei AL_LOOPING %s\n", error, filename); } alSourcef (source, AL_MAX_DISTANCE, MAX_DISTANCE); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcef AL_MAX_DISTANCE %s\n", error, filename); } alSourcef (source, AL_REFERENCE_DISTANCE, REFERENCE_DISTANCE); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcef AL_REFERENCE_DISTANCE %s\n", error, filename); } alSourcef (source, AL_ROLLOFF_FACTOR, ROLLOFF_FACTOR); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcef AL_ROLLOFF_FACTOR %s\n", error, filename); } alSourcef (source, AL_GAIN, 0.0f); if (error != AL_NO_ERROR) { printf("OpenAL Error: %d, alSourcef AL_GAIN %s\n", error, filename); } }
bool NetClient::SendDriverInfoPacket(NetDriver *pDriver) { SetDriverName(pDriver->name); pDriver->address.port = m_pHost->address.port; GfLogTrace("SendDriverInfoPacket: pDriver\n"); GfLogTrace("->host=%d\n", pDriver->address.host); GfLogTrace("->port=%d\n", pDriver->address.port); GfLogTrace("->idx=%d\n", pDriver->idx); GfLogTrace("->name=%s\n", pDriver->name); GfLogTrace("->sname=%s\n", pDriver->sname); GfLogTrace("->cname=%s\n", pDriver->cname); GfLogTrace("->car=%s\n", pDriver->car); GfLogTrace("->team=%s\n", pDriver->team); GfLogTrace("->author=%s\n", pDriver->author); GfLogTrace("->racenumber=%d\n", pDriver->racenumber); GfLogTrace("->skilllevel=%s\n", pDriver->skilllevel); GfLogTrace("->red=%.1f\n", pDriver->red); GfLogTrace("->green=%.1f\n", pDriver->green); GfLogTrace("->blue=%.1f\n", pDriver->blue); GfLogTrace("->module=%s\n", pDriver->module); GfLogTrace("->type=%s\n", pDriver->type); GfLogTrace("->client=%d\n", pDriver->client); PackedBuffer msg; try { msg.pack_ubyte(PLAYERINFO_PACKET); msg.pack_int(pDriver->idx); msg.pack_string(pDriver->name, sizeof pDriver->name); msg.pack_string(pDriver->sname, sizeof pDriver->sname); msg.pack_string(pDriver->cname, sizeof pDriver->cname); msg.pack_string(pDriver->car, sizeof pDriver->car); msg.pack_string(pDriver->team, sizeof pDriver->team); msg.pack_string(pDriver->author, sizeof pDriver->author); msg.pack_int(pDriver->racenumber); msg.pack_string(pDriver->skilllevel, sizeof pDriver->skilllevel); msg.pack_float(pDriver->red); msg.pack_float(pDriver->green); msg.pack_float(pDriver->blue); msg.pack_string(pDriver->module, sizeof pDriver->module); msg.pack_string(pDriver->type, sizeof pDriver->type); msg.pack_int(pDriver->client); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SendDriverInfoPacket: packed buffer error\n"); } GfLogTrace("SendDriverInfoPacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)==0) return true; return false; }
void SDScreens::InitCars(tSituation *s) { //char buf[256]; //char idx[16]; //int index; int i; tCarElt *elt; //void *hdle; const char *pszSpanSplit; int grNbSuggestedScreens = 0; for (i = 0; i < s->_ncars; i++) { elt = s->cars[i]; //index = elt->index; //hdle = elt->_paramsHandle; // WARNING: This index hack on the human robot for the Career mode // does no more work with the new "welcome" module system // (the "normal" index has no more the 10 limit) ... TO BE FIXED !!!!!!! /*if (elt->_driverType == RM_DRV_HUMAN && elt->_driverIndex > 10) sprintf(idx, "Robots/index/%d", elt->_driverIndex - 11); else sprintf(idx, "Robots/index/%d", elt->_driverIndex); grCarInfo[index].iconColor[0] = GfParmGetNum(hdle, idx, "red", (char*)NULL, GfParmGetNum(hdle, ROB_SECT_ARBITRARY, "red", NULL, 0)); grCarInfo[index].iconColor[1] = GfParmGetNum(hdle, idx, "green", (char*)NULL, GfParmGetNum(hdle, ROB_SECT_ARBITRARY, "green", NULL, 0)); grCarInfo[index].iconColor[2] = GfParmGetNum(hdle, idx, "blue", (char*)NULL, GfParmGetNum(hdle, ROB_SECT_ARBITRARY, "blue", NULL, 0)); grCarInfo[index].iconColor[3] = 1.0; grInitCar(elt);*/ // Pre-assign each human driver (if any) to a different screen // (set him as the "current driver" for this screen). if (grNbSuggestedScreens < SD_NB_MAX_SCREEN && elt->_driverType == RM_DRV_HUMAN && !elt->_networkPlayer) { Screens[grNbSuggestedScreens]->setCurrentCar(elt); GfLogTrace("Screen #%d : Assigned to %s\n", grNbSuggestedScreens, elt->_name); grNbSuggestedScreens++; } } /* Check whether view should be spanned across vertical splits */ pszSpanSplit = GfParmGetStr(grHandle, GR_SCT_GRAPHIC, GR_ATT_SPANSPLIT, GR_VAL_NO); m_SpanSplit = strcmp(pszSpanSplit, GR_VAL_YES) ? 0 : 1; if (m_SpanSplit == 0 && grNbSuggestedScreens > 1) { // Mulitplayer, so ignore the stored number of screens m_NbActiveScreens = grNbSuggestedScreens; m_NbArrangeScreens = 0; } else { // Load the real number of active screens and the arrangment. m_NbActiveScreens = (int)GfParmGetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_NB_SCREENS, NULL, 1.0); m_NbArrangeScreens = (int)GfParmGetNum(grHandle, GR_SCT_DISPMODE, GR_ATT_ARR_SCREENS, NULL, 0.0); } // Initialize the cameras for all the screens. for (unsigned i=0; i<Screens.size();i++) { Screens[i]->Init(s); } // Setup the screens (= OpenGL viewports) inside the physical game window. this->AdaptScreenSize(); }
void NetClient::ResetNetwork() { if (m_pClient == NULL) return; if (m_pServer == NULL) return; ENetEvent event; enet_peer_disconnect (m_pServer, 0); bool bDisconnect = false; /* Allow up to 3 seconds for the disconnect to succeed and drop any packets received packets. */ while (enet_host_service (m_pClient, & event, 3000) > 0) { switch (event.type) { case ENET_EVENT_TYPE_RECEIVE: enet_packet_destroy (event.packet); break; case ENET_EVENT_TYPE_DISCONNECT: GfLogTrace ("Network disconnection succeeded."); bDisconnect=true; break; case ENET_EVENT_TYPE_NONE: case ENET_EVENT_TYPE_CONNECT: // Do nothing. break; } } /* We've arrived here, so the disconnect attempt didn't */ /* succeed yet. Force the connection down. */ if (!bDisconnect) enet_peer_reset (m_pServer); NetSetClient(false); ENetPeer * pCurrentPeer1; if (m_pHost ==NULL) return; for (pCurrentPeer1 = m_pHost-> peers; pCurrentPeer1 < & m_pHost->peers [m_pHost->peerCount]; ++ pCurrentPeer1) { if (pCurrentPeer1->state != ENET_PEER_STATE_CONNECTED) continue; enet_peer_reset (pCurrentPeer1); } enet_host_destroy(m_pHost); m_pHost = NULL; }
void RmNextEventMenu(void) { char buf[128]; tRmInfo* reInfo = LmRaceEngine().inData(); void *params = reInfo->params; void *results = reInfo->results; int raceNumber; int xx; if (rmScrHandle) { GfuiScreenRelease(rmScrHandle); } GfLogTrace("Entering Next Event menu\n"); // Create screen, load menu XML descriptor and create static controls. rmScrHandle = GfuiScreenCreate(NULL, NULL, (tfuiCallback)NULL, NULL, (tfuiCallback)NULL, 1); void *menuXMLDescHdle = GfuiMenuLoad("racenexteventmenu.xml"); GfuiMenuCreateStaticControls(rmScrHandle, menuXMLDescHdle); // Create background image from race params. const char* pszBGImg = GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_BGIMG, 0); if (pszBGImg) { GfuiScreenAddBgImg(rmScrHandle, pszBGImg); } // Create variable title label from race params. int titleId = GfuiMenuCreateLabelControl(rmScrHandle, menuXMLDescHdle, "TitleLabel"); char pszTitle[128]; if (LmRaceEngine().race()->getManager()->hasSubFiles()) { const char* pszGroup = GfParmGetStr(reInfo->params, RM_SECT_HEADER, RM_ATTR_NAME, "<no group>"); snprintf(pszTitle, sizeof(pszTitle), "%s - %s", reInfo->_reName, pszGroup); } else snprintf(pszTitle, sizeof(pszTitle), "%s", reInfo->_reName); GfuiLabelSetText(rmScrHandle, titleId, pszTitle); // Calculate which race of the series this is raceNumber = 1; for (xx = 1; xx < (int)GfParmGetNum(results, RE_SECT_CURRENT, RE_ATTR_CUR_TRACK, NULL, 1); ++xx) { snprintf(buf, sizeof(buf), "%s/%d", RM_SECT_TRACKS, xx); if (!strcmp( GfParmGetStr(reInfo->params, buf, RM_ATTR_NAME, "free"), "free") == 0) ++raceNumber; } // Create variable subtitle label from race params. snprintf(buf, sizeof(buf), "Race Day #%d/%d at %s", raceNumber, (int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) >= 0 ? (int)GfParmGetNum(params, RM_SECT_TRACKS, RM_ATTR_NUMBER, NULL, -1 ) : GfParmGetEltNb(params, RM_SECT_TRACKS), reInfo->track->name); int subTitleId = GfuiMenuCreateLabelControl(rmScrHandle, menuXMLDescHdle, "SubTitleLabel"); GfuiLabelSetText(rmScrHandle, subTitleId, buf); // Create Start and Abandon buttons. GfuiMenuCreateButtonControl(rmScrHandle, menuXMLDescHdle, "StartButton", NULL, rmStateManage); GfuiMenuCreateButtonControl(rmScrHandle, menuXMLDescHdle, "AbandonButton", RmRaceSelectMenuHandle, GfuiScreenActivate); // Close menu XML descriptor. GfParmReleaseHandle(menuXMLDescHdle); // Register keyboard shortcuts. GfuiMenuDefaultKeysAdd(rmScrHandle); GfuiAddKey(rmScrHandle, GFUIK_RETURN, "Start Event", NULL, rmStateManage, NULL); GfuiAddKey(rmScrHandle, GFUIK_ESCAPE, "Abandon", RmRaceSelectMenuHandle, GfuiScreenActivate, NULL); // Activate screen. GfuiScreenActivate(rmScrHandle); }
int RmGetFeaturesList( void* param ) { int nCars; char const *cardllname; int caridx; char const *features; int driverFeatureMask; int raceFeatureMask = -1; // All bits set to 1. void *robhdle; char path[ 256 ]; char buf[ 1024 ]; int xx, yy; int features_index; int buf_index; nCars = GfParmGetEltNb( param, RM_SECT_DRIVERS ); for( xx = 1; xx < nCars + 1; ++xx ) { /* Open robot */ sprintf( path, "%s/%d", RM_SECT_DRIVERS, xx ); cardllname = GfParmGetStr( param, path, RM_ATTR_MODULE, "" ); caridx = (int)GfParmGetNum( param, path, RM_ATTR_IDX, NULL, 0 ); sprintf( buf, "%s/drivers/%s/%s.xml", GfLocalDir(), cardllname, cardllname ); robhdle = GfParmReadFile( buf, GFPARM_RMODE_STD ); if( !robhdle ) { sprintf( buf, "drivers/%s/%s.xml", cardllname, cardllname ); robhdle = GfParmReadFile( buf, GFPARM_RMODE_STD ); } if( !robhdle ) continue; driverFeatureMask = 0; sprintf( buf, "%s/%s/%d", ROB_SECT_ROBOTS, ROB_LIST_INDEX, caridx ); if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_TYPE, ROB_VAL_ROBOT ), ROB_VAL_HUMAN ) == 0 ) { if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_LEVEL, ROB_VAL_ARCADE ), ROB_VAL_ARCADE ) == 0 ) driverFeatureMask |= RM_FEATURE_TIMEDSESSION; else if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_LEVEL, ROB_VAL_ARCADE ), ROB_VAL_SEMI_ROOKIE ) == 0 ) driverFeatureMask |= RM_FEATURE_TIMEDSESSION; else if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_LEVEL, ROB_VAL_ARCADE ), ROB_VAL_ROOKIE ) == 0 ) driverFeatureMask |= RM_FEATURE_TIMEDSESSION; else if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_LEVEL, ROB_VAL_ARCADE ), ROB_VAL_AMATEUR ) == 0 ) driverFeatureMask |= RM_FEATURE_TIMEDSESSION | RM_FEATURE_WETTRACK; /* | RM_FEATURE_BLUE */ else if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_LEVEL, ROB_VAL_ARCADE ), ROB_VAL_SEMI_PRO ) == 0 ) driverFeatureMask |= RM_FEATURE_TIMEDSESSION | RM_FEATURE_WETTRACK; /* | RM_FEATURE_PENALTIES | RM_FEATURE_SC | RM_FEATURE_YELLOW | RM_FEATURE_RED | */ else if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_LEVEL, ROB_VAL_ARCADE ), ROB_VAL_PRO ) == 0 ) driverFeatureMask |= RM_FEATURE_TIMEDSESSION | RM_FEATURE_PENALTIES | RM_FEATURE_WETTRACK; /*RM_FEATURE_SC | RM_FEATURE_YELLOW | RM_FEATURE_BLUE | RM_FEATURE_RED | RM_FEATURE_PITEXIT |*/ } else if( strcmp( GfParmGetStr( robhdle, buf, ROB_ATTR_TYPE, ROB_VAL_ROBOT ), ROB_VAL_ROBOT ) == 0 ) { sprintf( buf, "%s/%s/%d", ROB_SECT_ROBOTS, ROB_LIST_INDEX, caridx ); features = GfParmGetStr( robhdle, buf, ROB_ATTR_FEATURES, "" ); features_index = 0; buf_index = 0; while( true ) { if( features[ features_index ] != '\0' && features[ features_index ] != ';' && buf_index < nMaxFeatureNameLength ) { /* Feature name not yet ended */ buf[ buf_index ] = features[ features_index ]; ++buf_index; ++features_index; } else if( features[ features_index ] == '\0' || features[ features_index ] == ';' ) { /* Feature name ended, check for matched */ buf[ buf_index ] = '\0'; for( yy = 0; yy < nFeatures; ++yy ) { if( strcmp( features_list[ yy ].name, buf ) == 0 ) { driverFeatureMask |= features_list[ yy ].value; } } if( features[ features_index ] == '\0' ) break; /* Leave */ ++features_index; buf_index = 0; } } } GfLogDebug("Driver %s#%d supported-feature mask : 0x%02X\n", cardllname, caridx, driverFeatureMask); /* Binary and: the raceFeatureMask is only the features all cars have */ raceFeatureMask &= driverFeatureMask; GfParmReleaseHandle( robhdle ); } GfLogTrace("Race supported-feature mask : 0x%02X\n", raceFeatureMask); return raceFeatureMask; }
// Host on-line race menu. void RmNetworkHostMenu(void * /* dummy */) { GfLogTrace("Entering Network Host menu.\n"); if (!NetGetNetwork()) { NetSetServer(true); NetSetClient(false); if (!NetGetServer()->Start(SPEEDDREAMSPORT)) { NetSetServer(false); return; } } if (racemanMenuHdle) GfuiScreenRelease(racemanMenuHdle); racemanMenuHdle = GfuiScreenCreate(NULL, NULL, (tfuiCallback)OnActivateNetworkHost, NULL, (tfuiCallback)NULL, 1); void *mparam = GfuiMenuLoad("networkhostmenu.xml"); GfuiMenuCreateStaticControls(racemanMenuHdle, mparam); RmSetRacemanMenuHandle(racemanMenuHdle); NetworkRaceInfo(); g_trackHd = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,"trackname"); g_lapsHd = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,"lapcountname"); g_catHd = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,"carcatname"); g_OutlineId = GfuiMenuCreateStaticImageControl(racemanMenuHdle,mparam,"outlineimage"); //Show players for (int i = 0; i < MAXNETWORKPLAYERS; i++) { char buf[1024]; sprintf(buf,"ready%i",i); g_readystatus[i] = GfuiMenuCreateStaticImageControl(racemanMenuHdle,mparam,buf); GfuiVisibilitySet(racemanMenuHdle,g_readystatus[i],false); sprintf(buf,"driver%i",i); g_playerNames[i] = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,buf); GfuiLabelSetText(racemanMenuHdle,g_playerNames[i],""); sprintf(buf,"car%i",i); g_carNames[i] = GfuiMenuCreateLabelControl(racemanMenuHdle,mparam,buf); GfuiLabelSetText(racemanMenuHdle,g_carNames[i],""); } g_ReadyCheckboxId = GfuiMenuCreateCheckboxControl(racemanMenuHdle, mparam, "playerreadycheckbox", NULL, onHostPlayerReady); g_HostSettingsButtonId = GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "networkhostsettings", racemanMenuHdle, rmNetworkHostSettingsMenu); GfuiEnable(racemanMenuHdle, g_HostSettingsButtonId, GFUI_DISABLE); g_RaceSetupId = GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "racesetup", racemanMenuHdle, RmConfigureRace); GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "start race", NULL, ServerPrepareStartNetworkRace); g_CancelButtonId = GfuiMenuCreateButtonControl(racemanMenuHdle, mparam, "cancel", NULL, rmNetworkServerDisconnect); GfParmReleaseHandle(mparam); GfuiMenuDefaultKeysAdd(racemanMenuHdle); GfuiAddKey(racemanMenuHdle, GFUIK_ESCAPE, "Back to previous menu", 0, 0, rmNetworkServerDisconnect); UpdateNetworkPlayers(); GfuiScreenActivate(racemanMenuHdle); }