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

View file

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

View file

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

File diff suppressed because it is too large Load diff