applied Tom's patch for reindented network module

git-svn-id: https://svn.code.sf.net/p/speed-dreams/code/trunk@5537 30fe4595-0a0c-4342-8851-515496e4dcbd

Former-commit-id: 7b5608b9c770754ba7171c79a2c4cb823b27b695
Former-commit-id: a53ea12099f2d163d1c87954f7faf015a9ea2dfd
This commit is contained in:
torcs-ng 2013-06-24 20:50:53 +00:00
parent 28fd22f1a8
commit b51bd09683
6 changed files with 2167 additions and 2167 deletions

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

View file

@ -1,10 +1,10 @@
// -*- Mode: c++ -*-
/*************************************************************************** /***************************************************************************
file : network.h
created : July 2009 file : network.h
copyright : (C) 2009 Brian Gavin created : July 2009
web : speed-dreams.sourceforge.net copyright : (C) 2009 Brian Gavin
version : $Id$ web : speed-dreams.sourceforge.net
version : $Id$
***************************************************************************/ ***************************************************************************/
@ -91,55 +91,55 @@ enum EnumClientAccepted { PROCESSINGCLIENT,CLIENTREJECTED,CLIENTACCEPTED };
//Packed / Compressed to reduce internet bandwidth requirements //Packed / Compressed to reduce internet bandwidth requirements
struct CarControlsPacked struct CarControlsPacked
{ {
unsigned char startRank; unsigned char startRank;
tDynPt DynGCg; /* GC global data */ tDynPt DynGCg; /* GC global data */
short steering;//Fixed point between -2,2 short steering;//Fixed point between -2,2
short throttle;//Fixed point between -2,2 short throttle;//Fixed point between -2,2
short brake;//Fixed point between -2,2 short brake;//Fixed point between -2,2
short clutch;//Fixed point between -2,2 short clutch;//Fixed point between -2,2
unsigned char gear; unsigned char gear;
}; };
//Uncompressed car controls pack //Uncompressed car controls pack
struct CarControlsData struct CarControlsData
{ {
int startRank; int startRank;
tDynPt DynGCg; /* GC global data */ tDynPt DynGCg; /* GC global data */
float steering; float steering;
float throttle; float throttle;
float brake; float brake;
float clutch; float clutch;
int gear; int gear;
double time; double time;
}; };
struct LapStatus struct LapStatus
{ {
double bestLapTime; double bestLapTime;
double bestSplitTime; double bestSplitTime;
int laps; int laps;
int startRank; int startRank;
}; };
struct CarStatus struct CarStatus
{ {
float topSpeed; float topSpeed;
int state; int state;
double time; double time;
float fuel; float fuel;
int dammage; int dammage;
int startRank; int startRank;
}; };
struct CarStatusPacked struct CarStatusPacked
{ {
float topSpeed; float topSpeed;
short state; short state;
float fuel; float fuel;
int dammage; int dammage;
unsigned char startRank; unsigned char startRank;
}; };
@ -147,28 +147,28 @@ struct CarStatusPacked
class NETWORKING_API NetDriver class NETWORKING_API NetDriver
{ {
public: public:
NetDriver(); NetDriver();
~NetDriver() {} ~NetDriver() {}
ENetAddress address; ENetAddress address;
unsigned short hostPort; unsigned short hostPort;
int idx; int idx;
char name[64]; char name[64];
char car[64]; char car[64];
char team[64]; char team[64];
char author[64]; char author[64];
int racenumber; int racenumber;
char skilllevel[64]; char skilllevel[64];
float red,green,blue; float red,green,blue;
char module[64]; char module[64];
char type[64]; char type[64];
bool client; bool client;
}; };
//Holds car setup values //Holds car setup values
struct CarSetup struct CarSetup
{ {
//TODO //TODO
}; };
struct SDL_mutex; struct SDL_mutex;
@ -177,263 +177,263 @@ struct SDL_mutex;
class NETWORKING_API NetMutexData class NETWORKING_API NetMutexData
{ {
public: public:
NetMutexData(); NetMutexData();
virtual ~NetMutexData(); virtual ~NetMutexData();
void Lock(); void Lock();
void Unlock(); void Unlock();
void Init(); void Init();
SDL_mutex *m_networkMutex; SDL_mutex *m_networkMutex;
std::vector<CarControlsData> m_vecCarCtrls; std::vector<CarControlsData> m_vecCarCtrls;
std::vector<CarStatus> m_vecCarStatus; std::vector<CarStatus> m_vecCarStatus;
std::vector<LapStatus> m_vecLapStatus; std::vector<LapStatus> m_vecLapStatus;
std::vector<bool> m_vecReadyStatus; std::vector<bool> m_vecReadyStatus;
double m_finishTime; double m_finishTime;
}; };
//Put data here that is read by the network thread and the main thread //Put data here that is read by the network thread and the main thread
class NETWORKING_API NetServerMutexData class NETWORKING_API NetServerMutexData
{ {
public: public:
void Init(); void Init();
NetServerMutexData(); NetServerMutexData();
virtual ~NetServerMutexData(); virtual ~NetServerMutexData();
void Lock(); void Lock();
void Unlock(); void Unlock();
SDL_mutex *m_networkMutex; SDL_mutex *m_networkMutex;
std::vector<NetDriver> m_vecNetworkPlayers; std::vector<NetDriver> m_vecNetworkPlayers;
}; };
class NETWORKING_API NetNetwork class NETWORKING_API NetNetwork
{ {
public: public:
NetNetwork(); NetNetwork();
virtual ~NetNetwork(); virtual ~NetNetwork();
void SetCurrentTime(double time) {m_currentTime = time;} void SetCurrentTime(double time) {m_currentTime = time;}
bool IsServerMode(); bool IsServerMode();
bool IsClientMode(); bool IsClientMode();
bool SetCurrentDriver(); bool SetCurrentDriver();
int GetNetworkHumanIdx(); int GetNetworkHumanIdx();
int GetDriverIdx(); int GetDriverIdx();
int GetCarIndex(int startRank,tSituation *s); int GetCarIndex(int startRank,tSituation *s);
virtual void ReadLapStatusPacket(ENetPacket *pPacket); virtual void ReadLapStatusPacket(ENetPacket *pPacket);
virtual void SendCarControlsPacket(tSituation *s); virtual void SendCarControlsPacket(tSituation *s);
virtual void SendCarStatusPacket(tSituation *s,bool bForce); virtual void SendCarStatusPacket(tSituation *s,bool bForce);
virtual void SendLapStatusPacket(tCarElt *pCar); virtual void SendLapStatusPacket(tCarElt *pCar);
virtual void SetDriverReady(bool bReady) {}; virtual void SetDriverReady(bool bReady) {};
virtual bool IsConnected() { return false;} virtual bool IsConnected() { return false;}
virtual bool IsRaceActive() { return m_bRaceActive;} virtual bool IsRaceActive() { return m_bRaceActive;}
virtual void SetRaceActive(bool bStatus) {m_bRaceActive = bStatus;} virtual void SetRaceActive(bool bStatus) {m_bRaceActive = bStatus;}
virtual void RaceInit(tSituation *s); virtual void RaceInit(tSituation *s);
virtual void RaceDone(); virtual void RaceDone();
int GetDriverStartRank(int idx); int GetDriverStartRank(int idx);
virtual bool listen(){ return false;};
virtual void Disconnect() {}; virtual bool listen(){ return false;};
virtual void ResetNetwork() {};
void ReadCarControlsPacket(ENetPacket *pPacket); virtual void Disconnect() {};
void ReadCarStatusPacket(ENetPacket *pPacket); virtual void ResetNetwork() {};
void PackCarControl(tCarCtrl *pCtrl,int &size,char *&pBuffer);
void UnPackCarControl(tCarCtrl *&pCtrl,int size,char *pBuffer);
bool PrepareToRace(){return m_bPrepareToRace;}
void SetRaceInfoChanged(bool bStatus);
void SetRefreshDisplay(bool bStatus);
bool GetRefreshDisplay() {return m_bRefreshDisplay;}
bool GetRaceInfoChanged(){return m_bRaceInfoChanged;};
double GetRaceStartTime(){return m_racestarttime;}
std::string GetNetworkDriverName();
void SetRaceXMLFile(char const *pXMLFile);
void ReadDriverData(NetDriver &player,int index,void *param);
void WriteDriverData(NetDriver player,int index,void *param);
int GetPlayerCarIndex(tSituation *s);
void ClearLocalDrivers(); void ReadCarControlsPacket(ENetPacket *pPacket);
void ReadCarStatusPacket(ENetPacket *pPacket);
void PackCarControl(tCarCtrl *pCtrl,int &size,char *&pBuffer);
void UnPackCarControl(tCarCtrl *&pCtrl,int size,char *pBuffer);
bool PrepareToRace(){return m_bPrepareToRace;}
void SetRaceInfoChanged(bool bStatus);
void SetRefreshDisplay(bool bStatus);
bool GetRefreshDisplay() {return m_bRefreshDisplay;}
bool GetRaceInfoChanged(){return m_bRaceInfoChanged;};
double GetRaceStartTime(){return m_racestarttime;}
std::string GetNetworkDriverName();
void SetRaceXMLFile(char const *pXMLFile);
void ReadDriverData(NetDriver &player,int index,void *param);
void WriteDriverData(NetDriver player,int index,void *param);
int GetPlayerCarIndex(tSituation *s);
void SetDriverName(char *pName); void ClearLocalDrivers();
const char *GetDriverName();
virtual void SetLocalDrivers();
void GetHostSettings(std::string &strCarCat,bool &bCollisions);
virtual void SetCarInfo(const char *pszName);
virtual bool FinishRace(double time) ; void SetDriverName(char *pName);
const char *GetDriverName();
virtual void SetLocalDrivers();
void GetHostSettings(std::string &strCarCat,bool &bCollisions);
virtual void SetCarInfo(const char *pszName);
NetMutexData * LockNetworkData() ; virtual bool FinishRace(double time) ;
void UnlockNetworkData();
NetMutexData * LockNetworkData() ;
void UnlockNetworkData();
protected: protected:
std::string m_strDriverName; std::string m_strDriverName;
ENetHost * m_pHost; ENetHost * m_pHost;
virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel); virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel);
int m_driverIdx; int m_driverIdx;
bool m_bBeginRace; bool m_bBeginRace;
bool m_bRaceInfoChanged; bool m_bRaceInfoChanged;
bool m_bRefreshDisplay; bool m_bRefreshDisplay;
double m_racestarttime; double m_racestarttime;
bool m_bPrepareToRace; bool m_bPrepareToRace;
bool m_bTimeSynced; bool m_bTimeSynced;
bool m_bRaceActive; bool m_bRaceActive;
//time when packet was sent or recieved //time when packet was sent or recieved
double m_activeNetworkTime; double m_activeNetworkTime;
ENetAddress m_address; ENetAddress m_address;
FILE *m_pFile; FILE *m_pFile;
double m_sendCtrlTime;
double m_sendCarDataTime;
double m_currentTime;
NetMutexData m_NetworkData; double m_sendCtrlTime;
double m_sendCarDataTime;
double m_currentTime;
NetMutexData m_NetworkData;
std::map<int,int> m_mapRanks; std::map<int,int> m_mapRanks;
std::set<int> m_setLocalDrivers; std::set<int> m_setLocalDrivers;
double m_timePhysics; double m_timePhysics;
std::string m_strClass; std::string m_strClass;
std::string m_strRaceXMLFile; std::string m_strRaceXMLFile;
}; };
class NETWORKING_API NetClient: public NetNetwork class NETWORKING_API NetClient: public NetNetwork
{ {
public: public:
NetClient(); NetClient();
~NetClient(); ~NetClient();
virtual void Disconnect(); virtual void Disconnect();
virtual void ResetNetwork(); virtual void ResetNetwork();
virtual bool IsConnected(); virtual bool IsConnected();
bool ConnectToServer(const char *pAddress,int port, NetDriver *pDriver); bool ConnectToServer(const char *pAddress,int port, NetDriver *pDriver);
virtual bool listen(); virtual bool listen();
//Packets //Packets
bool SendDriverInfoPacket(NetDriver *pDriver); bool SendDriverInfoPacket(NetDriver *pDriver);
virtual void SendDriverReadyPacket(){}; virtual void SendDriverReadyPacket(){};
void SendReadyToStartPacket(); void SendReadyToStartPacket();
double WaitForRaceStart(); double WaitForRaceStart();
void SendServerTimeRequest(); void SendServerTimeRequest();
virtual void SetDriverReady(bool bReady); virtual void SetDriverReady(bool bReady);
bool TimeSynced(){return m_bTimeSynced;} bool TimeSynced(){return m_bTimeSynced;}
int LookUpDriverIdx() { return m_driverIdx;} int LookUpDriverIdx() { return m_driverIdx;}
bool listenHost(ENetHost * pHost); bool listenHost(ENetHost * pHost);
virtual void SetLocalDrivers(); virtual void SetLocalDrivers();
void ConnectToClients(); void ConnectToClients();
void SetCarInfo(const char *pszName); void SetCarInfo(const char *pszName);
protected: protected:
//Packets //Packets
void ReadRaceSetupPacket(ENetPacket *pPacket); void ReadRaceSetupPacket(ENetPacket *pPacket);
void ReadPrepareToRacePacket(ENetPacket *pPacket); void ReadPrepareToRacePacket(ENetPacket *pPacket);
void ReadStartTimePacket(ENetPacket *pPacket); void ReadStartTimePacket(ENetPacket *pPacket);
void ReadFilePacket(ENetPacket *pPacket); void ReadFilePacket(ENetPacket *pPacket);
void ReadPacket(ENetEvent event); void ReadPacket(ENetEvent event);
void ReadTimePacket(ENetPacket *pPacket); void ReadTimePacket(ENetPacket *pPacket);
void ReadFinishTimePacket(ENetPacket *pPacket); void ReadFinishTimePacket(ENetPacket *pPacket);
void ReadAllDriverReadyPacket(ENetPacket *pPacket); void ReadAllDriverReadyPacket(ENetPacket *pPacket);
void ReadWeatherPacket(ENetPacket *pPacket); void ReadWeatherPacket(ENetPacket *pPacket);
void ReadPlayerRejectedPacket(ENetPacket *pPacket); void ReadPlayerRejectedPacket(ENetPacket *pPacket);
void ReadPlayerAcceptedPacket(ENetPacket *pPacket); void ReadPlayerAcceptedPacket(ENetPacket *pPacket);
void ConnectToDriver(NetDriver driver); void ConnectToDriver(NetDriver driver);
virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel); virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel);
bool m_bConnected; bool m_bConnected;
double m_lag; double m_lag;
double m_servertimedifference; double m_servertimedifference;
double m_packetsendtime; double m_packetsendtime;
EnumClientAccepted m_eClientAccepted; EnumClientAccepted m_eClientAccepted;
ENetHost * m_pClient; ENetHost * m_pClient;
ENetPeer *m_pServer; ENetPeer *m_pServer;
}; };
class NETWORKING_API NetServer : public NetNetwork class NETWORKING_API NetServer : public NetNetwork
{ {
public: public:
NetServer(); NetServer();
~NetServer(); ~NetServer();
virtual void Disconnect(); virtual void Disconnect();
virtual void ResetNetwork(); virtual void ResetNetwork();
virtual bool IsConnected(); virtual bool IsConnected();
bool Start(int port); bool Start(int port);
virtual bool listen(); virtual bool listen();
//Network Packets
void SendRaceSetupPacket();
void SendPrepareToRacePacket();
void SendFilePacket(const char *pszFile);
void WaitForClientsStartPacket();
void SendStartTimePacket(int &startTime);
void SendTimePacket(ENetPacket *pPacket, ENetPeer * pPeer);
void SendFinishTimePacket();
void SendWeatherPacket();
bool SendPlayerRejectedPacket(ENetPeer * pPeer,std::string strReason);
bool SendPlayerAcceptedPacket(ENetPeer * pPeer);
void SendDriversReadyPacket();
void PingClients();
virtual void SetDriverReady(bool bReady);
void OverrideDriverReady(int idx,bool bReady);
bool ClientsReadyToRace();
double WaitForRaceStart();
void UpdateClientCarInfo(tSituation *s);
void UpdateDriver(NetDriver & player); //Network Packets
void SendRaceSetupPacket();
void SendPrepareToRacePacket();
void SendFilePacket(const char *pszFile);
void WaitForClientsStartPacket();
void SendStartTimePacket(int &startTime);
void SendTimePacket(ENetPacket *pPacket, ENetPeer * pPeer);
void SendFinishTimePacket();
void SendWeatherPacket();
bool SendPlayerRejectedPacket(ENetPeer * pPeer,std::string strReason);
bool SendPlayerAcceptedPacket(ENetPeer * pPeer);
void SendDriversReadyPacket();
void PingClients();
virtual void SetDriverReady(bool bReady);
void OverrideDriverReady(int idx,bool bReady);
int NumberofPlayers(); bool ClientsReadyToRace();
NetDriver GetPlayer(int i); double WaitForRaceStart();
void ClearDrivers(); void UpdateClientCarInfo(tSituation *s);
void RemoveDriver(ENetEvent event);
void CreateNetworkRobotFile();
//virtual void SendCarControlsPacket(tSituation *s);
virtual void SetLocalDrivers();
void SetHostSettings(const char *pszCarCat,bool bCollisions);
void SetCarInfo(const char *pszName); void UpdateDriver(NetDriver & player);
void SetFinishTime(double time);
void RemovePlayerFromRace(unsigned int idx); int NumberofPlayers();
NetDriver GetPlayer(int i);
void ClearDrivers();
void RemoveDriver(ENetEvent event);
void CreateNetworkRobotFile();
//virtual void SendCarControlsPacket(tSituation *s);
virtual void SetLocalDrivers();
void SetHostSettings(const char *pszCarCat,bool bCollisions);
void SetCarInfo(const char *pszName);
void SetFinishTime(double time);
void RemovePlayerFromRace(unsigned int idx);
NetServerMutexData * LockServerData();
void UnlockServerData();
NetServerMutexData * LockServerData();
void UnlockServerData();
protected: protected:
void GenerateDriversForXML(); void GenerateDriversForXML();
//Packets //Packets
void ReadDriverInfoPacket(ENetPacket *ENetPacket, ENetPeer * pPeer); void ReadDriverInfoPacket(ENetPacket *ENetPacket, ENetPeer * pPeer);
void ReadDriverReadyPacket(ENetPacket *pPacket); void ReadDriverReadyPacket(ENetPacket *pPacket);
void ReadPacket(ENetEvent event); void ReadPacket(ENetEvent event);
NetServerMutexData m_ServerData;
virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel);
void Dump(const char* pszCaller);
std::vector<NetDriver> m_vecWaitForPlayers; NetServerMutexData m_ServerData;
virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel);
void Dump(const char* pszCaller);
std::vector<NetDriver> m_vecWaitForPlayers;
ENetHost * m_pServer; ENetHost * m_pServer;
}; };

