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