void NetClient::SendReadyToStartPacket() { std::string strDName = GetDriverName(); GfLogTrace("Sending ready to start packet\n"); PackedBuffer msg; try { msg.pack_ubyte(CLIENTREADYTOSTART_PACKET); msg.pack_stdstring(strDName); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SendReadyToStartPacket: packed buffer error\n"); } GfLogTrace("SendReadyToStartPacket: 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)) GfLogError("SendReadyToStartPacket : enet_peer_send failed\n"); }
void NetClient::SendServerTimeRequest() { m_packetsendtime = GfTimeClock(); PackedBuffer msg; try { msg.pack_ubyte(SERVER_TIME_REQUEST_PACKET); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SendServerTimeRequest: packed buffer error\n"); } GfLogTrace("SendServerTimeRequest: packed data length=%d\n", msg.length()); ENetPacket *pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_UNSEQUENCED); if (enet_peer_send (m_pServer, UNRELIABLECHANNEL, pPacket)) GfLogError("SendServerTimeRequest : enet_peer_send failed\n"); }
void NetServer::SendTimePacket(ENetPacket *pPacketRec, ENetPeer * pPeer) { GfLogTrace("Sending Time Packet\n"); double time = GfTimeClock(); GfLogTrace("\nServer time is %lf",time); PackedBuffer msg; try { msg.pack_ubyte(SERVER_TIME_SYNC_PACKET); msg.pack_double(time); } catch (PackedBufferException &e) { GfLogFatal("SendTimePacket: packed buffer error\n"); } GfLogTrace("SendTimePacket: packed data length=%d\n", msg.length()); //TODO change to peer send ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_UNSEQUENCED); enet_peer_send (pPeer, UNRELIABLECHANNEL, pPacket); }
void NetClient::ReadStartTimePacket(ENetPacket *pPacket) { GfLogTrace("Received the start race Packet\n"); //double time = GfTimeClock(); PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadStartTimePacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); m_racestarttime = msg.unpack_double(); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("ReadStartTimePacket: packed buffer error\n"); } //Adjust start time based on client clock m_racestarttime= m_racestarttime+m_servertimedifference; m_bBeginRace = true; }
void NetClient::ReadAllDriverReadyPacket(ENetPacket *pPacket) { int rsize; PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadAllDriverReadyPacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); rsize = msg.unpack_int(); NetMutexData *pNData = LockNetworkData(); pNData->m_vecReadyStatus.clear(); pNData->m_vecReadyStatus.resize(rsize); for (int i=0;i<rsize;i++) pNData->m_vecReadyStatus[i] = msg.unpack_int() ? true : false; UnlockNetworkData(); SetRaceInfoChanged(true); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("ReadAllDriverReadyPacket: packed buffer error\n"); } GfLogTrace("Received All Driver Ready Packet\n"); }
//Here you are Xavier a dynamic weather packet void NetServer::SendWeatherPacket() { GfLogTrace("Sending Weather Packet\n"); PackedBuffer msg; try { msg.pack_ubyte(WEATHERCHANGE_PACKET); //TODO add weather data here } catch (PackedBufferException &e) { GfLogFatal("SendWeatherPacket: packed buffer error\n"); } GfLogTrace("SendWeatherPacket: packed data length=%d\n", msg.length()); ENetPacket *pWeatherPacket = enet_packet_create(msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pWeatherPacket,RELIABLECHANNEL); }
void NetClient::ReadTimePacket(ENetPacket *pPacket) { double curTime = GfTimeClock(); m_lag = (curTime-m_packetsendtime)/2.0; GfLogTrace ("Connection lag is %lf seconds\n",m_lag); double time = 0; PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadTimePacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); time = msg.unpack_double(); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("ReadTimePacket: packed buffer error\n"); } m_servertimedifference = curTime-time; m_bTimeSynced = true; }
void NetServer::ReadDriverReadyPacket(ENetPacket *pPacket) { GfLogTrace ("Read Driver Ready Packet\n"); int idx = 0; bool bReady; PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadDriverReadyPacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); idx = msg.unpack_int(); bReady = msg.unpack_int(); } catch (PackedBufferException &e) { GfLogFatal("SendRaceSetupPacket: packed buffer error\n"); } NetMutexData *pNData = LockNetworkData(); if (idx > 0) pNData->m_vecReadyStatus[idx-1] = bReady; UnlockNetworkData(); SendDriversReadyPacket(); }
void NetServer::SendDriversReadyPacket() { NetMutexData *pNData = LockNetworkData(); int rsize = pNData->m_vecReadyStatus.size(); PackedBuffer msg; try { msg.pack_ubyte(ALLDRIVERREADY_PACKET); msg.pack_int(rsize); for (int i = 0; i < rsize; i++) { msg.pack_int(pNData->m_vecReadyStatus[i]); } } catch (PackedBufferException &e) { GfLogFatal("SendDriversReadyPacket: packed buffer error\n"); } GfLogTrace("SendDriversReadyPacket: packed data length=%d\n", msg.length()); UnlockNetworkData(); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); m_bRefreshDisplay = true; }
bool NetServer::SendPlayerRejectedPacket(ENetPeer * pPeer,std::string strReason) { //Send to client requesting connection PackedBuffer msg; try { msg.pack_ubyte(PLAYERREJECTED_PACKET); msg.pack_stdstring(strReason); } catch (PackedBufferException &e) { GfLogFatal("SendPlayerRejectedPacket: packed buffer error\n"); } GfLogTrace("SendPlayerRejectedPacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); if (enet_peer_send (pPeer, RELIABLECHANNEL, pPacket)==0) return true; return false; }
void NetServer::SendStartTimePacket(int &startTime) { //Wait RACESTARTDELEAY seconds to start race m_racestarttime = GfTimeClock()+RACESTARTDELEAY; PackedBuffer msg; try { msg.pack_ubyte(RACESTARTTIME_PACKET); msg.pack_double(m_racestarttime); } catch (PackedBufferException &e) { GfLogFatal("SendStartTimePacket: packed buffer error\n"); } GfLogTrace("SendStartTimePacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); GfLogInfo("Server Start time is %lf\n",m_racestarttime); }
void NetClient::SetDriverReady(bool bReady) { // Get local driver index in the race driver list int idx = GetDriverIdx(); NetMutexData *pNData = LockNetworkData(); pNData->m_vecReadyStatus[idx-1] = bReady; UnlockNetworkData(); PackedBuffer msg; try { msg.pack_ubyte(DRIVERREADY_PACKET); msg.pack_int(idx); msg.pack_int(bReady); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("SetDriverReady: packed buffer error\n"); } GfLogTrace("SetDriverReady: 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; }
void NetServer::SendFinishTimePacket() { GfLogTrace("Sending finish Time Packet\n"); NetMutexData *pNData = LockNetworkData(); double time = pNData->m_finishTime; UnlockNetworkData(); GfLogInfo("Server finish time is %lf\n",time); PackedBuffer msg; try { msg.pack_ubyte(FINISHTIME_PACKET); msg.pack_double(time); } catch (PackedBufferException &e) { GfLogFatal("SendFinishTimePacket: packed buffer error\n"); } GfLogTrace("SendFinishTimePacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); }
//Send a file to clients //Do not use this to send large files //In future maybe change to TCP based //64k file size limit void NetServer::SendFilePacket(const char *pszFile) { char filepath[255]; sprintf(filepath, "%s%s", GfLocalDir(), pszFile); GfLogTrace("Sending file packet: File- %s\n",filepath); FILE *pFile = fopen(filepath,"rb"); if (!pFile) return; char buf[0xffff]; size_t size; size = fread( buf, 1, 0xffff, pFile ); //File is to big if (!feof(pFile)) { fclose(pFile); assert(false); return; } fclose(pFile); unsigned int filesize = size; GfLogTrace("Server file size %u\n",filesize); short namelen = strlen(pszFile); /* On 64 bit systems, the following calculates a buffer size that is * bigger than necessary, but that is safe. Better too big than too * small. */ size_t bufsize = 1 + sizeof namelen + namelen + sizeof filesize + filesize; PackedBuffer msg(bufsize); try { msg.pack_ubyte(FILE_PACKET); msg.pack_short(namelen); msg.pack_string(pszFile, namelen); msg.pack_uint(filesize); msg.pack_string(buf, size); } catch (PackedBufferException &e) { GfLogFatal("SendFilePacket: packed buffer error\n"); } GfLogTrace("SendFilePacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); }
//Remove disconnected player from race track void NetServer::RemovePlayerFromRace(unsigned int idx) { GfLogTrace("Removing disconnected player\n"); std::vector<CarStatus> vecCarStatus; double time = 0.0; int startRank = GetDriverStartRank(idx); CarStatus cstatus; cstatus.topSpeed = -1.0; cstatus.fuel = -1.0; cstatus.startRank = startRank; cstatus.dammage = -1; cstatus.state = RM_CAR_STATE_ELIMINATED; cstatus.time = m_currentTime; NetMutexData *pNData = LockNetworkData(); pNData->m_vecCarStatus.push_back(cstatus); UnlockNetworkData(); vecCarStatus.push_back(cstatus); time = m_currentTime; int iNumCars = vecCarStatus.size(); PackedBuffer msg; try { msg.pack_ubyte(CARSTATUS_PACKET); msg.pack_double(time); msg.pack_int(iNumCars); for (int i=0;i<iNumCars;i++) { msg.pack_float(vecCarStatus[i].topSpeed); msg.pack_int(vecCarStatus[i].state); msg.pack_int(vecCarStatus[i].startRank); msg.pack_int(vecCarStatus[i].dammage); msg.pack_float(vecCarStatus[i].fuel); } } catch (PackedBufferException &e) { GfLogFatal("RemovePlayerFromRace: packed buffer error\n"); } GfLogTrace("RemovePlayerFromRace: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); }
/** Initialize the gaming framework. @ingroup tgf @param bWithLogging If false, inhibit logging output @return None */ void GfInit(bool bWithLogging) { gfTraceInit(bWithLogging); gfDirInit(); gfModInit(); gfOsInit(); gfParamInit(); // Initialize SDL and useful subsystems (some others may be initialized in tgfclient). if (SDL_Init(SDL_INIT_TIMER) < 0) GfLogFatal("Couldn't initialize SDL(timer) (%s)\n", SDL_GetError()); // Trace build information. GfLogInfo("Built on %s\n", SD_BUILD_INFO_SYSTEM); GfLogInfo(" with CMake %s, '%s' generator\n", SD_BUILD_INFO_CMAKE_VERSION, SD_BUILD_INFO_CMAKE_GENERATOR); GfLogInfo(" with %s %s compiler ('%s' configuration)\n", SD_BUILD_INFO_COMPILER_NAME, SD_BUILD_INFO_COMPILER_VERSION, SD_BUILD_INFO_CONFIGURATION); // Trace current OS information. std::string strName; int nMajor, nMinor, nPatch, nBits; if (GfGetOSInfo(strName, nMajor, nMinor, nPatch, nBits)) { GfLogInfo("Current OS is %s", (strName.empty() ? "unknown" : strName.c_str())); if (nMajor >= 0) { GfLogInfo(" (R%d", nMajor); if (nMinor >= 0) { GfLogInfo(".%d", nMinor); if (nPatch >= 0) GfLogInfo(".%d", nPatch); } } if (nBits >= 0) { if (nMajor >= 0) GfLogInfo(", "); else GfLogInfo(" ("); GfLogInfo("%d bits", nBits); } if (nMajor >= 0 || nBits >= 0) GfLogInfo(")"); GfLogInfo("\n"); } }
void NetClient::ReadFilePacket(ENetPacket *pPacket) { short len; size_t writeSize; char file[255]; unsigned int filesize = 0; char *filedata = 0; memset(file, 0, sizeof file); PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadFilePacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); len = msg.unpack_short(); msg.unpack_string(file, len); filesize = msg.unpack_int(); GfLogTrace("Client file size %u\n",filesize); filedata = new char[filesize]; msg.unpack_string(filedata, filesize); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("ReadFilePacket: packed buffer error\n"); } char filepath[255]; snprintf(filepath, sizeof filepath, "%s%s", GfLocalDir(), file); FILE *pFile = fopen(filepath,"w+b"); GfLogTrace("Reading file packet: File- %s\n",filepath); if (filedata && filesize > 0) { writeSize = fwrite(filedata, filesize, 1, pFile); if( writeSize <= 0 ) GfLogTrace("Not all bytes are send to file"); } fclose(pFile); delete [] filedata; }
// Normalize a directory path in-place : \ to / conversion + mandatory unique trailing /. char* GfPathNormalizeDir(char* pszPath, size_t nMaxPathLen) { #ifdef WIN32 // Replace '\' by '/' size_t i; for (i = 0; i < strlen(pszPath); i++) if (pszPath[i] == '\\') pszPath[i] = '/'; #endif // Add a trailing '/' if not present. if (pszPath[strlen(pszPath)-1] != '/') { if (strlen(pszPath) < nMaxPathLen - 1) strcat(pszPath, "/"); else GfLogFatal("Path '%s' too long ; could not normalize\n", pszPath); } return pszPath; }
void NetClient::ReadFinishTimePacket(ENetPacket *pPacket) { PackedBuffer msg(pPacket->data, pPacket->dataLength); GfLogTrace("ReadFinishTimePacket: packed data length=%d\n", msg.length()); try { msg.unpack_ubyte(); NetMutexData *pNData = LockNetworkData(); pNData->m_finishTime = msg.unpack_double(); UnlockNetworkData(); } // catch (PackedBufferException &e) catch (PackedBufferException) { GfLogFatal("ReadFinishTimePacket: packed buffer error\n"); } GfOut("Received finish time packet\n"); }
void NetServer::SendPrepareToRacePacket() { //Add all players to list except the server player NetServerMutexData *pSData = LockServerData(); for (int i=0;i<(int)pSData->m_vecNetworkPlayers.size();i++) { if (pSData->m_vecNetworkPlayers[i].client) { m_vecWaitForPlayers.push_back(pSData->m_vecNetworkPlayers[i]); } } UnlockServerData(); if (m_vecWaitForPlayers.size()==0) m_bBeginRace = true; ////TODO send needed xml files to race PackedBuffer msg; try { msg.pack_ubyte(PREPARETORACE_PACKET); } catch (PackedBufferException &e) { GfLogFatal("SendPrepareToRacePacket: packed buffer error\n"); } GfLogTrace("SendPrepareToRacePacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); }
void NetServer::SendRaceSetupPacket() { PackedBuffer msg; try { msg.pack_ubyte(RACEINFOCHANGE_PACKET); } catch (PackedBufferException &e) { GfLogFatal("SendRaceSetupPacket: packed buffer error\n"); } GfLogTrace("SendRaceSetupPacket: packed data length=%d\n", msg.length()); ENetPacket * pPacket = enet_packet_create (msg.buffer(), msg.length(), ENET_PACKET_FLAG_RELIABLE); BroadcastPacket(pPacket,RELIABLECHANNEL); SetRaceInfoChanged(true); }
GfTracks::GfTracks() { _pPrivate = new GfTracks::Private; // Get the list of sub-dirs in the "tracks" folder (the track categories). tFList* lstCatFolders = GfDirGetList("tracks"); if (!lstCatFolders) { GfLogFatal("No track category available in the 'tracks' folder\n"); return; } tFList* pCatFolder = lstCatFolders; do { //GfLogDebug("GfTracks::GfTracks() : Examining category %s\n", pCatFolder->name); // Ignore "." and ".." folders. const char* pszCatId = pCatFolder->name; if (pszCatId[0] == '.') continue; // Get the list of sub-dirs in the "tracks" folder (the track categories). std::string strDirName("tracks/"); strDirName += pszCatId; tFList* lstTrackFolders = GfDirGetList(strDirName.c_str()); if (!lstTrackFolders) { GfLogWarning("No track available in the '%s' folder\n", strDirName.c_str()); continue; } // Add new category. _pPrivate->vecCatIds.push_back(pszCatId); // Look at the tracks in this category. tFList* pTrackFolder = lstTrackFolders; do { //GfLogDebug("GfTracks::GfTracks() : Examining track %s\n", pTrackFolder->name); // Determine and check the XML file of the track. const char* pszTrackId = pTrackFolder->name; std::ostringstream ossFileName; ossFileName << "tracks/" << pszCatId << '/' << pszTrackId << '/' << pszTrackId << '.' << TRKEXT; const std::string strTrackFileName(ossFileName.str()); if (!GfFileExists(strTrackFileName.c_str())) { GfLogInfo("Ignoring track %s : %s not found\n", pszTrackId, strTrackFileName.c_str()); continue; } // Get 1st level track info (those which don't need to open any file). ossFileName.str(""); ossFileName << "tracks/" << pszCatId << '/' << pszTrackId << '/' << pszTrackId << ".jpg"; std::string strPreviewFileName(ossFileName.str()); if (!GfFileExists(strPreviewFileName.c_str())) { ossFileName.str(""); ossFileName << "tracks/" << pszCatId << '/' << pszTrackId << '/' << pszTrackId << ".png"; strPreviewFileName = ossFileName.str(); } if (!GfFileExists(strPreviewFileName.c_str())) strPreviewFileName = "data/img/splash-trackselect.jpg"; ossFileName.str(""); ossFileName << "tracks/" << pszCatId << '/' << pszTrackId << '/' << "outline.png"; std::string strOutlineFileName(ossFileName.str()); if (!GfFileExists(strOutlineFileName.c_str())) strOutlineFileName = "data/img/notrackoutline.png"; // Store track info in the GfTrack structure. GfTrack* pTrack = new GfTrack; pTrack->setId(pszTrackId); pTrack->setCategoryId(pszCatId); pTrack->setDescriptorFile(strTrackFileName); pTrack->setPreviewFile(strPreviewFileName); pTrack->setOutlineFile(strOutlineFileName); // Update the GfTracks singleton. _pPrivate->vecTracks.push_back(pTrack); _pPrivate->mapTracksById[pszTrackId] = pTrack; } while ((pTrackFolder = pTrackFolder->next) != lstTrackFolders); GfDirFreeList(lstTrackFolders, NULL, true, true); } while ((pCatFolder = pCatFolder->next) != lstCatFolders); GfDirFreeList(lstCatFolders, NULL, true, true); // Sort the car category ids and driver types vectors. std::sort(_pPrivate->vecCatIds.begin(), _pPrivate->vecCatIds.end()); // Trace what we got. print(false); // No verbose here, otherwise infinite recursion. }
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::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); }
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; }
static char* makeRunTimeDirPath(const char* srcPath) { static const size_t bufSize = 512; // Allocate target buffer (must be freed by caller when useless). char* tgtPath = (char *)malloc(bufSize); tgtPath[0] = 0; // If the path starts with a ~, substitute ~ with $HOME / <My documents> // (to give the user an easy access to advanced settings). if (strlen(srcPath) > 0 && srcPath[0] == '~' && (strlen(srcPath) == 1 || (srcPath[1] == '/' || srcPath[1] == '\\'))) { #ifdef WIN32 LPITEMIDLIST pidl; if (!SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_PERSONAL, &pidl)) || !SHGetPathFromIDList(pidl, tgtPath)) GfLogFatal("Could not get user's My documents folder path\n"); #else const char* pszHomeDir = getenv("HOME"); if (pszHomeDir && strlen(pszHomeDir) > 0) strcpy(tgtPath, pszHomeDir); else GfLogFatal("Could not get user's HOME folder path, or it is empty\n"); #endif if (strlen(tgtPath) + strlen(srcPath) - 1 < bufSize - 1) strcat(tgtPath, srcPath+1); // Don't keep the ~. else { free(tgtPath); tgtPath = 0; } } // If the path is not already an absolute one, // prefix it with the install dir if we know it already. else if (strlen(srcPath) > 0 && srcPath[0] != '/' && srcPath[0] != '\\' && !(strlen(srcPath) > 1 && srcPath[1] == ':')) { if (gfInstallDir) strcpy(tgtPath, gfInstallDir); else { if(!getcwd(tgtPath, bufSize)) GfLogError("Could not get the current working directory"); strcat(tgtPath, "/"); } if (!strcmp(srcPath, ".")) ; // Nothing more to append. else if (strlen(tgtPath) + strlen(srcPath) < bufSize - 1) strcat(tgtPath, srcPath); else { free(tgtPath); tgtPath = 0; } } // Already an absolute path : simply copy it. else strcpy(tgtPath, srcPath); // Fix \ and add a trailing / is needed. if (tgtPath) GfPathNormalizeDir(tgtPath, bufSize - 1); if (!tgtPath) GfLogFatal("Path '%s' too long ; could not make it a run-time path\n", srcPath); return tgtPath; }
void GfDrivers::reload() { // Clear all. clear(); // (Re)Load robot modules from the "drivers" installed folder. std::string strDriversDirName(GfLibDir()); strDriversDirName += "drivers"; tModList* lstDriverModules = 0; const int nDriverModules = GfModInfoDir(CAR_IDENT, strDriversDirName.c_str(), 1, &lstDriverModules); if (nDriverModules <= 0 || !lstDriverModules) { GfLogFatal("Could not load any driver module from %s", strDriversDirName.c_str()); return; } // For each module found, load drivers information. tModList *pCurModule = lstDriverModules; do { pCurModule = pCurModule->next; // Determine the module name. std::string strModName(pCurModule->sopath); strModName.erase(strlen(pCurModule->sopath) - strlen(DLLEXT) - 1); // Truncate file ext. const size_t nLastSlashInd = strModName.rfind('/'); if (nLastSlashInd != std::string::npos) strModName = strModName.substr(nLastSlashInd+1); // Remove heading folder path. // Load the module XML descriptor file (try user settings first, and then installed one) std::ostringstream ossRobotFileName; ossRobotFileName << GfLocalDir() << "drivers/" << strModName << '/' << strModName << PARAMEXT; void *hparmRobot = GfParmReadFile(ossRobotFileName.str().c_str(), GFPARM_RMODE_STD | GFPARM_RMODE_REREAD); if (!hparmRobot) { ossRobotFileName.str(""); ossRobotFileName << "drivers/" << strModName << '/' << strModName << PARAMEXT; hparmRobot = GfParmReadFile(ossRobotFileName.str().c_str(), GFPARM_RMODE_STD | GFPARM_RMODE_REREAD); } if (!hparmRobot) { // Do not waste log with drivers that do not exists or do not have to exist! if (strncmp("dandroid",strModName.c_str(),8) == 0) continue; else if (strncmp("usr",strModName.c_str(),3) == 0) continue; else if (strncmp("replay",strModName.c_str(),6) == 0) continue; GfLogError("No usable '%s' driver (%s.xml not found or not readable)\n", strModName.c_str(), strModName.c_str()); continue; } // For each driver (= interface) "in" the module for (int nItfInd = 0; nItfInd < pCurModule->modInfoSize; nItfInd++) { // Ignore undefined drivers or showing an empty name if (!pCurModule->modInfo[nItfInd].name || pCurModule->modInfo[nItfInd].name[0] == '\0') { GfLogInfo("Ignoring '%s' driver #%d (not defined or empty name)\n", strModName.c_str(), nItfInd); continue; } // Create the driver and load info from the XML file. GfDriver* pDriver = new GfDriver(strModName, pCurModule->modInfo[nItfInd].index, pCurModule->modInfo[nItfInd].name, hparmRobot); // For human drivers, if the car was not found, select the 1st possible one. if (!pDriver->getCar() && pDriver->isHuman()) { GfCar* pSubstCar = GfCars::self()->getCarsInCategory()[0]; // Should never fail. if (pSubstCar) { std::ostringstream ossDrvSecPath; ossDrvSecPath << ROB_SECT_ROBOTS << '/' << ROB_LIST_INDEX << '/' << pCurModule->modInfo[nItfInd].index; const char* pszCarId = GfParmGetStr(hparmRobot, ossDrvSecPath.str().c_str(), ROB_ATTR_CAR, ""); GfLogWarning("Changing '%s' driver '%s' (#%d) 's car to %s (default one '%s' not available)\n", strModName.c_str(), pCurModule->modInfo[nItfInd].name, pCurModule->modInfo[nItfInd].index, pSubstCar->getId().c_str(), pszCarId); pDriver->setCar(pSubstCar); } } // Keep the driver only if he drives an existing car. if (pDriver->getCar()) { // Update the GfDrivers singleton. _pPrivate->vecDrivers.push_back(pDriver); const std::pair<std::string, int> driverKey(pDriver->getModuleName(), pDriver->getInterfaceIndex()); _pPrivate->mapDriversByKey[driverKey] = pDriver; if (std::find(_pPrivate->vecTypes.begin(), _pPrivate->vecTypes.end(), pDriver->getType()) == _pPrivate->vecTypes.end()) _pPrivate->vecTypes.push_back(pDriver->getType()); if (std::find(_pPrivate->vecCarCategoryIds.begin(), _pPrivate->vecCarCategoryIds.end(), pDriver->getCar()->getCategoryId()) == _pPrivate->vecCarCategoryIds.end()) _pPrivate->vecCarCategoryIds.push_back(pDriver->getCar()->getCategoryId()); } else { delete pDriver; std::ostringstream ossDrvSecPath; ossDrvSecPath << ROB_SECT_ROBOTS << '/' << ROB_LIST_INDEX << '/' << pCurModule->modInfo[nItfInd].index; const char* pszCarId = GfParmGetStr(hparmRobot, ossDrvSecPath.str().c_str(), ROB_ATTR_CAR, ""); GfLogInfo("Ignoring '%s' driver '%s' (#%d) (not defined or default car '%s' not available)\n", strModName.c_str(), pCurModule->modInfo[nItfInd].name, pCurModule->modInfo[nItfInd].index, pszCarId); } } // Close driver module descriptor file if open GfParmReleaseHandle(hparmRobot); } while (pCurModule != lstDriverModules); // Free the module list. GfModFreeInfoList(&lstDriverModules); // Sort the car category ids and driver types vectors. std::sort(_pPrivate->vecCarCategoryIds.begin(), _pPrivate->vecCarCategoryIds.end()); std::sort(_pPrivate->vecTypes.begin(), _pPrivate->vecTypes.end()); // Trace what we got. print(); }