View file

@ -1,10 +1,10 @@
// -*- Mode: c++ -*- /***************************************************************************
/****************************************1***********************************
file : network.cpp file : network.cpp
created : July 2009 created : July 2009
copyright : (C) 2009 Brian Gavin copyright : (C) 2009 Brian Gavin
web : speed-dreams.sourceforge.net web : speed-dreams.sourceforge.net
version : $Id$ version : $Id$
***************************************************************************/ ***************************************************************************/
@ -18,9 +18,9 @@
***************************************************************************/ ***************************************************************************/
/* /*
This file will generate the xml file needed for a robot file. This file will generate the xml file needed for a robot file.
Currently only used for networkhuman.xml Currently only used for networkhuman.xml
*/ */
#include "robotxml.h" #include "robotxml.h"
@ -30,88 +30,88 @@ RobotXml::RobotXml()
bool RobotXml::CreateRobotFile(const char*pRobotName,std::vector<NetDriver> &vecDrivers) bool RobotXml::CreateRobotFile(const char*pRobotName,std::vector<NetDriver> &vecDrivers)
{ {
char buf[255]; char buf[255];
sprintf(buf,"drivers/%s/%s.xml",pRobotName,pRobotName); sprintf(buf,"drivers/%s/%s.xml",pRobotName,pRobotName);
void *params = GfParmReadFileLocal(buf,GFPARM_RMODE_CREAT); void *params = GfParmReadFileLocal(buf,GFPARM_RMODE_CREAT);
//Erase existing robots //Erase existing robots
GfParmListClean(params, "Robots"); GfParmListClean(params, "Robots");
char path2[256]; char path2[256];
for (int i=0;i<(int)vecDrivers.size();i++) for (int i=0;i<(int)vecDrivers.size();i++)
{ {
sprintf(path2, "Robots/index/%d",i+1); sprintf(path2, "Robots/index/%d",i+1);
GfParmSetStr(params, path2, "name",vecDrivers[i].name); GfParmSetStr(params, path2, "name",vecDrivers[i].name);
GfParmSetStr(params, path2, "car name",vecDrivers[i].car); GfParmSetStr(params, path2, "car name",vecDrivers[i].car);
GfParmSetNum(params, path2, "race number", (char*)NULL,(tdble) vecDrivers[i].racenumber); GfParmSetNum(params, path2, "race number", (char*)NULL,(tdble) vecDrivers[i].racenumber);
GfParmSetNum(params, path2, "red", (char*)NULL, vecDrivers[i].red); GfParmSetNum(params, path2, "red", (char*)NULL, vecDrivers[i].red);
GfParmSetNum(params, path2, "green", (char*)NULL, vecDrivers[i].green); GfParmSetNum(params, path2, "green", (char*)NULL, vecDrivers[i].green);
GfParmSetNum(params, path2, "blue", (char*)NULL, vecDrivers[i].blue); GfParmSetNum(params, path2, "blue", (char*)NULL, vecDrivers[i].blue);
GfParmSetStr(params, path2, "type",vecDrivers[i].type); GfParmSetStr(params, path2, "type",vecDrivers[i].type);
GfParmSetStr(params, path2, "skill level",vecDrivers[i].skilllevel); GfParmSetStr(params, path2, "skill level",vecDrivers[i].skilllevel);
GfParmSetStr(params, path2, "networkrace","yes"); GfParmSetStr(params, path2, "networkrace","yes");
if (vecDrivers[i].client) if (vecDrivers[i].client)
GfParmSetStr(params, path2, "client","yes"); GfParmSetStr(params, path2, "client","yes");
else else
GfParmSetStr(params, path2, "client","no"); GfParmSetStr(params, path2, "client","no");
char hostName[256];
enet_address_get_host_ip (&vecDrivers[i].address,hostName,256);
GfParmSetStr(params, path2, "host",hostName);
GfParmSetNum(params, path2, "port",(char*)NULL, vecDrivers[i].address.port);
}
//Save our changes char hostName[256];
GfParmWriteFileLocal(buf, params, pRobotName); enet_address_get_host_ip (&vecDrivers[i].address,hostName,256);
GfParmSetStr(params, path2, "host",hostName);
GfParmSetNum(params, path2, "port",(char*)NULL, vecDrivers[i].address.port);
}
GfParmReleaseHandle(params); //Save our changes
GfParmWriteFileLocal(buf, params, pRobotName);
return true; GfParmReleaseHandle(params);
return true;
} }
bool RobotXml::ReadRobotDrivers(const char*pRobotName,std::vector<NetDriver> &vecDrivers) bool RobotXml::ReadRobotDrivers(const char*pRobotName,std::vector<NetDriver> &vecDrivers)
{ {
char buf[255]; char buf[255];
sprintf(buf,"drivers/%s/%s.xml",pRobotName,pRobotName); sprintf(buf,"drivers/%s/%s.xml",pRobotName,pRobotName);
void *params = GfParmReadFileLocal(buf,GFPARM_RMODE_REREAD); void *params = GfParmReadFileLocal(buf,GFPARM_RMODE_REREAD);
char path2[256]; char path2[256];
//bool bFound = true; //bool bFound = true;
//int i = 1; //int i = 1;
int nPlayers = GfParmGetEltNb(params, "Robots/index"); int nPlayers = GfParmGetEltNb(params, "Robots/index");
for (int i= 1;i<=nPlayers;i++) for (int i= 1;i<=nPlayers;i++)
{ {
sprintf(path2, "Robots/index/%i",i); sprintf(path2, "Robots/index/%i",i);
NetDriver driver; NetDriver driver;
strncpy(driver.name,GfParmGetStr(params, path2, "name",NULL),64); strncpy(driver.name,GfParmGetStr(params, path2, "name",NULL),64);
std::string strClient = GfParmGetStr(params, path2, "client",NULL); std::string strClient = GfParmGetStr(params, path2, "client",NULL);
if (strClient == "yes") if (strClient == "yes")
driver.client = true; driver.client = true;
else else
driver.client = false; driver.client = false;
strncpy(driver.car,GfParmGetStr(params, path2, "car name",NULL),64); strncpy(driver.car,GfParmGetStr(params, path2, "car name",NULL),64);
strncpy(driver.type,GfParmGetStr(params, path2, "type",NULL),64); strncpy(driver.type,GfParmGetStr(params, path2, "type",NULL),64);
strncpy(driver.skilllevel,GfParmGetStr(params, path2, "skill level",NULL),64); strncpy(driver.skilllevel,GfParmGetStr(params, path2, "skill level",NULL),64);
driver.racenumber = (int)GfParmGetNum(params, path2, "race number",NULL,1.0);
driver.red = GfParmGetNum(params, path2, "red",NULL,1.0);
driver.green = GfParmGetNum(params, path2, "green",NULL,1.0);
driver.blue = GfParmGetNum(params, path2, "blue",NULL,1.0);
std::string strHost = GfParmGetStr(params, path2, "host",NULL);
ENetAddress address;
enet_address_set_host (& address, strHost.c_str());
driver.address.host = address.host;
driver.address.port = (enet_uint16)GfParmGetNum(params, path2, "port",NULL,0);
strncpy(driver.module,NETWORKROBOT,64);
vecDrivers.push_back(driver);
printf("Adding driver \n");
}
GfParmReleaseHandle(params); driver.racenumber = (int)GfParmGetNum(params, path2, "race number",NULL,1.0);
return true; driver.red = GfParmGetNum(params, path2, "red",NULL,1.0);
driver.green = GfParmGetNum(params, path2, "green",NULL,1.0);
driver.blue = GfParmGetNum(params, path2, "blue",NULL,1.0);
std::string strHost = GfParmGetStr(params, path2, "host",NULL);
ENetAddress address;
enet_address_set_host (& address, strHost.c_str());
driver.address.host = address.host;
driver.address.port = (enet_uint16)GfParmGetNum(params, path2, "port",NULL,0);
strncpy(driver.module,NETWORKROBOT,64);
vecDrivers.push_back(driver);
printf("Adding driver \n");
}
GfParmReleaseHandle(params);
return true;
} }

View file

@ -1,10 +1,10 @@
// -*- Mode: c++ -*-
/*************************************************************************** /***************************************************************************
file : robotxml.h
created : July 2009 file : robotxml.h
copyright : (C) 2009 Brian Gavin created : July 2009
web : speed-dreams.sourceforge.net copyright : (C) 2009 Brian Gavin
version : $Id$ web : speed-dreams.sourceforge.net
version : $Id$
***************************************************************************/ ***************************************************************************/
@ -27,10 +27,10 @@
class RobotXml class RobotXml
{ {
public: public:
RobotXml(); RobotXml();
bool CreateRobotFile(const char*pRobotName,std::vector<NetDriver> &vecDriver); bool CreateRobotFile(const char*pRobotName,std::vector<NetDriver> &vecDriver);
bool ReadRobotDrivers(const char*pRobotName,std::vector<NetDriver> &vecDrivers); bool ReadRobotDrivers(const char*pRobotName,std::vector<NetDriver> &vecDrivers);
}; };
#endif // ROBOTXML_H #endif // ROBOTXML_H

File diff suppressed because it is too large Load diff