From b51bd09683940a5cc8f06c12b3271b51a8483d3b Mon Sep 17 00:00:00 2001 From: torcs-ng Date: Mon, 24 Jun 2013 20:50:53 +0000 Subject: [PATCH] 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 --- src/modules/networking/client.cpp | 1054 +++++++++--------- src/modules/networking/network.cpp | 1094 +++++++++---------- src/modules/networking/network.h | 482 ++++----- src/modules/networking/robotxml.cpp | 158 +-- src/modules/networking/robotxml.h | 20 +- src/modules/networking/server.cpp | 1526 +++++++++++++-------------- 6 files changed, 2167 insertions(+), 2167 deletions(-) diff --git a/src/modules/networking/client.cpp b/src/modules/networking/client.cpp index 5760f36f9..0c4a81bc2 100644 --- a/src/modules/networking/client.cpp +++ b/src/modules/networking/client.cpp @@ -1,10 +1,10 @@ -// -*- Mode: c++ -*- /*************************************************************************** - 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$ ***************************************************************************/ @@ -27,47 +27,47 @@ NetClient::NetClient() { - if (enet_initialize () != 0) + if (enet_initialize () != 0) GfLogError ("An error occurred while initializing ENet.\n"); - m_strClass = "client"; - m_pServer = NULL; - m_pClient = NULL; - m_pHost = NULL; - m_eClientAccepted = PROCESSINGCLIENT; + m_strClass = "client"; + m_pServer = NULL; + m_pClient = NULL; + m_pHost = NULL; + m_eClientAccepted = PROCESSINGCLIENT; } NetClient::~NetClient() { - ResetNetwork(); - NetSetClient(false); + ResetNetwork(); + NetSetClient(false); } void NetClient::Disconnect() { - m_bConnected = false; - - ResetNetwork(); - NetSetClient(false); + m_bConnected = false; + + ResetNetwork(); + NetSetClient(false); } void NetClient::ResetNetwork() { - if (m_pClient == NULL) - return; + if (m_pClient == NULL) + return; - if (m_pServer == NULL) - return; + if (m_pServer == NULL) + return; + + ENetEvent event; - ENetEvent event; - enet_peer_disconnect (m_pServer, 0); - bool bDisconnect = false; + bool bDisconnect = false; /* Allow up to 3 seconds for the disconnect to succeed - and drop any packets received packets. + and drop any packets received packets. */ while (enet_host_service (m_pClient, & event, 3000) > 0) { @@ -79,117 +79,117 @@ void NetClient::ResetNetwork() case ENET_EVENT_TYPE_DISCONNECT: GfLogTrace ("Network disconnection succeeded."); - bDisconnect=true; + bDisconnect=true; + break; + + case ENET_EVENT_TYPE_NONE: + case ENET_EVENT_TYPE_CONNECT: + // Do nothing. break; - - case ENET_EVENT_TYPE_NONE: - case ENET_EVENT_TYPE_CONNECT: - // Do nothing. - break; } } - + /* We've arrived here, so the disconnect attempt didn't */ /* succeed yet. Force the connection down. */ if (!bDisconnect) - enet_peer_reset (m_pServer); + enet_peer_reset (m_pServer); - NetSetClient(false); + NetSetClient(false); ENetPeer * pCurrentPeer1; - if (m_pHost ==NULL) - return; + if (m_pHost ==NULL) + return; - for (pCurrentPeer1 = m_pHost-> peers; - pCurrentPeer1 < & m_pHost->peers [m_pHost->peerCount]; - ++ pCurrentPeer1) - { - if (pCurrentPeer1->state != ENET_PEER_STATE_CONNECTED) - continue; + for (pCurrentPeer1 = m_pHost-> peers; + pCurrentPeer1 < & m_pHost->peers [m_pHost->peerCount]; + ++ pCurrentPeer1) + { + if (pCurrentPeer1->state != ENET_PEER_STATE_CONNECTED) + continue; - enet_peer_reset (pCurrentPeer1); - } + enet_peer_reset (pCurrentPeer1); + } - enet_host_destroy(m_pHost); - m_pHost = NULL; + enet_host_destroy(m_pHost); + m_pHost = NULL; } bool NetClient::ConnectToServer(const char *pAddress,int port, NetDriver *pDriver) { - m_bTimeSynced = false; - m_bPrepareToRace = false; - m_bBeginRace = false; - m_timePhysics = -2.0; - m_servertimedifference = 0.0; - m_sendCarDataTime = 0.0; - m_sendCtrlTime = 0.0; - m_bPrepareToRace = false; - m_bBeginRace = false; - m_bConnected = false; - m_pClient = NULL; - m_pHost = NULL; + m_bTimeSynced = false; + m_bPrepareToRace = false; + m_bBeginRace = false; + m_timePhysics = -2.0; + m_servertimedifference = 0.0; + m_sendCarDataTime = 0.0; + m_sendCtrlTime = 0.0; + m_bPrepareToRace = false; + m_bBeginRace = false; + m_bConnected = false; + m_pClient = NULL; + m_pHost = NULL; #if (ENET_VERSION >= 0x010300) - m_pClient = enet_host_create (NULL /* create a client host */, - MAXNETWORKPLAYERS, - 2, /*channel limit*/ - 0/* downstream bandwidth */, - 0/* upstream bandwidth */); + m_pClient = enet_host_create (NULL /* create a client host */, + MAXNETWORKPLAYERS, + 2, /*channel limit*/ + 0/* downstream bandwidth */, + 0/* upstream bandwidth */); #else - m_pClient = enet_host_create (NULL /* create a client host */, - MAXNETWORKPLAYERS, - 0/* downstream bandwidth */, - 0/* upstream bandwidth */); + m_pClient = enet_host_create (NULL /* create a client host */, + MAXNETWORKPLAYERS, + 0/* downstream bandwidth */, + 0/* upstream bandwidth */); #endif if (m_pClient == NULL) { GfLogError ("An error occurred while trying to create an ENet client host.\n"); - ResetNetwork(); - return false; + ResetNetwork(); + return false; } ENetAddress caddress; caddress.host = ENET_HOST_ANY; - + /* Bind the server to port*/ caddress.port = SPEEDDREAMSPEERPORT; #if (ENET_VERSION >= 0x010300) - m_pHost = enet_host_create (&caddress /* create a peer host */, - MAXNETWORKPLAYERS, - 2, /*channel limit*/ - 0/* downstream bandwidth */, - 0/* upstream bandwidth */); + m_pHost = enet_host_create (&caddress /* create a peer host */, + MAXNETWORKPLAYERS, + 2, /*channel limit*/ + 0/* downstream bandwidth */, + 0/* upstream bandwidth */); #else - m_pHost = enet_host_create (&caddress /* create a peer host */, - MAXNETWORKPLAYERS, - 0/* downstream bandwidth */, - 0/* upstream bandwidth */); + m_pHost = enet_host_create (&caddress /* create a peer host */, + MAXNETWORKPLAYERS, + 0/* downstream bandwidth */, + 0/* upstream bandwidth */); #endif if(m_pHost==NULL) { - //try the other ports - for (int i=1;i<5;i++) - { - caddress.port++; + //try the other ports + for (int i=1;i<5;i++) + { + caddress.port++; #if (ENET_VERSION >= 0x010300) - m_pHost = enet_host_create (&caddress,MAXNETWORKPLAYERS,2,0,0); + m_pHost = enet_host_create (&caddress,MAXNETWORKPLAYERS,2,0,0); #else - m_pHost = enet_host_create (&caddress,MAXNETWORKPLAYERS,0,0); + m_pHost = enet_host_create (&caddress,MAXNETWORKPLAYERS,0,0); #endif - if(m_pHost) - break; - - } + if(m_pHost) + break; - if (m_pHost == NULL) - { - GfLogError("Unable to setup client listener\n"); - return false; - } + } + + if (m_pHost == NULL) + { + GfLogError("Unable to setup client listener\n"); + return false; + } } ENetAddress address; @@ -197,273 +197,273 @@ bool NetClient::ConnectToServer(const char *pAddress,int port, NetDriver *pDrive enet_address_set_host (& address, pAddress); address.port = (enet_uint16)port; - + /* Initiate the connection, allocating the two channels 0 and 1. */ - GfLogError ("Initiating network connection to host '%s:%d' ...\n", pAddress, port); - #if (ENET_VERSION >= 0x010300) - m_pServer = enet_host_connect (m_pClient, & address, 2, 0); - #else - m_pServer = enet_host_connect (m_pClient, & address, 2); - #endif + GfLogError ("Initiating network connection to host '%s:%d' ...\n", pAddress, port); +#if (ENET_VERSION >= 0x010300) + m_pServer = enet_host_connect (m_pClient, & address, 2, 0); +#else + m_pServer = enet_host_connect (m_pClient, & address, 2); +#endif if (m_pServer == NULL) { - GfLogInfo ("No available peers for initiating an ENet connection.\n"); - ResetNetwork(); - return false; + GfLogInfo ("No available peers for initiating an ENet connection.\n"); + ResetNetwork(); + return false; } - + /* Wait up to 5 seconds for the connection attempt to succeed. */ if (enet_host_service (m_pClient, & event, 5000) > 0 && - event.type == ENET_EVENT_TYPE_CONNECT) + event.type == ENET_EVENT_TYPE_CONNECT) { - m_address.host = m_pClient->address.host; - m_address.port = m_pClient->address.port; - m_bConnected = true; - GfLogInfo ("Network connection accepted.\n"); + m_address.host = m_pClient->address.host; + m_address.port = m_pClient->address.port; + m_bConnected = true; + GfLogInfo ("Network connection accepted.\n"); } else { - m_bConnected = false; - ResetNetwork(); - GfLogError ("Network connection refused.\n"); - return false; + m_bConnected = false; + ResetNetwork(); + GfLogError ("Network connection refused.\n"); + return false; } - m_eClientAccepted = PROCESSINGCLIENT; - SendDriverInfoPacket(pDriver); + m_eClientAccepted = PROCESSINGCLIENT; + SendDriverInfoPacket(pDriver); - //Wait for server to accept or reject - GfLogInfo ("Sent local driver info to the network server : waiting ...\n"); - while(m_eClientAccepted == PROCESSINGCLIENT) - SDL_Delay(50); + //Wait for server to accept or reject + GfLogInfo ("Sent local driver info to the network server : waiting ...\n"); + while(m_eClientAccepted == PROCESSINGCLIENT) + SDL_Delay(50); - if (m_eClientAccepted == CLIENTREJECTED) - { - m_bConnected = false; - ResetNetwork(); - return false; - } - else - GfLogInfo ("Driver info accepted by the network server.\n"); + if (m_eClientAccepted == CLIENTREJECTED) + { + m_bConnected = false; + ResetNetwork(); + return false; + } + else + GfLogInfo ("Driver info accepted by the network server.\n"); - return m_bConnected; + return m_bConnected; } bool NetClient::IsConnected() { - return m_bConnected; + return m_bConnected; } void NetClient::SetDriverReady(bool bReady) { - // Get local driver index in the race driver list - int idx = GetDriverIdx(); + // Get local driver index in the race driver list + int idx = GetDriverIdx(); - NetMutexData *pNData = LockNetworkData(); - pNData->m_vecReadyStatus[idx-1] = bReady; - UnlockNetworkData(); + NetMutexData *pNData = LockNetworkData(); + pNData->m_vecReadyStatus[idx-1] = bReady; + UnlockNetworkData(); - PackedBuffer msg; + PackedBuffer msg; - try - { - msg.pack_ubyte(DRIVERREADY_PACKET); - msg.pack_int(idx); - msg.pack_int(bReady); - } - catch (PackedBufferException &e) - { - GfLogFatal("SetDriverReady: packed buffer error\n"); - } - GfLogTrace("SetDriverReady: packed data length=%d\n", msg.length()); + try + { + msg.pack_ubyte(DRIVERREADY_PACKET); + msg.pack_int(idx); + msg.pack_int(bReady); + } + catch (PackedBufferException &e) + { + 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); + ENetPacket *pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)==0) - return; + if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)==0) + return; } bool NetClient::SendDriverInfoPacket(NetDriver *pDriver) { - SetDriverName(pDriver->name); - pDriver->address.port = m_pHost->address.port; + 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("->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); + 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("->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; + 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->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) - { - GfLogFatal("SendDriverInfoPacket: packed buffer error\n"); - } - GfLogTrace("SendDriverInfoPacket: packed data length=%d\n", - msg.length()); + try + { + msg.pack_ubyte(PLAYERINFO_PACKET); + msg.pack_int(pDriver->idx); + msg.pack_string(pDriver->name, sizeof pDriver->name); + 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) + { + 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); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)==0) - return true; + if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)==0) + return true; - return false; + return false; } void NetClient::SendReadyToStartPacket() { - - std::string strDName = GetDriverName(); - GfLogTrace("Sending ready to start packet\n"); - PackedBuffer msg; + std::string strDName = GetDriverName(); + GfLogTrace("Sending ready to start packet\n"); - try - { - msg.pack_ubyte(CLIENTREADYTOSTART_PACKET); - msg.pack_stdstring(strDName); - } - catch (PackedBufferException &e) - { - GfLogFatal("SendReadyToStartPacket: packed buffer error\n"); - } - GfLogTrace("SendReadyToStartPacket: packed data length=%d\n", - msg.length()); + PackedBuffer msg; - ENetPacket *pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); + try + { + msg.pack_ubyte(CLIENTREADYTOSTART_PACKET); + msg.pack_stdstring(strDName); + } + catch (PackedBufferException &e) + { + GfLogFatal("SendReadyToStartPacket: packed buffer error\n"); + } + GfLogTrace("SendReadyToStartPacket: packed data length=%d\n", + msg.length()); - if (enet_peer_send (m_pServer, RELIABLECHANNEL, pPacket)) - GfLogError("SendReadyToStartPacket : enet_peer_send failed\n"); + 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(); + m_packetsendtime = GfTimeClock(); - PackedBuffer msg; + PackedBuffer msg; - try - { - msg.pack_ubyte(SERVER_TIME_REQUEST_PACKET); - } - catch (PackedBufferException &e) - { - GfLogFatal("SendServerTimeRequest: packed buffer error\n"); - } - GfLogTrace("SendServerTimeRequest: packed data length=%d\n", - msg.length()); + try + { + msg.pack_ubyte(SERVER_TIME_REQUEST_PACKET); + } + catch (PackedBufferException &e) + { + 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); + 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"); + if (enet_peer_send (m_pServer, UNRELIABLECHANNEL, pPacket)) + GfLogError("SendServerTimeRequest : enet_peer_send failed\n"); } double NetClient::WaitForRaceStart() { - while(!m_bBeginRace) - { - SDL_Delay(20); - } + while(!m_bBeginRace) + { + SDL_Delay(20); + } - return GfTimeClock()-m_racestarttime; + return GfTimeClock()-m_racestarttime; } void NetClient::ReadStartTimePacket(ENetPacket *pPacket) { - GfLogTrace("Recieved the start race Packet\n"); - //double time = GfTimeClock(); + GfLogTrace("Recieved the start race Packet\n"); + //double time = GfTimeClock(); - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadStartTimePacket: packed data length=%d\n", - msg.length()); + 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) - { - GfLogFatal("ReadStartTimePacket: packed buffer error\n"); - } + try + { + msg.unpack_ubyte(); + m_racestarttime = msg.unpack_double(); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadStartTimePacket: packed buffer error\n"); + } + + //Adjust start time based on client clock + m_racestarttime= m_racestarttime+m_servertimedifference; + m_bBeginRace = true; - //Adjust start time based on client clock - m_racestarttime= m_racestarttime+m_servertimedifference; - m_bBeginRace = true; - } void NetClient::ReadPlayerRejectedPacket(ENetPacket *pPacket) { - m_eClientAccepted = CLIENTREJECTED; - GfLogWarning ("Server rejected connection.\n"); + m_eClientAccepted = CLIENTREJECTED; + GfLogWarning ("Server rejected connection.\n"); } void NetClient::ReadPlayerAcceptedPacket(ENetPacket *pPacket) { - m_eClientAccepted = CLIENTACCEPTED; - GfLogTrace ("Server accepted connection.\n"); + m_eClientAccepted = CLIENTACCEPTED; + GfLogTrace ("Server accepted connection.\n"); } bool NetClient::listenHost(ENetHost * pHost) { - if (pHost == NULL) - return false; + if (pHost == NULL) + return false; - bool bHasPacket = false; + bool bHasPacket = false; - ENetEvent event; - - while (enet_host_service(pHost, & event, 0) > 0) + ENetEvent event; + + while (enet_host_service(pHost, & event, 0) > 0) { switch (event.type) { case ENET_EVENT_TYPE_CONNECT: - char hostName[256]; - enet_address_get_host_ip (&event.peer->address,hostName,256); + char hostName[256]; + enet_address_get_host_ip (&event.peer->address,hostName,256); GfLogTrace ("A new client connected from %s\n",hostName); @@ -478,362 +478,362 @@ bool NetClient::listenHost(ENetHost * pHost) // event.packet -> data, // event.peer -> data, // event.channelID); - ReadPacket(event); - bHasPacket = true; + ReadPacket(event); + bHasPacket = true; break; - + case ENET_EVENT_TYPE_DISCONNECT: - if(event.peer == m_pServer) - { - m_bConnected = false; - /* Reset the peer's client information. */ - GfLogTrace("Server disconnected\n"); - } - + if(event.peer == m_pServer) + { + m_bConnected = false; + /* Reset the peer's client information. */ + GfLogTrace("Server disconnected\n"); + } + event.peer -> data = NULL; - break; - - case ENET_EVENT_TYPE_NONE: - // Do nothing. - break; + break; + + case ENET_EVENT_TYPE_NONE: + // Do nothing. + break; } } - return bHasPacket; + return bHasPacket; } bool NetClient::listen() { - if (!m_bConnected) - return false; - - listenHost(m_pClient); - listenHost(m_pHost); + if (!m_bConnected) + return false; - return true; + listenHost(m_pClient); + listenHost(m_pHost); + + return true; } void NetClient::ReadPacket(ENetEvent event) { - ENetPacket *pPacket = event.packet; - assert(pPacket->dataLength>=1); - unsigned char packetId = pPacket->data[0]; - //unsigned char *pData = &pPacket->data[1]; - //int datasize = pPacket->dataLength-1; - - switch (packetId) - { - case RACEINFOCHANGE_PACKET: - ReadRaceSetupPacket(event.packet); - break; - case PREPARETORACE_PACKET: - ReadPrepareToRacePacket(event.packet); - break; - case RACESTARTTIME_PACKET: - ReadStartTimePacket(event.packet); - break; - case CARCONTROLS_PACKET: - ReadCarControlsPacket(event.packet); - break; - case FILE_PACKET: - ReadFilePacket(event.packet); - break; - case SERVER_TIME_SYNC_PACKET: - ReadTimePacket(event.packet); - break; - case WEATHERCHANGE_PACKET: - ReadWeatherPacket(event.packet); - break; - case CARSTATUS_PACKET: - ReadCarStatusPacket(event.packet); - break; - case LAPSTATUS_PACKET: - ReadLapStatusPacket(event.packet); - break; - case FINISHTIME_PACKET: - ReadFinishTimePacket(event.packet); - break; - case ALLDRIVERREADY_PACKET: - ReadAllDriverReadyPacket(event.packet); - break; - case PLAYERREJECTED_PACKET: - ReadPlayerRejectedPacket(event.packet); - break; - case PLAYERACCEPTED_PACKET: - ReadPlayerAcceptedPacket(event.packet); - break; - default: - assert(false); - GfLogDebug ("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); + ENetPacket *pPacket = event.packet; + assert(pPacket->dataLength>=1); + unsigned char packetId = pPacket->data[0]; + //unsigned char *pData = &pPacket->data[1]; + //int datasize = pPacket->dataLength-1; - } + switch (packetId) + { + case RACEINFOCHANGE_PACKET: + ReadRaceSetupPacket(event.packet); + break; + case PREPARETORACE_PACKET: + ReadPrepareToRacePacket(event.packet); + break; + case RACESTARTTIME_PACKET: + ReadStartTimePacket(event.packet); + break; + case CARCONTROLS_PACKET: + ReadCarControlsPacket(event.packet); + break; + case FILE_PACKET: + ReadFilePacket(event.packet); + break; + case SERVER_TIME_SYNC_PACKET: + ReadTimePacket(event.packet); + break; + case WEATHERCHANGE_PACKET: + ReadWeatherPacket(event.packet); + break; + case CARSTATUS_PACKET: + ReadCarStatusPacket(event.packet); + break; + case LAPSTATUS_PACKET: + ReadLapStatusPacket(event.packet); + break; + case FINISHTIME_PACKET: + ReadFinishTimePacket(event.packet); + break; + case ALLDRIVERREADY_PACKET: + ReadAllDriverReadyPacket(event.packet); + break; + case PLAYERREJECTED_PACKET: + ReadPlayerRejectedPacket(event.packet); + break; + case PLAYERACCEPTED_PACKET: + ReadPlayerAcceptedPacket(event.packet); + break; + default: + assert(false); + GfLogDebug ("A packet of length %u containing %s was received from %s on channel %u.\n", + event.packet -> dataLength, + event.packet -> data, + (char*)event.peer -> data, + event.channelID); + + } enet_packet_destroy (event.packet); } void NetClient::ReadPrepareToRacePacket(ENetPacket *pPacket) { - GfLogTrace("Recieved the start race Packet\n"); + GfLogTrace("Recieved the start race Packet\n"); - //unsigned char packetId = pPacket->data[0]; - - + //unsigned char packetId = pPacket->data[0]; - m_bPrepareToRace = true; + + + m_bPrepareToRace = true; } void NetClient::ReadRaceSetupPacket(ENetPacket *pPacket) { - GfLogTrace("\nRecieving race setup\n"); + GfLogTrace("\nRecieving race setup\n"); - SetRaceInfoChanged(true); + SetRaceInfoChanged(true); } void NetClient::ConnectToDriver(NetDriver driver) { - char hostName[256]; - enet_address_get_host_ip (&driver.address,hostName,256); + char hostName[256]; + enet_address_get_host_ip (&driver.address,hostName,256); - if (!driver.client) - { - GfLogTrace("Skipping server: %s Address: %s\n",driver.name,hostName); - return; - } - - if (strcmp(driver.name,GetDriverName())==0) - { - GfLogTrace("Skipping ourself: %s Address: %s\n",driver.name,hostName); - return; - } - - ENetPeer * pCurrentPeer; - - for (pCurrentPeer = m_pClient-> peers; - pCurrentPeer < & m_pClient->peers [m_pClient->peerCount]; - ++ pCurrentPeer) - { - if (pCurrentPeer->state == ENET_PEER_STATE_CONNECTED) - { - if ((pCurrentPeer->address.host == driver.address.host)&& - (pCurrentPeer->address.port == driver.address.port)) - { - GfLogTrace("Already connected to driver: %s Address: %s\n",driver.name,hostName); - return; - } - } - - } - - GfLogTrace("connecting to driver: %s Address: %s\n",driver.name,hostName); - - //Connect to peer player - //ENetPeer *pPeer = enet_host_connect (m_pClient, &driver.address, 2); - - - - ENetEvent event; - - if (enet_host_service (m_pClient, & event, 5000) > 0 && - event.type == ENET_EVENT_TYPE_CONNECT) + if (!driver.client) { - GfLogTrace("Successfully connected to peer\n"); - return; + GfLogTrace("Skipping server: %s Address: %s\n",driver.name,hostName); + return; + } + + if (strcmp(driver.name,GetDriverName())==0) + { + GfLogTrace("Skipping ourself: %s Address: %s\n",driver.name,hostName); + return; + } + + ENetPeer * pCurrentPeer; + + for (pCurrentPeer = m_pClient-> peers; + pCurrentPeer < & m_pClient->peers [m_pClient->peerCount]; + ++ pCurrentPeer) + { + if (pCurrentPeer->state == ENET_PEER_STATE_CONNECTED) + { + if ((pCurrentPeer->address.host == driver.address.host)&& + (pCurrentPeer->address.port == driver.address.port)) + { + GfLogTrace("Already connected to driver: %s Address: %s\n",driver.name,hostName); + return; + } + } + + } + + GfLogTrace("connecting to driver: %s Address: %s\n",driver.name,hostName); + + //Connect to peer player + //ENetPeer *pPeer = enet_host_connect (m_pClient, &driver.address, 2); + + + + ENetEvent event; + + if (enet_host_service (m_pClient, & event, 5000) > 0 && + event.type == ENET_EVENT_TYPE_CONNECT) + { + GfLogTrace("Successfully connected to peer\n"); + return; } else { - GfLogWarning("Failed to connect to peer!\n"); - return; + GfLogWarning("Failed to connect to peer!\n"); + return; } } void NetClient::ReadWeatherPacket(ENetPacket *pPacket) { - //TODO Xavier read in weather data + //TODO Xavier read in weather data } void NetClient::ReadAllDriverReadyPacket(ENetPacket *pPacket) { - int rsize; + int rsize; - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadAllDriverReadyPacket: packed data length=%d\n", - msg.length()); + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadAllDriverReadyPacket: packed data length=%d\n", + msg.length()); - try - { - msg.unpack_ubyte(); - rsize = msg.unpack_int(); + try + { + msg.unpack_ubyte(); + rsize = msg.unpack_int(); - NetMutexData *pNData = LockNetworkData(); - pNData->m_vecReadyStatus.clear(); - pNData->m_vecReadyStatus.resize(rsize); - for (int i=0;im_vecReadyStatus[i] = msg.unpack_int() ? true : false; + NetMutexData *pNData = LockNetworkData(); + pNData->m_vecReadyStatus.clear(); + pNData->m_vecReadyStatus.resize(rsize); + for (int i=0;im_vecReadyStatus[i] = msg.unpack_int() ? true : false; - UnlockNetworkData(); - SetRaceInfoChanged(true); - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadAllDriverReadyPacket: packed buffer error\n"); - } + UnlockNetworkData(); + SetRaceInfoChanged(true); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadAllDriverReadyPacket: packed buffer error\n"); + } - GfLogTrace("Recieved All Driver Ready Packet\n"); + GfLogTrace("Recieved All Driver Ready Packet\n"); } void NetClient::ReadFinishTimePacket(ENetPacket *pPacket) { - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadFinishTimePacket: packed data length=%d\n", - msg.length()); - - try - { - msg.unpack_ubyte(); + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadFinishTimePacket: packed data length=%d\n", + msg.length()); - NetMutexData *pNData = LockNetworkData(); - pNData->m_finishTime = msg.unpack_double(); - UnlockNetworkData(); - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadFinishTimePacket: packed buffer error\n"); - } + try + { + msg.unpack_ubyte(); - GfOut("Recieved finish time packet\n"); + NetMutexData *pNData = LockNetworkData(); + pNData->m_finishTime = msg.unpack_double(); + UnlockNetworkData(); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadFinishTimePacket: packed buffer error\n"); + } + + GfOut("Recieved finish time packet\n"); } 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 curTime = GfTimeClock(); + m_lag = (curTime-m_packetsendtime)/2.0; + GfLogTrace ("Connection lag is %lf seconds\n",m_lag); - double time = 0; + double time = 0; - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadTimePacket: packed data length=%d\n", - msg.length()); + 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) - { - GfLogFatal("ReadTimePacket: packed buffer error\n"); - } + try + { + msg.unpack_ubyte(); + time = msg.unpack_double(); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadTimePacket: packed buffer error\n"); + } - m_servertimedifference = curTime-time; - m_bTimeSynced = true; + m_servertimedifference = curTime-time; + m_bTimeSynced = true; } void NetClient::ReadFilePacket(ENetPacket *pPacket) { - short len; - size_t writeSize; - char file[255]; - unsigned int filesize = 0; - char *filedata = 0; + short len; + size_t writeSize; + char file[255]; + unsigned int filesize = 0; + char *filedata = 0; - memset(file, 0, sizeof file); + memset(file, 0, sizeof file); - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadFilePacket: packed data length=%d\n", - msg.length()); + 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(); + 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]; + GfLogTrace("Client file size %u\n",filesize); + filedata = new char[filesize]; - msg.unpack_string(filedata, filesize); - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadFilePacket: packed buffer error\n"); - } - - char filepath[255]; - snprintf(filepath, sizeof filepath, "%s%s", GfLocalDir(), file); + msg.unpack_string(filedata, filesize); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadFilePacket: packed buffer error\n"); + } - FILE *pFile = fopen(filepath,"w+b"); - GfLogTrace("Reading file packet: File- %s\n",filepath); + char filepath[255]; + snprintf(filepath, sizeof filepath, "%s%s", GfLocalDir(), file); - if (filedata && filesize > 0) - { - writeSize = fwrite(filedata, filesize, 1, pFile); - if( writeSize <= 0 ) - GfLogTrace("Not all bytes are send to file"); - } - fclose(pFile); + FILE *pFile = fopen(filepath,"w+b"); + GfLogTrace("Reading file packet: File- %s\n",filepath); - delete [] filedata; + 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; } void NetClient::BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel) { - ENetPacket * pHostPacket = enet_packet_create (pPacket->data, - pPacket->dataLength, - pPacket->flags); + ENetPacket * pHostPacket = enet_packet_create (pPacket->data, + pPacket->dataLength, + pPacket->flags); - //Send to connected clients - enet_host_broadcast (m_pHost, channel, pPacket); + //Send to connected clients + enet_host_broadcast (m_pHost, channel, pPacket); - //Send to server - enet_peer_send (m_pServer, channel, pHostPacket); + //Send to server + enet_peer_send (m_pServer, channel, pHostPacket); - m_activeNetworkTime = GfTimeClock(); + m_activeNetworkTime = GfTimeClock(); } void NetClient::SetCarInfo(const char *pszName) { - std::vector vecDrivers; + std::vector vecDrivers; - RobotXml robotxml; - robotxml.ReadRobotDrivers(NETWORKROBOT,vecDrivers); + RobotXml robotxml; + robotxml.ReadRobotDrivers(NETWORKROBOT,vecDrivers); - for (unsigned int i=0;i vecDrivers; + std::vector vecDrivers; - RobotXml robotxml; - robotxml.ReadRobotDrivers(NETWORKROBOT,vecDrivers); + RobotXml robotxml; + robotxml.ReadRobotDrivers(NETWORKROBOT,vecDrivers); - for(unsigned int i=0;i_ncars; i++) - { - tCarElt *pCar = s->cars[i]; - m_mapRanks[i] = pCar->info.startRank; - } - - m_NetworkData.Init(); + + m_mapRanks.clear(); + for (int i = 0; i < s->_ncars; i++) + { + tCarElt *pCar = s->cars[i]; + m_mapRanks[i] = pCar->info.startRank; + } + + m_NetworkData.Init(); } void NetNetwork::RaceDone() { - m_bRaceActive = false; - m_bBeginRace = false; - m_bPrepareToRace = false; - m_bRaceInfoChanged = false; - m_bTimeSynced = false; - m_sendCtrlTime = 0.0; - m_sendCarDataTime = 0.0; - m_timePhysics = -2.0; + m_bRaceActive = false; + m_bBeginRace = false; + m_bPrepareToRace = false; + m_bRaceInfoChanged = false; + m_bTimeSynced = false; + m_sendCtrlTime = 0.0; + m_sendCarDataTime = 0.0; + m_timePhysics = -2.0; - m_mapRanks.clear(); + m_mapRanks.clear(); } int NetNetwork::GetDriverStartRank(int idx) { - std::map::iterator p; - p = m_mapRanks.find(idx); + std::map::iterator p; + p = m_mapRanks.find(idx); - return p->second; + return p->second; } //============================================================ NetDriver::NetDriver() { - //Initialize values - idx = -1; - memset(name,0,sizeof(name)); - memset(car,0,sizeof(car)); - memset(team,0,sizeof(team)); - memset(author,0,sizeof(author)); - racenumber = 1; - memset(skilllevel,0,sizeof(skilllevel)); - red = 1.0; - green = 1.0; - blue = 1.0; - hostPort = 0; - client = false; - memset(module,0,sizeof(module)); - memset(type,0,sizeof(type)); + //Initialize values + idx = -1; + memset(name,0,sizeof(name)); + memset(car,0,sizeof(car)); + memset(team,0,sizeof(team)); + memset(author,0,sizeof(author)); + racenumber = 1; + memset(skilllevel,0,sizeof(skilllevel)); + red = 1.0; + green = 1.0; + blue = 1.0; + hostPort = 0; + client = false; + memset(module,0,sizeof(module)); + memset(type,0,sizeof(type)); } bool NetworkInit(); NetNetwork *NetGetNetwork() { - if (!g_bInit) - NetworkInit(); + if (!g_bInit) + NetworkInit(); - if (g_bServer) - return &g_server; + if (g_bServer) + return &g_server; - if (g_bClient) - return &g_client; + if (g_bClient) + return &g_client; - return NULL; + return NULL; } int NetNetwork::GetCarIndex(int startRank,tSituation *s) { - for (int i=0;i_ncars;i++) - { - if (startRank == s->cars[i]->info.startRank) - return i; - } + for (int i=0;i_ncars;i++) + { + if (startRank == s->cars[i]->info.startRank) + return i; + } - assert(false); - return -1; + assert(false); + return -1; } bool NetNetwork::IsServerMode() { - if (m_strClass == (char*)"server") - return true; + if (m_strClass == (char*)"server") + return true; - return false; + return false; } void NetNetwork::SetRefreshDisplay(bool bStatus) { - m_bRefreshDisplay = bStatus; - if (!bStatus) - GfLogDebug("refreshdisplay false\n"); + m_bRefreshDisplay = bStatus; + if (!bStatus) + GfLogDebug("refreshdisplay false\n"); } void NetNetwork::SetRaceInfoChanged(bool bStatus) { - m_bRaceInfoChanged = bStatus; - if (bStatus) - m_bRefreshDisplay = true; + m_bRaceInfoChanged = bStatus; + if (bStatus) + m_bRefreshDisplay = true; - if (!bStatus) - GfLogDebug("raceinfo false\n"); + if (!bStatus) + GfLogDebug("raceinfo false\n"); } bool NetNetwork::IsClientMode() { - if (m_strClass == "client") - return true; + if (m_strClass == "client") + return true; - return false; + return false; } // Get the index of the local network-human driver in the networkhuman interface list int NetNetwork::GetNetworkHumanIdx() { - assert(m_strDriverName!=""); - int idx = 1; + assert(m_strDriverName!=""); + int idx = 1; - char buf[255]; - sprintf(buf,"drivers/networkhuman/networkhuman.xml"); - void *params = GfParmReadFileLocal(buf,GFPARM_RMODE_REREAD); - assert(params); - char path2[256]; + char buf[255]; + sprintf(buf,"drivers/networkhuman/networkhuman.xml"); + void *params = GfParmReadFileLocal(buf,GFPARM_RMODE_REREAD); + assert(params); + char path2[256]; - int i=0; - const char *pName; - do - { - i++; - sprintf(path2, "Robots/index/%d",i); - pName = GfParmGetStr(params, path2, "name",NULL); - if (pName && strcmp(m_strDriverName.c_str(),pName)==0) - { - idx = i; - break; - } - } - while(pName); - - GfParmReleaseHandle(params); + int i=0; + const char *pName; + do + { + i++; + sprintf(path2, "Robots/index/%d",i); + pName = GfParmGetStr(params, path2, "name",NULL); + if (pName && strcmp(m_strDriverName.c_str(),pName)==0) + { + idx = i; + break; + } + } + while(pName); - return idx; + GfParmReleaseHandle(params); + + return idx; } void NetNetwork::SetRaceXMLFile(char const*pXmlFile) { - m_strRaceXMLFile=pXmlFile; + m_strRaceXMLFile=pXmlFile; } int NetNetwork::GetPlayerCarIndex(tSituation *s) { - int i=0; - while (s->cars[i]->info.startRank != (m_driverIdx-1)) - i++; + int i=0; + while (s->cars[i]->info.startRank != (m_driverIdx-1)) + i++; - return i; + return i; } void NetNetwork::ClearLocalDrivers() { - m_setLocalDrivers.clear(); + m_setLocalDrivers.clear(); } void NetNetwork::SetDriverName(char *pName) { - m_strDriverName = pName; - GfLogInfo("Setting network driver name: %s\n", pName); + m_strDriverName = pName; + GfLogInfo("Setting network driver name: %s\n", pName); } const char *NetNetwork::GetDriverName() { - return m_strDriverName.c_str(); + return m_strDriverName.c_str(); } void NetNetwork::SetLocalDrivers() @@ -325,29 +325,29 @@ void NetNetwork::SetCarInfo(const char *pszName) bool NetNetwork::FinishRace(double time) { - NetMutexData *pNData = LockNetworkData(); - double finishTime = pNData->m_finishTime; - UnlockNetworkData(); + NetMutexData *pNData = LockNetworkData(); + double finishTime = pNData->m_finishTime; + UnlockNetworkData(); - if (finishTime<=0.0) - return false; + if (finishTime<=0.0) + return false; - if (timerace.bestLapTime); - msg.pack_double(*pCar->race.bestSplitTime); - msg.pack_int(pCar->race.laps); - msg.pack_int(pCar->info.startRank); - } - catch (PackedBufferException &e) - { - GfLogFatal("SendLapStatusPacket: packed buffer error\n"); - } - GfLogTrace("SendLapStatusPacket: packed data length=%d\n", - msg.length()); + try + { + msg.pack_ubyte(LAPSTATUS_PACKET); + msg.pack_double(pCar->race.bestLapTime); + msg.pack_double(*pCar->race.bestSplitTime); + msg.pack_int(pCar->race.laps); + msg.pack_int(pCar->info.startRank); + } + catch (PackedBufferException &e) + { + GfLogFatal("SendLapStatusPacket: packed buffer error\n"); + } + GfLogTrace("SendLapStatusPacket: packed data length=%d\n", + msg.length()); - ENetPacket *pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); + ENetPacket *pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - BroadcastPacket(pPacket,RELIABLECHANNEL); + BroadcastPacket(pPacket,RELIABLECHANNEL); } void NetNetwork::SendCarStatusPacket(tSituation *s,bool bForce) { - if (s->currentTime<0.0) - return; + if (s->currentTime<0.0) + return; - //Clock error fix it - if (s->currentTimecurrentTime-CAR_DATA_UPDATE; - } + //Clock error fix it + if (s->currentTimecurrentTime-CAR_DATA_UPDATE; + } - //Send carinfo packet when enough time has passed(CAR_DATA_UPDATE) - if (((m_sendCarDataTime+CAR_DATA_UPDATE)>s->currentTime)&&(!bForce)) - { - return; - } + //Send carinfo packet when enough time has passed(CAR_DATA_UPDATE) + if (((m_sendCarDataTime+CAR_DATA_UPDATE)>s->currentTime)&&(!bForce)) + { + return; + } - std::vector local; - double time = 0.0; + std::vector local; + double time = 0.0; - //Pack controls values to reduce data size of packet - for (int i = 0; i < s->_ncars; i++) - { - tCarElt *pCar = s->cars[i]; - //Only transmit local drivers to other clients - if (m_setLocalDrivers.find(pCar->info.startRank)!=m_setLocalDrivers.end()) - { - local.push_back(pCar); - } - - } - - time = s->currentTime; - m_sendCarDataTime = s->currentTime; - - - int iNumCars = local.size(); - - PackedBuffer msg; - - try + //Pack controls values to reduce data size of packet + for (int i = 0; i < s->_ncars; i++) + { + tCarElt *pCar = s->cars[i]; + //Only transmit local drivers to other clients + if (m_setLocalDrivers.find(pCar->info.startRank)!=m_setLocalDrivers.end()) { - msg.pack_ubyte(CARSTATUS_PACKET); - msg.pack_double(time); - msg.pack_int(iNumCars); - for (int i=0;iinfo.name, local[i]->info.startRank); - msg.pack_float(local[i]->race.topSpeed); - msg.pack_int(local[i]->pub.state); - msg.pack_int(local[i]->info.startRank); - msg.pack_int(local[i]->priv.dammage); - msg.pack_float(local[i]->priv.fuel); - } + local.push_back(pCar); } - catch (PackedBufferException &e) + + } + + time = s->currentTime; + m_sendCarDataTime = s->currentTime; + + + int iNumCars = local.size(); + + PackedBuffer msg; + + try + { + msg.pack_ubyte(CARSTATUS_PACKET); + msg.pack_double(time); + msg.pack_int(iNumCars); + for (int i=0;iinfo.name, local[i]->info.startRank); + msg.pack_float(local[i]->race.topSpeed); + msg.pack_int(local[i]->pub.state); + msg.pack_int(local[i]->info.startRank); + msg.pack_int(local[i]->priv.dammage); + msg.pack_float(local[i]->priv.fuel); } - GfLogTrace("SendCarStatusPacket: packed data length=%d\n", - msg.length()); + } + catch (PackedBufferException &e) + { + GfLogFatal("SendCarStatusPacket: packed buffer error\n"); + } + GfLogTrace("SendCarStatusPacket: packed data length=%d\n", + msg.length()); - ENetPacket * pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); + + BroadcastPacket(pPacket,RELIABLECHANNEL); - BroadcastPacket(pPacket,RELIABLECHANNEL); - } void NetNetwork::SendCarControlsPacket(tSituation *s) { - if (s->currentTime<0.0) - return; + if (s->currentTime<0.0) + return; - //Clock error fix it - if (s->currentTimecurrentTime-CAR_CONTROL_UPDATE; - } + //Clock error fix it + if (s->currentTimecurrentTime-CAR_CONTROL_UPDATE; + } - SendCarStatusPacket(s,false); + SendCarStatusPacket(s,false); - //Send carinfo packet when enough time has passed(CAR_CONTROL_UPDATE) - if ((m_sendCtrlTime+CAR_CONTROL_UPDATE)>s->currentTime) - { - return; - } + //Send carinfo packet when enough time has passed(CAR_CONTROL_UPDATE) + if ((m_sendCtrlTime+CAR_CONTROL_UPDATE)>s->currentTime) + { + return; + } - std::vector local; - double time = 0.0; + std::vector local; + double time = 0.0; - //Pack controls values to reduce data size of packet - for (int i = 0; i < s->raceInfo.ncars; i++) - { - tCarElt *pCar = s->cars[i]; - //Only transmit local drivers to other clients - if (m_setLocalDrivers.find(pCar->info.startRank)!=m_setLocalDrivers.end()) - { - local.push_back(pCar); - } - - } - time = s->currentTime; - - m_sendCtrlTime = s->currentTime; - - int iNumCars = local.size(); - - PackedBuffer msg; - - try + //Pack controls values to reduce data size of packet + for (int i = 0; i < s->raceInfo.ncars; i++) + { + tCarElt *pCar = s->cars[i]; + //Only transmit local drivers to other clients + if (m_setLocalDrivers.find(pCar->info.startRank)!=m_setLocalDrivers.end()) { - msg.pack_ubyte(CARCONTROLS_PACKET); - msg.pack_double(time); - msg.pack_int(iNumCars); - for (int i = 0; i < iNumCars; i++) - { - msg.pack_int(local[i]->ctrl.gear); - msg.pack_float(local[i]->ctrl.brakeCmd); - msg.pack_float(local[i]->ctrl.steer); - msg.pack_float(local[i]->ctrl.accelCmd); - msg.pack_float(local[i]->ctrl.clutchCmd); - msg.pack_int(local[i]->info.startRank); - msg.pack_float(local[i]->pub.DynGCg.pos.x); - msg.pack_float(local[i]->pub.DynGCg.pos.y); - msg.pack_float(local[i]->pub.DynGCg.pos.z); - msg.pack_float(local[i]->pub.DynGCg.pos.xy); - msg.pack_float(local[i]->pub.DynGCg.pos.ax); - msg.pack_float(local[i]->pub.DynGCg.pos.ay); - msg.pack_float(local[i]->pub.DynGCg.pos.az); - msg.pack_float(local[i]->pub.DynGCg.vel.x); - msg.pack_float(local[i]->pub.DynGCg.vel.y); - msg.pack_float(local[i]->pub.DynGCg.vel.z); - msg.pack_float(local[i]->pub.DynGCg.vel.xy); - msg.pack_float(local[i]->pub.DynGCg.vel.ax); - msg.pack_float(local[i]->pub.DynGCg.vel.ay); - msg.pack_float(local[i]->pub.DynGCg.vel.az); - msg.pack_float(local[i]->pub.DynGCg.acc.x); - msg.pack_float(local[i]->pub.DynGCg.acc.y); - msg.pack_float(local[i]->pub.DynGCg.acc.z); - msg.pack_float(local[i]->pub.DynGCg.acc.xy); - msg.pack_float(local[i]->pub.DynGCg.acc.ax); - msg.pack_float(local[i]->pub.DynGCg.acc.ay); - msg.pack_float(local[i]->pub.DynGCg.acc.az); - } + local.push_back(pCar); } - catch (PackedBufferException &e) + + } + time = s->currentTime; + + m_sendCtrlTime = s->currentTime; + + int iNumCars = local.size(); + + PackedBuffer msg; + + try + { + msg.pack_ubyte(CARCONTROLS_PACKET); + msg.pack_double(time); + msg.pack_int(iNumCars); + for (int i = 0; i < iNumCars; i++) { - GfLogFatal("SendCarControlsPacket: packed buffer error\n"); + msg.pack_int(local[i]->ctrl.gear); + msg.pack_float(local[i]->ctrl.brakeCmd); + msg.pack_float(local[i]->ctrl.steer); + msg.pack_float(local[i]->ctrl.accelCmd); + msg.pack_float(local[i]->ctrl.clutchCmd); + msg.pack_int(local[i]->info.startRank); + msg.pack_float(local[i]->pub.DynGCg.pos.x); + msg.pack_float(local[i]->pub.DynGCg.pos.y); + msg.pack_float(local[i]->pub.DynGCg.pos.z); + msg.pack_float(local[i]->pub.DynGCg.pos.xy); + msg.pack_float(local[i]->pub.DynGCg.pos.ax); + msg.pack_float(local[i]->pub.DynGCg.pos.ay); + msg.pack_float(local[i]->pub.DynGCg.pos.az); + msg.pack_float(local[i]->pub.DynGCg.vel.x); + msg.pack_float(local[i]->pub.DynGCg.vel.y); + msg.pack_float(local[i]->pub.DynGCg.vel.z); + msg.pack_float(local[i]->pub.DynGCg.vel.xy); + msg.pack_float(local[i]->pub.DynGCg.vel.ax); + msg.pack_float(local[i]->pub.DynGCg.vel.ay); + msg.pack_float(local[i]->pub.DynGCg.vel.az); + msg.pack_float(local[i]->pub.DynGCg.acc.x); + msg.pack_float(local[i]->pub.DynGCg.acc.y); + msg.pack_float(local[i]->pub.DynGCg.acc.z); + msg.pack_float(local[i]->pub.DynGCg.acc.xy); + msg.pack_float(local[i]->pub.DynGCg.acc.ax); + msg.pack_float(local[i]->pub.DynGCg.acc.ay); + msg.pack_float(local[i]->pub.DynGCg.acc.az); } - GfLogTrace("SendCarControlsPacket: packed data length=%d\n", - msg.length()); + } + catch (PackedBufferException &e) + { + GfLogFatal("SendCarControlsPacket: packed buffer error\n"); + } + GfLogTrace("SendCarControlsPacket: packed data length=%d\n", + msg.length()); - ENetPacket * pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_UNSEQUENCED); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_UNSEQUENCED); - BroadcastPacket(pPacket,UNRELIABLECHANNEL); + BroadcastPacket(pPacket,UNRELIABLECHANNEL); } void NetNetwork::ReadLapStatusPacket(ENetPacket *pPacket) { - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadLapStatusPacket: packed data length=%d\n", - msg.length()); - - LapStatus lstatus; + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadLapStatusPacket: packed data length=%d\n", + msg.length()); - try - { - msg.unpack_ubyte(); - lstatus.bestLapTime = msg.unpack_double(); - lstatus.bestSplitTime = msg.unpack_double(); - lstatus.laps = msg.unpack_int(); - lstatus.startRank = msg.unpack_int(); - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadLapStatusPacket: packed buffer error\n"); - } - - NetMutexData *pNData = LockNetworkData(); - bool bFound = false; - for (unsigned int i=0;im_vecLapStatus.size();i++) - { - if (pNData->m_vecLapStatus[i].startRank == lstatus.startRank) - { - bFound = true; - pNData->m_vecLapStatus[i] = lstatus; - } - } + LapStatus lstatus; - if (!bFound) - pNData->m_vecLapStatus.push_back(lstatus); - - UnlockNetworkData(); + try + { + msg.unpack_ubyte(); + lstatus.bestLapTime = msg.unpack_double(); + lstatus.bestSplitTime = msg.unpack_double(); + lstatus.laps = msg.unpack_int(); + lstatus.startRank = msg.unpack_int(); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadLapStatusPacket: packed buffer error\n"); + } + + NetMutexData *pNData = LockNetworkData(); + bool bFound = false; + for (unsigned int i=0;im_vecLapStatus.size();i++) + { + if (pNData->m_vecLapStatus[i].startRank == lstatus.startRank) + { + bFound = true; + pNData->m_vecLapStatus[i] = lstatus; + } + } + + if (!bFound) + pNData->m_vecLapStatus.push_back(lstatus); + + UnlockNetworkData(); } void NetNetwork::ReadCarStatusPacket(ENetPacket *pPacket) { - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadCarStatusPacket: packed data length=%d\n", - msg.length()); - - double packettime; - int iNumCars; + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadCarStatusPacket: packed data length=%d\n", + msg.length()); - try + double packettime; + int iNumCars; + + try + { + msg.unpack_ubyte(); + packettime = msg.unpack_double(); + iNumCars = msg.unpack_int(); + + NetMutexData *pNData = LockNetworkData(); + + //Car conrols values (steering,brake,gas,and etc + for (int i=0;im_vecCarStatus.size();i++) + { + if (pNData->m_vecCarStatus[i].startRank == status.startRank) { - CarStatus status; - - status.topSpeed = msg.unpack_float(); - status.state = msg.unpack_int(); - status.startRank = msg.unpack_int(); - status.dammage = msg.unpack_int(); - status.fuel = msg.unpack_float(); - - status.time = packettime; - - bool bFound = false; - for (unsigned int i=0;im_vecCarStatus.size();i++) - { - if (pNData->m_vecCarStatus[i].startRank == status.startRank) - { - bFound = true; - //Only use the data if the time is newer. Prevent out of order packet - if (pNData->m_vecCarStatus[i].time < status.time) - { - pNData->m_vecCarStatus[i] = status; - } - else - { - GfLogTrace("Rejected car status from startRank %i\n",status.startRank); - } - GfLogTrace("Recieved car status from startRank %i\n",status.startRank); - break; - } - } - - if (!bFound) - pNData->m_vecCarStatus.push_back(status); + bFound = true; + //Only use the data if the time is newer. Prevent out of order packet + if (pNData->m_vecCarStatus[i].time < status.time) + { + pNData->m_vecCarStatus[i] = status; + } + else + { + GfLogTrace("Rejected car status from startRank %i\n",status.startRank); + } + GfLogTrace("Recieved car status from startRank %i\n",status.startRank); + break; } + } - UnlockNetworkData(); - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadCarStatusPacket: packed buffer error\n"); + if (!bFound) + pNData->m_vecCarStatus.push_back(status); } + + UnlockNetworkData(); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadCarStatusPacket: packed buffer error\n"); + } } void NetNetwork::GetHostSettings(std::string &strCarCat,bool &bCollisions) { - assert(m_strRaceXMLFile!=""); + assert(m_strRaceXMLFile!=""); - void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); - assert(params); + void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); + assert(params); - strCarCat = GfParmGetStr(params, RM_SECT_HEADER,RM_ATTR_CAR_CATEGORY,"All"); - - //TODO - bCollisions = true; + strCarCat = GfParmGetStr(params, RM_SECT_HEADER,RM_ATTR_CAR_CATEGORY,"All"); + + //TODO + bCollisions = true; } void NetNetwork::ReadCarControlsPacket(ENetPacket *pPacket) { - PackedBuffer msg(pPacket->data, pPacket->dataLength); - GfLogTrace("ReadCarControlsPacket: packed data length=%d\n", - msg.length()); + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadCarControlsPacket: packed data length=%d\n", + msg.length()); - double packettime; - int iNumCars; + double packettime; + int iNumCars; - try + try + { + msg.unpack_ubyte(); + packettime = msg.unpack_double(); + iNumCars = msg.unpack_int(); + + NetMutexData *pNData = LockNetworkData(); + + //Car conrols values (steering,brake,gas,and etc + for (int i=0;im_vecCarCtrls.size();i++) + { + if (pNData->m_vecCarCtrls[i].startRank == ctrl.startRank) { - CarControlsData ctrl; - - ctrl.gear = msg.unpack_int(); - ctrl.brake = msg.unpack_float(); - ctrl.steering = msg.unpack_float(); - ctrl.throttle = msg.unpack_float(); - ctrl.clutch = msg.unpack_float(); - ctrl.startRank = msg.unpack_int(); - ctrl.DynGCg.pos.x = msg.unpack_float(); - ctrl.DynGCg.pos.y = msg.unpack_float(); - ctrl.DynGCg.pos.z = msg.unpack_float(); - ctrl.DynGCg.pos.xy = msg.unpack_float(); - ctrl.DynGCg.pos.ax = msg.unpack_float(); - ctrl.DynGCg.pos.ay = msg.unpack_float(); - ctrl.DynGCg.pos.az = msg.unpack_float(); - ctrl.DynGCg.vel.x = msg.unpack_float(); - ctrl.DynGCg.vel.y = msg.unpack_float(); - ctrl.DynGCg.vel.z = msg.unpack_float(); - ctrl.DynGCg.vel.xy = msg.unpack_float(); - ctrl.DynGCg.vel.ax = msg.unpack_float(); - ctrl.DynGCg.vel.ay = msg.unpack_float(); - ctrl.DynGCg.vel.az = msg.unpack_float(); - ctrl.DynGCg.acc.x = msg.unpack_float(); - ctrl.DynGCg.acc.y = msg.unpack_float(); - ctrl.DynGCg.acc.z = msg.unpack_float(); - ctrl.DynGCg.acc.xy = msg.unpack_float(); - ctrl.DynGCg.acc.ax = msg.unpack_float(); - ctrl.DynGCg.acc.ay = msg.unpack_float(); - ctrl.DynGCg.acc.az = msg.unpack_float(); - - ctrl.time = packettime; - - bool bFound = false; - for (unsigned int i=0;im_vecCarCtrls.size();i++) - { - if (pNData->m_vecCarCtrls[i].startRank == ctrl.startRank) - { - bFound = true; - //Only use the data if the time is newer. Prevent out of order packet - if (pNData->m_vecCarCtrls[i].time < ctrl.time) - { - pNData->m_vecCarCtrls[i] = ctrl; - } - else - { - GfLogTrace("Rejected car control from startRank %i\n",ctrl.startRank); - } - } - } - - if (!bFound) - pNData->m_vecCarCtrls.push_back(ctrl); + bFound = true; + //Only use the data if the time is newer. Prevent out of order packet + if (pNData->m_vecCarCtrls[i].time < ctrl.time) + { + pNData->m_vecCarCtrls[i] = ctrl; + } + else + { + GfLogTrace("Rejected car control from startRank %i\n",ctrl.startRank); + } } + } - UnlockNetworkData(); - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadCarControlsPacket: packed buffer error\n"); + if (!bFound) + pNData->m_vecCarCtrls.push_back(ctrl); } + + UnlockNetworkData(); + } + catch (PackedBufferException &e) + { + GfLogFatal("ReadCarControlsPacket: packed buffer error\n"); + } } //========================================================== Uint32 network_callbackfunc(Uint32 interval, void *param) { - if (NetGetNetwork()) - NetGetNetwork()->listen(); - - return interval; + if (NetGetNetwork()) + NetGetNetwork()->listen(); + + return interval; } bool NetworkInit() { - g_bInit = true; + g_bInit = true; - return true; + return true; } bool RemoveNetworkTimer() { - return SDL_RemoveTimer(g_timerId) == SDL_TRUE ? true : false; + return SDL_RemoveTimer(g_timerId) == SDL_TRUE ? true : false; } bool AddNetworkTimer() { - //Create a timer callback to listen to the network - g_timerId = SDL_AddTimer(40, network_callbackfunc,0); + //Create a timer callback to listen to the network + g_timerId = SDL_AddTimer(40, network_callbackfunc,0); - return true; + return true; } NetServer *NetGetServer() { - if (!g_bServer) - return NULL; - - return &g_server; + if (!g_bServer) + return NULL; + + return &g_server; } NetClient *NetGetClient() { - if (!g_bClient) - return NULL; + if (!g_bClient) + return NULL; - return &g_client; + return &g_client; } void NetSetServer(bool bStatus) { - if (bStatus == g_bServer) - return; + if (bStatus == g_bServer) + return; - g_bServer = bStatus; - if (g_bServer) - AddNetworkTimer(); - else - RemoveNetworkTimer(); + g_bServer = bStatus; + if (g_bServer) + AddNetworkTimer(); + else + RemoveNetworkTimer(); } void NetSetClient(bool bStatus) { - if (bStatus == g_bClient) - return; + if (bStatus == g_bClient) + return; - g_bClient = bStatus; - if (g_bClient) - AddNetworkTimer(); - else - RemoveNetworkTimer(); + g_bClient = bStatus; + if (g_bClient) + AddNetworkTimer(); + else + RemoveNetworkTimer(); } bool NetIsServer() { - return g_bServer; + return g_bServer; } bool NetIsClient() { - return g_bClient; + return g_bClient; } void NetworkListen() { - if (NetGetNetwork()) - NetGetNetwork()->listen(); + if (NetGetNetwork()) + NetGetNetwork()->listen(); } bool AddressMatch(ENetAddress &a1,ENetAddress &a2) { - if ((a1.host == a2.host)&&(a1.port == a2.port)) - return true; + if ((a1.host == a2.host)&&(a1.port == a2.port)) + return true; - return false; + return false; }; // Never used : remove ? diff --git a/src/modules/networking/network.h b/src/modules/networking/network.h index 345dfd168..1a6bdcb96 100644 --- a/src/modules/networking/network.h +++ b/src/modules/networking/network.h @@ -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; - - 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; + 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; }; //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 m_vecCarCtrls; - std::vector m_vecCarStatus; - std::vector m_vecLapStatus; - std::vector m_vecReadyStatus; - double m_finishTime; + SDL_mutex *m_networkMutex; + std::vector m_vecCarCtrls; + std::vector m_vecCarStatus; + std::vector m_vecLapStatus; + std::vector 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 Lock(); - void Unlock(); - - SDL_mutex *m_networkMutex; - std::vector m_vecNetworkPlayers; + void Init(); + NetServerMutexData(); + virtual ~NetServerMutexData(); + + void Lock(); + void Unlock(); + + SDL_mutex *m_networkMutex; + std::vector 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 bool listen(){ return false;}; + virtual void RaceInit(tSituation *s); + virtual void RaceDone(); + int GetDriverStartRank(int idx); - virtual void Disconnect() {}; - virtual void ResetNetwork() {}; + virtual bool listen(){ return false;}; - 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); + virtual void Disconnect() {}; + virtual void ResetNetwork() {}; - 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); - const char *GetDriverName(); - virtual void SetLocalDrivers(); - void GetHostSettings(std::string &strCarCat,bool &bCollisions); - virtual void SetCarInfo(const char *pszName); + void ClearLocalDrivers(); - 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() ; - void UnlockNetworkData(); + virtual bool FinishRace(double time) ; + + 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; - - double m_sendCtrlTime; - double m_sendCarDataTime; - double m_currentTime; + FILE *m_pFile; - NetMutexData m_NetworkData; + double m_sendCtrlTime; + double m_sendCarDataTime; + double m_currentTime; + + NetMutexData m_NetworkData; - std::map m_mapRanks; + std::map m_mapRanks; - std::set m_setLocalDrivers; + std::set 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(); - - void ConnectToClients(); - void SetCarInfo(const char *pszName); + bool TimeSynced(){return m_bTimeSynced;} + int LookUpDriverIdx() { return m_driverIdx;} + bool listenHost(ENetHost * pHost); + virtual void SetLocalDrivers(); + + 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; - - ENetPeer *m_pServer; + ENetHost * m_pClient; + + 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(); - - //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 Start(int port); + virtual bool listen(); - 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(); - 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); + bool ClientsReadyToRace(); + double WaitForRaceStart(); + void UpdateClientCarInfo(tSituation *s); - void SetCarInfo(const char *pszName); - void SetFinishTime(double time); - void RemovePlayerFromRace(unsigned int idx); + 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); + + 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); - - - NetServerMutexData m_ServerData; - virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel); - void Dump(const char* pszCaller); + void GenerateDriversForXML(); + //Packets + void ReadDriverInfoPacket(ENetPacket *ENetPacket, ENetPeer * pPeer); + void ReadDriverReadyPacket(ENetPacket *pPacket); + void ReadPacket(ENetEvent event); - std::vector m_vecWaitForPlayers; + NetServerMutexData m_ServerData; + virtual void BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel); + void Dump(const char* pszCaller); + + + std::vector m_vecWaitForPlayers; ENetHost * m_pServer; }; diff --git a/src/modules/networking/robotxml.cpp b/src/modules/networking/robotxml.cpp index 4ae0da220..3d42787fb 100644 --- a/src/modules/networking/robotxml.cpp +++ b/src/modules/networking/robotxml.cpp @@ -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 &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); - } - //Save our changes - GfParmWriteFileLocal(buf, params, pRobotName); + 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); + } - GfParmReleaseHandle(params); + //Save our changes + GfParmWriteFileLocal(buf, params, pRobotName); - return true; + GfParmReleaseHandle(params); + + return true; } bool RobotXml::ReadRobotDrivers(const char*pRobotName,std::vector &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); - - 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"); - } + 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); - GfParmReleaseHandle(params); - return true; + 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); + return true; } diff --git a/src/modules/networking/robotxml.h b/src/modules/networking/robotxml.h index 6627952cc..27d23c3f9 100644 --- a/src/modules/networking/robotxml.h +++ b/src/modules/networking/robotxml.h @@ -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(); - - bool CreateRobotFile(const char*pRobotName,std::vector &vecDriver); - bool ReadRobotDrivers(const char*pRobotName,std::vector &vecDrivers); + RobotXml(); + + bool CreateRobotFile(const char*pRobotName,std::vector &vecDriver); + bool ReadRobotDrivers(const char*pRobotName,std::vector &vecDrivers); }; #endif // ROBOTXML_H diff --git a/src/modules/networking/server.cpp b/src/modules/networking/server.cpp index 6664ce597..1fc428427 100644 --- a/src/modules/networking/server.cpp +++ b/src/modules/networking/server.cpp @@ -1,10 +1,10 @@ -// -*- Mode: c++ -*- /*************************************************************************** - 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$ ***************************************************************************/ @@ -27,108 +27,108 @@ NetServer::NetServer() { - if (enet_initialize () != 0) + if (enet_initialize () != 0) { GfLogError ("An error occurred while initializing ENet.\n"); - assert(false); + assert(false); } - m_strClass = "server"; + m_strClass = "server"; } NetServer::~NetServer() { - ResetNetwork(); - NetSetServer(false); + ResetNetwork(); + NetSetServer(false); } void NetServer::Disconnect() - { - ResetNetwork(); - NetSetServer(false); - } +{ + ResetNetwork(); + NetSetServer(false); +} void NetServer::ResetNetwork() { - if (m_pServer) - { - ENetPeer * pCurrentPeer; + if (m_pServer) + { + ENetPeer * pCurrentPeer; - for (pCurrentPeer = m_pServer-> peers; - pCurrentPeer < & m_pServer->peers [m_pServer->peerCount]; - ++ pCurrentPeer) - { - if (pCurrentPeer->state != ENET_PEER_STATE_CONNECTED) - continue; + for (pCurrentPeer = m_pServer-> peers; + pCurrentPeer < & m_pServer->peers [m_pServer->peerCount]; + ++ pCurrentPeer) + { + if (pCurrentPeer->state != ENET_PEER_STATE_CONNECTED) + continue; - enet_peer_disconnect (pCurrentPeer, 0); - } + enet_peer_disconnect (pCurrentPeer, 0); + } - ENetEvent event; - bool bDisconnect = false; - - /* Allow up to 3 seconds for the disconnect to succeed - and drop any received packets. - */ - while (enet_host_service (m_pServer, & event, 3000) > 0) - { - switch (event.type) - { - case ENET_EVENT_TYPE_RECEIVE: - enet_packet_destroy (event.packet); - break; + ENetEvent event; + bool bDisconnect = false; - case ENET_EVENT_TYPE_DISCONNECT: - GfLogTrace ("Disconnection succeeded."); - bDisconnect=true; - break; - - case ENET_EVENT_TYPE_NONE: - case ENET_EVENT_TYPE_CONNECT: - // Do nothing. - break; - } - } + /* Allow up to 3 seconds for the disconnect to succeed + and drop any received packets. + */ + while (enet_host_service (m_pServer, & event, 3000) > 0) + { + switch (event.type) + { + case ENET_EVENT_TYPE_RECEIVE: + enet_packet_destroy (event.packet); + break; - /* We've arrived here, so the disconnect attempt didn't */ - /* succeed yet. Force the connection down. */ - if (!bDisconnect) - { - ENetPeer * pCurrentPeer1; + case ENET_EVENT_TYPE_DISCONNECT: + GfLogTrace ("Disconnection succeeded."); + bDisconnect=true; + break; - for (pCurrentPeer1 = m_pServer-> peers; - pCurrentPeer1 < & m_pServer->peers [m_pServer->peerCount]; - ++ pCurrentPeer1) - { - if (pCurrentPeer1->state != ENET_PEER_STATE_CONNECTED) - continue; + case ENET_EVENT_TYPE_NONE: + case ENET_EVENT_TYPE_CONNECT: + // Do nothing. + break; + } + } - enet_peer_reset (pCurrentPeer1); - } - } + /* We've arrived here, so the disconnect attempt didn't */ + /* succeed yet. Force the connection down. */ + if (!bDisconnect) + { + ENetPeer * pCurrentPeer1; - enet_host_destroy(m_pServer); - m_pServer = NULL; - } + for (pCurrentPeer1 = m_pServer-> peers; + pCurrentPeer1 < & m_pServer->peers [m_pServer->peerCount]; + ++ pCurrentPeer1) + { + if (pCurrentPeer1->state != ENET_PEER_STATE_CONNECTED) + continue; + + enet_peer_reset (pCurrentPeer1); + } + } + + enet_host_destroy(m_pServer); + m_pServer = NULL; + } } bool NetServer::IsConnected() { - if (m_pServer) - return true; + if (m_pServer) + return true; - return false; + return false; } bool NetServer::Start(int port) { - SetRaceInfoChanged(true); - m_bPrepareToRace = false; - m_bBeginRace = false; + SetRaceInfoChanged(true); + m_bPrepareToRace = false; + m_bBeginRace = false; - m_timePhysics = -2.0; - m_sendCarDataTime = 0.0; - m_sendCtrlTime = 0.0; + m_timePhysics = -2.0; + m_sendCarDataTime = 0.0; + m_sendCtrlTime = 0.0; /* Bind the server to the default localhost. */ @@ -139,570 +139,570 @@ bool NetServer::Start(int port) /* Bind the server to port*/ m_address.port = (enet_uint16)port; - assert(m_pServer ==NULL); + assert(m_pServer ==NULL); - GfLogInfo ("Starting network server : Listening on port %d.\n", port); - - #if (ENET_VERSION >= 0x010300) - m_pServer = enet_host_create (& m_address /* the address to bind the server host to */, - MAXNETWORKPLAYERS, - 2, /* assume tha maximum number of channels is allowed*/ - 0 /* assume any amount of incoming bandwidth */, - 0 /* assume any amount of outgoing bandwidth */); - #else - m_pServer = enet_host_create (& m_address /* the address to bind the server host to */, - MAXNETWORKPLAYERS, - 0 /* assume any amount of incoming bandwidth */, - 0 /* assume any amount of outgoing bandwidth */); - #endif + GfLogInfo ("Starting network server : Listening on port %d.\n", port); + +#if (ENET_VERSION >= 0x010300) + m_pServer = enet_host_create (& m_address /* the address to bind the server host to */, + MAXNETWORKPLAYERS, + 2, /* assume tha maximum number of channels is allowed*/ + 0 /* assume any amount of incoming bandwidth */, + 0 /* assume any amount of outgoing bandwidth */); +#else + m_pServer = enet_host_create (& m_address /* the address to bind the server host to */, + MAXNETWORKPLAYERS, + 0 /* assume any amount of incoming bandwidth */, + 0 /* assume any amount of outgoing bandwidth */); +#endif if (m_pServer == NULL) { GfLogError ("An error occurred while trying to create an ENet server host.\n"); - return false; + return false; } - m_pHost = m_pServer; - return true; + m_pHost = m_pServer; + return true; } bool NetServer::ClientsReadyToRace() { - return m_bBeginRace; + return m_bBeginRace; } void NetServer::WaitForClientsStartPacket() { - while (!m_bBeginRace) - { - SDL_Delay(20); - } + while (!m_bBeginRace) + { + SDL_Delay(20); + } } void NetServer::SendStartTimePacket(int &startTime) { - //Wait RACESTARTDELEAY seconds to start race - m_racestarttime = GfTimeClock()+RACESTARTDELEAY; + //Wait RACESTARTDELEAY seconds to start race + m_racestarttime = GfTimeClock()+RACESTARTDELEAY; - PackedBuffer msg; + 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()); + 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); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - BroadcastPacket(pPacket,RELIABLECHANNEL); + BroadcastPacket(pPacket,RELIABLECHANNEL); - GfLogInfo("Server Start time is %lf\n",m_racestarttime); + GfLogInfo("Server Start time is %lf\n",m_racestarttime); } double NetServer::WaitForRaceStart() { - int startTime; - SendStartTimePacket(startTime); - GfLogInfo("Server waiting to start the race\n"); + int startTime; + SendStartTimePacket(startTime); + GfLogInfo("Server waiting to start the race\n"); - double time = GfTimeClock()-m_racestarttime; + double time = GfTimeClock()-m_racestarttime; - return time; + return time; } void NetServer::ClearDrivers() { - LockServerData()->m_vecNetworkPlayers.clear(); - LockServerData()->Unlock(); - GenerateDriversForXML(); - Dump("NetServer::ClearDrivers"); + LockServerData()->m_vecNetworkPlayers.clear(); + LockServerData()->Unlock(); + GenerateDriversForXML(); + Dump("NetServer::ClearDrivers"); } void NetServer::SetHostSettings(const char *pszCarCat,bool bCollisions) { - assert(m_strRaceXMLFile!=""); + assert(m_strRaceXMLFile!=""); - void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); - assert(params); - const char *pName =GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); + void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); + assert(params); + const char *pName =GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); - GfParmSetStr(params, RM_SECT_HEADER,RM_ATTR_CAR_CATEGORY, pszCarCat); - GfParmWriteFileLocal(m_strRaceXMLFile.c_str(), params, pName); + GfParmSetStr(params, RM_SECT_HEADER,RM_ATTR_CAR_CATEGORY, pszCarCat); + GfParmWriteFileLocal(m_strRaceXMLFile.c_str(), params, pName); } void NetServer::GenerateDriversForXML() { - assert(m_strRaceXMLFile!=""); + assert(m_strRaceXMLFile!=""); - void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); - assert(params); - - const char *pName =GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); + void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); + assert(params); + + const char *pName =GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); int nCars = GfParmGetEltNb(params, RM_SECT_DRIVERS); - - //Gather vector of all non human drivers - std::vector vecRDrivers; - for (int i=1;i<=nCars;i++) - { - NetDriver driver; - ReadDriverData(driver,i,params); - if (strcmp(driver.module,NETWORKROBOT) && strcmp(driver.module,HUMANROBOT)) - vecRDrivers.push_back(driver); - } - //Recreate drivers section robots first - char drvSec[256]; - GfParmListClean(params, RM_SECT_DRIVERS); - for (int i=0;i<(int)vecRDrivers.size();i++) - { - int index = i+1; - sprintf(drvSec, "%s/%d", RM_SECT_DRIVERS, index); - GfParmSetNum(params, drvSec, RM_ATTR_IDX, (char*)NULL, (tdble)vecRDrivers[i].idx); - GfParmSetStr(params, drvSec, RM_ATTR_MODULE, vecRDrivers[i].module); + //Gather vector of all non human drivers + std::vector vecRDrivers; + for (int i=1;i<=nCars;i++) + { + NetDriver driver; + ReadDriverData(driver,i,params); + if (strcmp(driver.module,NETWORKROBOT) && strcmp(driver.module,HUMANROBOT)) + vecRDrivers.push_back(driver); } - //And then add the networkhuman drivers - NetServerMutexData *pSData = LockServerData(); - for (int i=0;i<(int)pSData->m_vecNetworkPlayers.size();i++) - { - int index = i+1+vecRDrivers.size(); - sprintf(drvSec, "%s/%d", RM_SECT_DRIVERS, index); - GfParmSetNum(params, drvSec, RM_ATTR_IDX, (char*)NULL,(tdble) pSData->m_vecNetworkPlayers[i].idx); - GfParmSetStr(params, drvSec, RM_ATTR_MODULE, pSData->m_vecNetworkPlayers[i].module); + //Recreate drivers section robots first + char drvSec[256]; + GfParmListClean(params, RM_SECT_DRIVERS); + for (int i=0;i<(int)vecRDrivers.size();i++) + { + int index = i+1; + sprintf(drvSec, "%s/%d", RM_SECT_DRIVERS, index); + GfParmSetNum(params, drvSec, RM_ATTR_IDX, (char*)NULL, (tdble)vecRDrivers[i].idx); + GfParmSetStr(params, drvSec, RM_ATTR_MODULE, vecRDrivers[i].module); } - UnlockServerData(); - - //Save our changes - GfParmWriteFileLocal(m_strRaceXMLFile.c_str(), params, pName); + //And then add the networkhuman drivers + NetServerMutexData *pSData = LockServerData(); + for (int i=0;i<(int)pSData->m_vecNetworkPlayers.size();i++) + { + int index = i+1+vecRDrivers.size(); + sprintf(drvSec, "%s/%d", RM_SECT_DRIVERS, index); + GfParmSetNum(params, drvSec, RM_ATTR_IDX, (char*)NULL,(tdble) pSData->m_vecNetworkPlayers[i].idx); + GfParmSetStr(params, drvSec, RM_ATTR_MODULE, pSData->m_vecNetworkPlayers[i].module); + } + + UnlockServerData(); + + //Save our changes + GfParmWriteFileLocal(m_strRaceXMLFile.c_str(), params, pName); } void NetServer::SetLocalDrivers() { - m_setLocalDrivers.clear(); + m_setLocalDrivers.clear(); - m_driverIdx = GetDriverIdx(); - GfLogTrace("Adding Human start rank: %i\n",m_driverIdx); - m_setLocalDrivers.insert(m_driverIdx-1); + m_driverIdx = GetDriverIdx(); + GfLogTrace("Adding Human start rank: %i\n",m_driverIdx); + m_setLocalDrivers.insert(m_driverIdx-1); - assert(m_strRaceXMLFile!=""); + assert(m_strRaceXMLFile!=""); - void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); - assert(params); + void *params = GfParmReadFileLocal(m_strRaceXMLFile.c_str(),GFPARM_RMODE_STD); + assert(params); - //const char *pName =GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); + //const char *pName =GfParmGetStr(params, RM_SECT_HEADER, RM_ATTR_NAME, ""); int nCars = GfParmGetEltNb(params, RM_SECT_DRIVERS); - //Gather vector of all non human drivers - std::vector vecRDrivers; - for (int i=1;i<=nCars;i++) - { - NetDriver driver; - ReadDriverData(driver,i,params); - if ((strcmp(driver.module,NETWORKROBOT)!=0) - &&(strcmp(driver.module,HUMANROBOT)!=0)) - { - m_setLocalDrivers.insert(i-1); - GfLogTrace("Adding driver start rank:%i\n",i); - } - } + //Gather vector of all non human drivers + std::vector vecRDrivers; + for (int i=1;i<=nCars;i++) + { + NetDriver driver; + ReadDriverData(driver,i,params); + if ((strcmp(driver.module,NETWORKROBOT)!=0) + &&(strcmp(driver.module,HUMANROBOT)!=0)) + { + m_setLocalDrivers.insert(i-1); + GfLogTrace("Adding driver start rank:%i\n",i); + } + } } void NetServer::OverrideDriverReady(int idx,bool bReady) { - NetMutexData *pNData = LockNetworkData(); - pNData->m_vecReadyStatus[idx-1] = bReady; - UnlockNetworkData(); + NetMutexData *pNData = LockNetworkData(); + pNData->m_vecReadyStatus[idx-1] = bReady; + UnlockNetworkData(); - Dump("NetServer::OverrideDriverReady"); + Dump("NetServer::OverrideDriverReady"); - SetRaceInfoChanged(true); + SetRaceInfoChanged(true); } void NetServer::SetDriverReady(bool bReady) { - int idx = GetDriverIdx(); + int idx = GetDriverIdx(); - NetMutexData *pNData = LockNetworkData(); - pNData->m_vecReadyStatus[idx-1] = bReady; - UnlockNetworkData(); + NetMutexData *pNData = LockNetworkData(); + pNData->m_vecReadyStatus[idx-1] = bReady; + UnlockNetworkData(); - Dump("NetServer::SetDriverReady"); + Dump("NetServer::SetDriverReady"); - SendDriversReadyPacket(); + SendDriversReadyPacket(); } void NetServer::UpdateDriver(NetDriver & driver) { - assert(m_strRaceXMLFile!=""); - bool bNewDriver = true; + assert(m_strRaceXMLFile!=""); + bool bNewDriver = true; - NetServerMutexData *pSData = LockServerData(); + NetServerMutexData *pSData = LockServerData(); - // Search for the driver in m_vecNetworkPlayers, and update its car name if found. - for(unsigned int i=0;im_vecNetworkPlayers.size();i++) - { - if (strcmp(driver.name,pSData->m_vecNetworkPlayers[i].name)==0) - { - bNewDriver = false; - strncpy(pSData->m_vecNetworkPlayers[i].car,driver.car,64); - break; - } - } + // Search for the driver in m_vecNetworkPlayers, and update its car name if found. + for(unsigned int i=0;im_vecNetworkPlayers.size();i++) + { + if (strcmp(driver.name,pSData->m_vecNetworkPlayers[i].name)==0) + { + bNewDriver = false; + strncpy(pSData->m_vecNetworkPlayers[i].car,driver.car,64); + break; + } + } - // If not found, append it to m_vecNetworkPlayers - if (bNewDriver) - { - driver.idx = pSData->m_vecNetworkPlayers.size()+1; + // If not found, append it to m_vecNetworkPlayers + if (bNewDriver) + { + driver.idx = pSData->m_vecNetworkPlayers.size()+1; - if (!driver.client) - { - driver.address = m_pServer->address; - } + if (!driver.client) + { + driver.address = m_pServer->address; + } - pSData->m_vecNetworkPlayers.push_back(driver); - - NetMutexData *pNData = LockNetworkData(); - pNData->m_vecReadyStatus.push_back(false); - UnlockNetworkData(); - } + pSData->m_vecNetworkPlayers.push_back(driver); - GenerateDriversForXML(); - - RobotXml rXml; - rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); + NetMutexData *pNData = LockNetworkData(); + pNData->m_vecReadyStatus.push_back(false); + UnlockNetworkData(); + } - UnlockServerData(); - - Dump("NetServer::UpdateDriver"); + GenerateDriversForXML(); - SetRaceInfoChanged(true); + RobotXml rXml; + rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); + + UnlockServerData(); + + Dump("NetServer::UpdateDriver"); + + SetRaceInfoChanged(true); } void NetServer::SetCarInfo(const char *pszName) { - std::vector vecDrivers; + std::vector vecDrivers; - RobotXml robotxml; - robotxml.ReadRobotDrivers(NETWORKROBOT,vecDrivers); + RobotXml robotxml; + robotxml.ReadRobotDrivers(NETWORKROBOT,vecDrivers); - for (unsigned int i=0;im_vecNetworkPlayers); - UnlockServerData(); + RobotXml rXml; + NetServerMutexData *pSData = LockServerData(); + rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); + UnlockServerData(); } void NetServer::RemoveDriver(ENetEvent event) { - int playerStartIndex; - ENetAddress address = event.peer->address; + int playerStartIndex; + ENetAddress address = event.peer->address; - char hostName[256]; - enet_address_get_host_ip (&address,hostName,256); + char hostName[256]; + enet_address_get_host_ip (&address,hostName,256); GfLogTrace ("Client Player Info disconnect from %s\n",hostName); - - std::vector::iterator p; - if (m_vecWaitForPlayers.size()>0) - { - p = m_vecWaitForPlayers.begin(); + std::vector::iterator p; - while(p!=m_vecWaitForPlayers.end()) - { + if (m_vecWaitForPlayers.size()>0) + { + p = m_vecWaitForPlayers.begin(); - if ((p->address.host == address.host)&&(p->hostPort == address.port)) - { - m_vecWaitForPlayers.erase(p); - break; - } + while(p!=m_vecWaitForPlayers.end()) + { - p++; - } + if ((p->address.host == address.host)&&(p->hostPort == address.port)) + { + m_vecWaitForPlayers.erase(p); + break; + } - if (m_vecWaitForPlayers.size()==0) - m_bBeginRace = true; - } + p++; + } - //look for driver id - NetServerMutexData *pSData = LockServerData(); - for (p = pSData->m_vecNetworkPlayers.begin();p!=pSData->m_vecNetworkPlayers.end();p++) - { - if (p->client) - { - if ((p->address.host == address.host)&&(p->hostPort == address.port)) - { - if(m_bRaceActive) - { - playerStartIndex = p->idx-1; - pSData->m_vecNetworkPlayers.erase(p); - RemovePlayerFromRace(playerStartIndex); - GenerateDriversForXML(); - RobotXml rXml; - rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); - SetRaceInfoChanged(true); - } - else - { - pSData->m_vecNetworkPlayers.erase(p); - GenerateDriversForXML(); - RobotXml rXml; - rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); - SetRaceInfoChanged(true); - } + if (m_vecWaitForPlayers.size()==0) + m_bBeginRace = true; + } - UnlockServerData(); - return; - } - } - } + //look for driver id + NetServerMutexData *pSData = LockServerData(); + for (p = pSData->m_vecNetworkPlayers.begin();p!=pSData->m_vecNetworkPlayers.end();p++) + { + if (p->client) + { + if ((p->address.host == address.host)&&(p->hostPort == address.port)) + { + if(m_bRaceActive) + { + playerStartIndex = p->idx-1; + pSData->m_vecNetworkPlayers.erase(p); + RemovePlayerFromRace(playerStartIndex); + GenerateDriversForXML(); + RobotXml rXml; + rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); + SetRaceInfoChanged(true); + } + else + { + pSData->m_vecNetworkPlayers.erase(p); + GenerateDriversForXML(); + RobotXml rXml; + rXml.CreateRobotFile("networkhuman",pSData->m_vecNetworkPlayers); + SetRaceInfoChanged(true); + } - UnlockServerData(); + UnlockServerData(); + return; + } + } + } + + UnlockServerData(); } bool NetServer::SendPlayerAcceptedPacket(ENetPeer * pPeer) { - //Send to client requesting connection - PackedBuffer msg; + //Send to client requesting connection + PackedBuffer msg; - try - { - msg.pack_ubyte(PLAYERACCEPTED_PACKET); - } - catch (PackedBufferException &e) - { - GfLogFatal("SendPlayerAcceptedPacket: packed buffer error\n"); - } - GfLogTrace("SendPlayerAcceptedPacket: packed data length=%d\n", - msg.length()); + try + { + msg.pack_ubyte(PLAYERACCEPTED_PACKET); + } + catch (PackedBufferException &e) + { + GfLogFatal("SendPlayerAcceptedPacket: packed buffer error\n"); + } + GfLogTrace("SendPlayerAcceptedPacket: packed data length=%d\n", + msg.length()); - ENetPacket * pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - if (enet_peer_send (pPeer, RELIABLECHANNEL, pPacket)==0) - return true; + if (enet_peer_send (pPeer, RELIABLECHANNEL, pPacket)==0) + return true; - return false; + return false; } bool NetServer::SendPlayerRejectedPacket(ENetPeer * pPeer,std::string strReason) { - //Send to client requesting connection + //Send to client requesting connection - PackedBuffer msg; + 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()); + 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); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - if (enet_peer_send (pPeer, RELIABLECHANNEL, pPacket)==0) - return true; + if (enet_peer_send (pPeer, RELIABLECHANNEL, pPacket)==0) + return true; - return false; + return false; } void NetServer::SendDriversReadyPacket() { - - NetMutexData *pNData = LockNetworkData(); - int rsize = pNData->m_vecReadyStatus.size(); + NetMutexData *pNData = LockNetworkData(); - PackedBuffer msg; + int rsize = pNData->m_vecReadyStatus.size(); - try + PackedBuffer msg; + + try + { + msg.pack_ubyte(ALLDRIVERREADY_PACKET); + msg.pack_int(rsize); + for (int i = 0; i < rsize; i++) { - msg.pack_ubyte(ALLDRIVERREADY_PACKET); - msg.pack_int(rsize); - for (int i = 0; i < rsize; i++) - { - msg.pack_int(pNData->m_vecReadyStatus[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()); + } + catch (PackedBufferException &e) + { + GfLogFatal("SendDriversReadyPacket: packed buffer error\n"); + } + GfLogTrace("SendDriversReadyPacket: packed data length=%d\n", + msg.length()); - UnlockNetworkData(); + UnlockNetworkData(); - ENetPacket * pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - BroadcastPacket(pPacket,RELIABLECHANNEL); - m_bRefreshDisplay = true; + BroadcastPacket(pPacket,RELIABLECHANNEL); + m_bRefreshDisplay = true; } void NetServer::SendRaceSetupPacket() { - PackedBuffer msg; + 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()); + 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); + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_RELIABLE); - BroadcastPacket(pPacket,RELIABLECHANNEL); + BroadcastPacket(pPacket,RELIABLECHANNEL); - SetRaceInfoChanged(true); + SetRaceInfoChanged(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()); + int idx = 0; + bool bReady; - try - { - msg.unpack_ubyte(); - idx = msg.unpack_int(); - bReady = msg.unpack_int() ? true : false; - } - catch (PackedBufferException &e) - { - GfLogFatal("SendRaceSetupPacket: packed buffer error\n"); - bReady = false; - } - - NetMutexData *pNData = LockNetworkData(); - if (idx > 0) - pNData->m_vecReadyStatus[idx-1] = bReady; - UnlockNetworkData(); + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadDriverReadyPacket: packed data length=%d\n", + msg.length()); - SendDriversReadyPacket(); + try + { + msg.unpack_ubyte(); + idx = msg.unpack_int(); + bReady = msg.unpack_int() ? true : false; + } + catch (PackedBufferException &e) + { + GfLogFatal("SendRaceSetupPacket: packed buffer error\n"); + bReady = false; + } + + NetMutexData *pNData = LockNetworkData(); + if (idx > 0) + pNData->m_vecReadyStatus[idx-1] = bReady; + UnlockNetworkData(); + + SendDriversReadyPacket(); } void NetServer::ReadDriverInfoPacket(ENetPacket *pPacket, ENetPeer * pPeer) { - NetDriver driver; + NetDriver driver; - char hostName[256]; - enet_address_get_host_ip (&driver.address,hostName,256); + 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()); + PackedBuffer msg(pPacket->data, pPacket->dataLength); + GfLogTrace("ReadDriverInfoPacket: packed data length=%d\n", + msg.length()); - try + 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() ? true : false; + } + 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;im_vecNetworkPlayers.size();i++) + { + if (strcmp(driver.name,pSData->m_vecNetworkPlayers[i].name)==0) { - 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() ? true : false; - } - catch (PackedBufferException &e) - { - GfLogFatal("ReadDriverInfoPacket: packed buffer error\n"); + SendPlayerRejectedPacket(pPeer,"Player name already used. Please choose a different name."); + UnlockServerData(); + return; } + } + UnlockServerData(); - 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); + driver.address.host = pPeer->address.host; + driver.hostPort = pPeer->address.port; - //Make sure player name is unique otherwise disconnect player - NetServerMutexData *pSData = LockServerData(); - for(unsigned int i=0;im_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(); + SendPlayerAcceptedPacket(pPeer); + UpdateDriver(driver); - 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); + GfLogTrace("Reading Driver Info Packet: Driver: %s,Car: %s\n",driver.name,driver.car); } @@ -712,13 +712,13 @@ void NetServer::PingClients() ENetPeer * pCurrentPeer; for (pCurrentPeer = m_pServer-> peers; - pCurrentPeer < & m_pServer->peers [m_pServer->peerCount]; - ++ pCurrentPeer) + pCurrentPeer < & m_pServer->peers [m_pServer->peerCount]; + ++ pCurrentPeer) { - if (pCurrentPeer->state != ENET_PEER_STATE_CONNECTED) - continue; + if (pCurrentPeer->state != ENET_PEER_STATE_CONNECTED) + continue; - enet_peer_ping (pCurrentPeer); + enet_peer_ping (pCurrentPeer); } } @@ -726,57 +726,57 @@ void NetServer::PingClients() //Here you are Xavier a dynamic weather packet void NetServer::SendWeatherPacket() { - GfLogTrace("Sending Weather Packet\n"); - - PackedBuffer msg; + GfLogTrace("Sending Weather Packet\n"); - 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()); + PackedBuffer msg; - ENetPacket *pWeatherPacket = enet_packet_create(msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); - - - BroadcastPacket(pWeatherPacket,RELIABLECHANNEL); + 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 NetServer::SendTimePacket(ENetPacket *pPacketRec, ENetPeer * pPeer) { - GfLogTrace("Sending Time Packet\n"); + GfLogTrace("Sending Time Packet\n"); - double time = GfTimeClock(); - GfLogTrace("\nServer time is %lf",time); + double time = GfTimeClock(); + GfLogTrace("\nServer time is %lf",time); - PackedBuffer msg; + 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()); + 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); + //TODO change to peer send + ENetPacket * pPacket = enet_packet_create (msg.buffer(), + msg.length(), + ENET_PACKET_FLAG_UNSEQUENCED); - enet_peer_send (pPeer, UNRELIABLECHANNEL, pPacket); + enet_peer_send (pPeer, UNRELIABLECHANNEL, pPacket); } //Send a file to clients @@ -785,80 +785,80 @@ void NetServer::SendTimePacket(ENetPacket *pPacketRec, ENetPeer * pPeer) //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); + char filepath[255]; + sprintf(filepath, "%s%s", GfLocalDir(), pszFile); - FILE *pFile = fopen(filepath,"rb"); - if (!pFile) - return; + GfLogTrace("Sending file packet: File- %s\n",filepath); - char buf[0xffff]; - size_t size; - size = fread( buf, 1, 0xffff, pFile ); + FILE *pFile = fopen(filepath,"rb"); + if (!pFile) + return; - //File is to big - if (!feof(pFile)) - { - fclose(pFile); - assert(false); - return; - } + char buf[0xffff]; + size_t size; + size = fread( buf, 1, 0xffff, pFile ); - fclose(pFile); - unsigned int filesize = size; - GfLogTrace("Server file size %u\n",filesize); + //File is to big + if (!feof(pFile)) + { + fclose(pFile); + assert(false); + return; + } - short namelen = (short)strlen(pszFile); + fclose(pFile); + unsigned int filesize = size; + GfLogTrace("Server file size %u\n",filesize); - /* 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; + short namelen = (short)strlen(pszFile); - PackedBuffer msg(bufsize); + /* 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; - 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()); + PackedBuffer msg(bufsize); - ENetPacket * pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); - - BroadcastPacket(pPacket,RELIABLECHANNEL); + 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); } bool NetServer::listen() { - if (!m_pServer) - return false; + if (!m_pServer) + return false; + + bool bHasPacket = false; + ENetEvent event; + char hostName[256]; - bool bHasPacket = false; - ENetEvent event; - char hostName[256]; - while (enet_host_service (m_pServer, & event, 0) > 0) { switch (event.type) { case ENET_EVENT_TYPE_CONNECT: - enet_address_get_host_ip (&event.peer -> address,hostName,256); + enet_address_get_host_ip (&event.peer -> address,hostName,256); GfLogTrace ("A new client connected from %s\n",hostName); @@ -868,282 +868,282 @@ bool NetServer::listen() break; case ENET_EVENT_TYPE_RECEIVE: - ReadPacket(event); - bHasPacket = true; + ReadPacket(event); + bHasPacket = true; break; - + case ENET_EVENT_TYPE_DISCONNECT: - GfLogTrace("\nA client lost the connection.\n"); - enet_address_get_host_ip (&event.peer -> address,hostName,256); + GfLogTrace("\nA client lost the connection.\n"); + enet_address_get_host_ip (&event.peer -> address,hostName,256); GfLogTrace ("A new client disconnected from %s\n",hostName); - RemoveDriver(event); - SetRaceInfoChanged(true); + RemoveDriver(event); + SetRaceInfoChanged(true); GfLogTrace ("%s disconected.\n", (char*)event.peer -> data); /* Reset the peer's client information. */ event.peer -> data = NULL; - break; - - case ENET_EVENT_TYPE_NONE: - // Do nothing. - break; + break; + + case ENET_EVENT_TYPE_NONE: + // Do nothing. + break; } } - if (bHasPacket) - m_activeNetworkTime = GfTimeClock(); - - return bHasPacket; + if (bHasPacket) + m_activeNetworkTime = GfTimeClock(); + + return bHasPacket; } //Remove disconnected player from race track void NetServer::RemovePlayerFromRace(unsigned int idx) { - GfLogTrace("Removing disconnected player\n"); - std::vector vecCarStatus; - double time = 0.0; + GfLogTrace("Removing disconnected player\n"); + std::vector 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(); + 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; - vecCarStatus.push_back(cstatus); + NetMutexData *pNData = LockNetworkData(); + pNData->m_vecCarStatus.push_back(cstatus); + UnlockNetworkData(); - time = m_currentTime; + vecCarStatus.push_back(cstatus); - int iNumCars = vecCarStatus.size(); + time = m_currentTime; - PackedBuffer msg; + int iNumCars = vecCarStatus.size(); - try + PackedBuffer msg; + + try + { + msg.pack_ubyte(CARSTATUS_PACKET); + msg.pack_double(time); + msg.pack_int(iNumCars); + for (int i=0;idataLength>=1); - unsigned char packetId = pPacket->data[0]; - //int datasize = pPacket->dataLength-1; - - switch (packetId) + 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: { - 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::iterator p; + p = m_vecWaitForPlayers.begin(); + while(p!=m_vecWaitForPlayers.end()) + { + if (strcmp(p->name,name)==0) { - 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::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; - + GfLogTrace("%s ready to start\n",&name[0]); + m_vecWaitForPlayers.erase(p); + break; } - 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); - } + p++; + } + + if (m_vecWaitForPlayers.size()==0) + m_bBeginRace = true; + + } + break; + case SERVER_TIME_REQUEST_PACKET: + SendTimePacket(pPacket,event.peer); + break; + case CARCONTROLS_PACKET: + ReadCarControlsPacket(event.packet); + break; + case CARSTATUS_PACKET: + ReadCarStatusPacket(event.packet); + break; + case LAPSTATUS_PACKET: + ReadLapStatusPacket(event.packet); + break; + case DRIVERREADY_PACKET: + ReadDriverReadyPacket(event.packet); + break; + + default: + GfLogTrace ("A packet of length %u containing %s was received from %s on channel %u.\n", + event.packet -> dataLength, + event.packet -> data, + (char*)event.peer -> data, + event.channelID); + } enet_packet_destroy (event.packet); } void NetServer::SendFinishTimePacket() { - GfLogTrace("Sending finish Time Packet\n"); - - NetMutexData *pNData = LockNetworkData(); - double time = pNData->m_finishTime; - UnlockNetworkData(); + GfLogTrace("Sending finish Time Packet\n"); - GfLogInfo("Server finish time is %lf\n",time); - - PackedBuffer msg; + NetMutexData *pNData = LockNetworkData(); + double time = pNData->m_finishTime; + UnlockNetworkData(); - 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()); + GfLogInfo("Server finish time is %lf\n",time); - ENetPacket * pPacket = enet_packet_create (msg.buffer(), - msg.length(), - ENET_PACKET_FLAG_RELIABLE); - BroadcastPacket(pPacket,RELIABLECHANNEL); + 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); } 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 + //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) { - msg.pack_ubyte(PREPARETORACE_PACKET); + m_vecWaitForPlayers.push_back(pSData->m_vecNetworkPlayers[i]); } - 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); + UnlockServerData(); - BroadcastPacket(pPacket,RELIABLECHANNEL); + 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::BroadcastPacket(ENetPacket *pPacket,enet_uint8 channel) { - enet_host_broadcast (m_pHost, channel, pPacket); - m_activeNetworkTime = GfTimeClock(); + enet_host_broadcast (m_pHost, channel, pPacket); + m_activeNetworkTime = GfTimeClock(); } void NetServer::SetFinishTime(double time) { - NetMutexData *pNData = LockNetworkData(); - pNData->m_finishTime = time; - UnlockNetworkData(); - SendFinishTimePacket(); + NetMutexData *pNData = LockNetworkData(); + pNData->m_finishTime = time; + UnlockNetworkData(); + SendFinishTimePacket(); } int NetServer::NumberofPlayers() { - int n = LockServerData()->m_vecNetworkPlayers.size(); - UnlockServerData(); - return n; + int n = LockServerData()->m_vecNetworkPlayers.size(); + UnlockServerData(); + return n; } NetServerMutexData * NetServer::LockServerData() { - m_ServerData.Lock(); - return & m_ServerData; + m_ServerData.Lock(); + return & m_ServerData; } void NetServer::UnlockServerData() { - m_ServerData.Unlock(); + m_ServerData.Unlock(); } void NetServer::Dump(const char* pszCaller) { - NetMutexData *pNData = LockNetworkData(); - NetServerMutexData *pSData = LockServerData(); + NetMutexData *pNData = LockNetworkData(); + NetServerMutexData *pSData = LockServerData(); - GfLogDebug("%s : vecReady:%u, vecPlayers:%u\n", - pszCaller, pNData->m_vecReadyStatus.size(), pSData->m_vecNetworkPlayers.size()); - - UnlockServerData(); - UnlockNetworkData(); + GfLogDebug("%s : vecReady:%u, vecPlayers:%u\n", + pszCaller, pNData->m_vecReadyStatus.size(), pSData->m_vecNetworkPlayers.size()); + + UnlockServerData(); + UnlockNetworkData(); }