gcblue-commits

[<ddc...@us...>]

Update of /cvsroot/gcblue/gcb_wx/src/network
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv9771/src/network

Modified Files:
	tcConnectionData.cpp tcMessage.cpp tcMultiplayerInterface.cpp 
	tcNetworkInterface.cpp 
Log Message:


Index: tcConnectionData.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/network/tcConnectionData.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** tcConnectionData.cpp	2 Mar 2004 02:52:14 -0000	1.2
--- tcConnectionData.cpp	6 Mar 2004 20:52:29 -0000	1.3
***************
*** 42,82 ****
  * the idx is stored in the appropriate receive queue.
  */
! void tcConnectionData::ReadNextMessage()
  {    
      wxASSERT(socket);
  
!     // attempt to read header if header needs to be read
!     if (tempMessage.id == -1)
!     { 
!         const unsigned headerSize = sizeof(tempMessage.messageSize) + 
!             sizeof(tempMessage.id);
! 
!         // verify the message header and at least one byte of data are available
!         socket->Read(tempMessage.buffer + tempMessage.bufferIdx, 
!             headerSize - tempMessage.bufferIdx);
! 
          tempMessage.bufferIdx += socket->LastCount();
- 
-         if (tempMessage.bufferIdx >= headerSize)
-         {
-             memcpy(&tempMessage.messageSize, tempMessage.buffer, sizeof(tempMessage.messageSize));
-             memcpy(&tempMessage.id, tempMessage.buffer + sizeof(tempMessage.messageSize),
-                 sizeof(tempMessage.id));
-             tempMessage.bufferIdx = 0;
-         }
      }
  
!     if (tempMessage.id == -1)
      {
!         fprintf(stdout, " Read partial message: %d bytes of data\n", tempMessage.bufferIdx);
          return;
      }
  
      // Read message
!     socket->Read(tempMessage.buffer + tempMessage.bufferIdx, 
!         tempMessage.messageSize - tempMessage.bufferIdx);
      tempMessage.bufferIdx += socket->LastCount();
      
!     if (tempMessage.bufferIdx >= tempMessage.messageSize)
      {
      }
--- 42,69 ----
  * the idx is stored in the appropriate receive queue.
  */
! void tcConnectionData::ReadNextMessageTCP()
  {    
      wxASSERT(socket);
  
!     // read size field first
!     if (tempMessage.bufferIdx == 0)
!     {
!         socket->Read(tempMessage.data.buffer, tcMessage::SIZE_SIZE);
          tempMessage.bufferIdx += socket->LastCount();
      }
  
!     if (tempMessage.bufferIdx == 0)
      {
!         std::cerr << "Warning - tcConnectionData::ReadNextMessage() called with empty read buffer"
!             << std::endl;
          return;
      }
  
      // Read message
!     socket->Read(tempMessage.data.buffer + tempMessage.bufferIdx, 
!         tempMessage.data.header.messageSize - tempMessage.bufferIdx);
      tempMessage.bufferIdx += socket->LastCount();
      
!     if (tempMessage.bufferIdx >= tempMessage.data.header.messageSize)
      {
      }
***************
*** 90,94 ****
  
      std::string testString;
!     testString = (char*)tempMessage.buffer;
  
      /*
--- 77,81 ----
  
      std::string testString;
!     testString = (const char*)tempMessage.GetMessageData();
  
      /*
***************
*** 107,114 ****
  
      *message = tempMessage;
      readQueueTCP.push(bufferIdx);
  
      fprintf(stdout, " Received message, size: %d, id:%d, t:%d data:%s\n",
!         tempMessage.messageSize, tempMessage.id, tcTime::Get30HzCount(), testString.c_str());
  
      tempMessage.Reset();
--- 94,104 ----
  
      *message = tempMessage;
+     message->StampTime();
+ 
      readQueueTCP.push(bufferIdx);
  
      fprintf(stdout, " Received message, size: %d, id:%d, t:%d data:%s\n",
!         message->GetMessageSize(), message->GetMessageId(), 
!         message->GetMessageTimestamp(), testString.c_str());
  
      tempMessage.Reset();
***************
*** 117,120 ****
--- 107,152 ----
  
  /**
+ * Read messageSize bytes from buffer, create message
+ * and add to UDP receive queue.
+ */
+ void tcConnectionData::ReadNextMessageUDP(unsigned int messageSize, 
+                                           unsigned char *buffer)
+ {
+     if (messageSize == 0)
+     {
+         std::cerr << "Error - empty UDP message received" << std::endl;
+         return;
+     }
+     if (messageSize > tcMessage::BUFFER_SIZE)
+     {
+         std::cerr << "Error - UDP message size too large"
+             << std::endl;
+         return;
+     }
+ 
+     int bufferIdx = networkInterface->CheckoutMessage();
+     tcMessage *message = networkInterface->GetMessage(bufferIdx);
+     if (message == NULL) 
+     {
+         std::cerr << "Error - Message buffer full, UDP receive message lost" 
+             << std::endl;
+         return;
+     }
+ 
+ 
+     memcpy(message->data.buffer, buffer, messageSize);
+ 
+     message->StampTime();
+ 
+     readQueueUDP.push(bufferIdx);
+ 
+     fprintf(stdout, " Received UDP message, size: %d, id:%d, t:%d\n",
+         message->GetMessageSize(), message->GetMessageId(), 
+         message->GetMessageTimestamp());
+    
+ }
+ 
+ 
+ /**
  * Adds message idx to back of TCP send queue
  */
***************
*** 125,128 ****
--- 157,168 ----
  
  /**
+ * Adds message idx to back of UDP send queue
+ */
+ void tcConnectionData::SendUDP(unsigned int idx, bool useAck)
+ {
+     writeQueueUDP.push(idx);
+ }
+ 
+ /**
  *
  */
***************
*** 132,136 ****
  
      //ReadNextMessage();
!     WriteQueuedMessage();
  }
  
--- 172,176 ----
  
      //ReadNextMessage();
!     WriteQueuedMessages();
  }
  
***************
*** 140,148 ****
  * is exceeded, writes part of the message only.
  */
! void tcConnectionData::WriteQueuedMessage()
  {
!     if (writeQueueTCP.empty()) return;
      int bufferId = writeQueueTCP.front();
      tcMessage *message = networkInterface->GetMessage(bufferId);
      if (message == NULL)
      {
--- 180,204 ----
  * is exceeded, writes part of the message only.
  */
! void tcConnectionData::WriteQueuedMessages()
  {
! 
!     WriteTCP();
! 
!     WriteUDP();
! 
!  
! }
! 
! /**
! *
! */
! void tcConnectionData::WriteTCP()
! {
!    if (writeQueueTCP.empty()) return;
! 
      int bufferId = writeQueueTCP.front();
+ 
      tcMessage *message = networkInterface->GetMessage(bufferId);
+ 
      if (message == NULL)
      {
***************
*** 153,205 ****
      //socket->SetFlags(wxSOCKET_WAITALL);
  
!     const unsigned idx1 = sizeof(message->messageSize);
!     const unsigned idx2 = sizeof(message->messageSize) + sizeof(message->id);
  
-     if (message->bufferIdx < idx1)
-     {
-         // write message size field
-         socket->Write(&message->messageSize + message->bufferIdx, 
-             idx1 - message->bufferIdx);
-         message->bufferIdx += socket->LastCount();
-         if (message->bufferIdx < idx1) return;
-     }
      if (socket->Error())
      {
-         int gg = 4;
-         wxSocketError err = socket->LastError();
-     }
-     if (message->bufferIdx < idx2)
-     {
-         // write message id field
-         socket->Write(&message->id + message->bufferIdx - idx1, 
-             idx2 - message->bufferIdx);
-         message->bufferIdx += socket->LastCount();
-         if (message->bufferIdx < idx2) return;
-     }
-     if (socket->Error())
-     {
-         int gg = 4;
          wxSocketError err = socket->LastError();
      }
  
-     // write data
-     socket->Write(&message->buffer[message->bufferIdx - idx2], 
-         message->messageSize - message->bufferIdx + idx2);
- 
      message->bufferIdx += socket->LastCount();
  
      // pop message from queue and return message buffer if entire
      // message has been written
!     if (message->bufferIdx >= (message->messageSize + idx2))
      {
          fprintf(stdout,"Sent message, size:%d, id:%d, t:%d\n",
!             message->messageSize, message->id, tcTime::Get30HzCount());
          writeQueueTCP.pop();
          networkInterface->ReturnMessage(bufferId);
      }
!     if (socket->Error())
      {
!         int gg = 4;
!         wxSocketError err = socket->LastError();
      }
  
--- 209,236 ----
      //socket->SetFlags(wxSOCKET_WAITALL);
  
!     socket->Write(message->data.buffer + message->bufferIdx, 
!         message->data.header.messageSize - message->bufferIdx);
  
      if (socket->Error())
      {
          wxSocketError err = socket->LastError();
+         fprintf(stderr, "Error - SocketError %d\n", err);
      }
  
      message->bufferIdx += socket->LastCount();
  
      // pop message from queue and return message buffer if entire
      // message has been written
!     if (message->bufferIdx >= message->data.header.messageSize)
      {
          fprintf(stdout,"Sent message, size:%d, id:%d, t:%d\n",
!             message->GetMessageSize(), message->GetMessageId(), tcTime::Get30HzCount());
          writeQueueTCP.pop();
          networkInterface->ReturnMessage(bufferId);
      }
!     else
      {
!         fprintf(stdout,"Sent partial message, buff_idx:%d, id:%d, t:%d\n",
!             message->bufferIdx, message->GetMessageId(), tcTime::Get30HzCount());
      }
  
***************
*** 208,211 ****
--- 239,287 ----
  }
  
+ void tcConnectionData::WriteUDP()
+ {
+     if (writeQueueUDP.empty()) return;
+ 
+     wxASSERT(networkInterface->GetDatagramSocket());
+ 
+     int bufferId = writeQueueUDP.front();
+ 
+     tcMessage *message = networkInterface->GetMessage(bufferId);
+ 
+     if (message == NULL)
+     {
+         std::cerr << "Error - bad message buffer idx." << std::endl;
+         writeQueueTCP.pop();
+         return;
+     }
+ 
+     wxIPV4address addr;
+     socket->GetPeer(addr);
+     addr.Service(tcNetworkInterface::UDP_PORT);
+ 
+     wxString peerName = addr.Hostname();
+ 
+     wxDatagramSocket *datagramSock = networkInterface->GetDatagramSocket();
+     if (datagramSock == NULL)
+     {
+         std::cerr << "Error - NULL datagram socket" << std::endl;
+         return;
+     }
+     datagramSock->SendTo(addr, message->data.buffer, message->data.header.messageSize);
+     if (datagramSock->Error())
+     {
+         wxSocketError err = socket->LastError();
+         fprintf(stderr, "Error - SocketError %d\n", err);
+     }
+ 
+     fprintf(stdout,"Sent UDP packet to %s, size:%d, id:%d, t:%d\n",
+         peerName.c_str(), message->GetMessageSize(), message->GetMessageId(), tcTime::Get30HzCount());
+ 
+     writeQueueUDP.pop();
+ 
+     networkInterface->ReturnMessage(bufferId);
+ 
+ }
+ 
  /**
  * tcConnectionData default constructor

Index: tcMessage.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/network/tcMessage.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** tcMessage.cpp	2 Mar 2004 02:52:15 -0000	1.2
--- tcMessage.cpp	6 Mar 2004 20:52:29 -0000	1.3
***************
*** 27,30 ****
--- 27,31 ----
  
  #include "network/tcMessage.h"
+ #include "tcTime.h"
  #include <iostream>
  
***************
*** 32,45 ****
  
  
  /**
  * Reset message state to default / uninitialized
  */
  void tcMessage::Reset()
! {
!     id = -1;
!     sourceId = -1;
      timestamp = 0;
      bufferIdx = 0;
!     messageSize = 0;
  }
  
--- 33,121 ----
  
  
+ 
+ /**
+ * @return pointer to start of message data portion of message (follows header)
+ */
+ const unsigned char * tcMessage::GetMessageData()
+ {
+     return (data.buffer + HEADER_SIZE);
+ }
+ 
+ 
+ 
+ /**
+ * @return message id from message header
+ */
+ int tcMessage::GetMessageId()
+ {
+     return data.header.id;
+ }
+ 
+ /**
+ * @return size of message in bytes not including header
+ */
+ unsigned int tcMessage::GetMessageSize()
+ {
+     if (data.header.messageSize >= HEADER_SIZE)
+     {
+         return data.header.messageSize - HEADER_SIZE;
+     }
+     else
+     {
+         wxASSERT(data.header.messageSize >= HEADER_SIZE);
+         return 0;
+     }
+ }
+ 
+ /**
+ *
+ */
+ unsigned int tcMessage::GetMessageTimestamp()
+ {
+     return timestamp;
+ }
+ 
+ /**
+ * @param messageSize size of data without any header info
+ * @param data pointer to messageSize bytes of message data
+ */
+ void tcMessage::PopulateMessage(int sourceId, int messageId, unsigned messageSize, 
+         const unsigned char *messageData)
+ {
+     if (messageSize > tcMessage::MESSAGE_SIZE)
+     {
+         std::cerr << "Error - Attempted to send oversized message, truncating." << std::endl;
+         messageSize = tcMessage::MESSAGE_SIZE;
+     }
+     bufferIdx = 0;    
+     timestamp = tcTime::Get30HzCount();
+ 
+     data.header.messageSize = messageSize + HEADER_SIZE;
+     data.header.sourceId = sourceId;
+     data.header.id = messageId;
+ 
+     memcpy(data.buffer + HEADER_SIZE, messageData, messageSize);
+ 
+ 
+ }
+ 
  /**
  * Reset message state to default / uninitialized
  */
  void tcMessage::Reset()
! {        
      timestamp = 0;
      bufferIdx = 0;
!     data.header.messageSize = 0;
!     data.header.id = -1;
!     data.header.sourceId = -1;
! }
! 
! /**
! * Sets timestamp using current time
! */
! void tcMessage::StampTime()
! {
!     timestamp = tcTime::Get30HzCount();
  }
  
***************
*** 57,68 ****
  tcMessage::tcMessage(const tcMessage& source)
  {
-     id = source.id;;
      timestamp = source.timestamp;
-     sourceId = source.sourceId;
      bufferIdx = source.bufferIdx;
!     messageSize = source.messageSize;
!     wxASSERT(messageSize <= BUFFER_SIZE);
!     if (messageSize > BUFFER_SIZE) messageSize = BUFFER_SIZE;
!     memcpy(buffer, source.buffer, messageSize);
  }
  
--- 133,144 ----
  tcMessage::tcMessage(const tcMessage& source)
  {
      timestamp = source.timestamp;
      bufferIdx = source.bufferIdx;
! 
!     data.header.sourceId = source.data.header.sourceId;
!     data.header.messageSize = source.data.header.messageSize;
!     wxASSERT(data.header.messageSize <= BUFFER_SIZE);
!     if (data.header.messageSize > BUFFER_SIZE) data.header.messageSize = BUFFER_SIZE;
!     memcpy(data.buffer, source.data.buffer, data.header.messageSize);
  }
  
***************
*** 72,83 ****
  const tcMessage& tcMessage::operator=(const tcMessage& rhs)
  {
-     id = rhs.id;;
      timestamp = rhs.timestamp;
-     sourceId = rhs.sourceId;
      bufferIdx = rhs.bufferIdx;
!     messageSize = rhs.messageSize;
!     wxASSERT(messageSize <= BUFFER_SIZE);
!     if (messageSize > BUFFER_SIZE) messageSize = BUFFER_SIZE;
!     memcpy(buffer, rhs.buffer, messageSize);
  
      return *this;
--- 148,162 ----
  const tcMessage& tcMessage::operator=(const tcMessage& rhs)
  {
      timestamp = rhs.timestamp;
      bufferIdx = rhs.bufferIdx;
! 
!     data.header.id = rhs.data.header.id;;
! 
!     data.header.sourceId = rhs.data.header.sourceId;
! 
!     data.header.messageSize = rhs.data.header.messageSize;
!     wxASSERT(data.header.messageSize <= BUFFER_SIZE);
!     if (data.header.messageSize > BUFFER_SIZE) data.header.messageSize = BUFFER_SIZE;
!     memcpy(data.buffer, rhs.data.buffer, data.header.messageSize);
  
      return *this;

Index: tcMultiplayerInterface.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/network/tcMultiplayerInterface.cpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** tcMultiplayerInterface.cpp	2 Mar 2004 02:52:15 -0000	1.2
--- tcMultiplayerInterface.cpp	6 Mar 2004 20:52:29 -0000	1.3
***************
*** 29,32 ****
--- 29,35 ----
  #include "network/tcMultiplayerInterface.h"
  #include <iostream>
+ #include <queue>
+ #include "tcSound.h"
+ #include "tcTime.h"
  
  BEGIN_NAMESPACE(network)
***************
*** 69,72 ****
--- 72,98 ----
  }
  
+ bool tcMultiplayerInterface::IsNewPlayer(int id)
+ {
+     std::map<int,tcPlayerStatus>::const_iterator mapIter;
+ 
+     mapIter = playerInfo.find(id);
+     if (mapIter == playerInfo.end()) 
+     {
+         return true;
+     }
+     else
+     {
+         return false;
+     }
+ }
+ 
+ /**
+ * @return true if acting as a server
+ */
+ bool tcMultiplayerInterface::IsServer()
+ {
+     return networkInterface->IsServer();
+ }
+ 
  void tcMultiplayerInterface::MakeClient()
  {
***************
*** 88,92 ****
  */
  void tcMultiplayerInterface::ProcessMessage(int connectionId, int messageId, 
!                                 unsigned messageSize, unsigned char *data)
  {
      switch (messageId)
--- 114,118 ----
  */
  void tcMultiplayerInterface::ProcessMessage(int connectionId, int messageId, 
!                                 unsigned messageSize, const unsigned char *data)
  {
      switch (messageId)
***************
*** 124,132 ****
      {
          int connId = networkInterface->GetConnectionId(n);
!         unsigned char *data = networkInterface->ReceiveMessage(connId, messageId, 
              messageSize, tcNetworkInterface::TCP);
!         if (data != NULL)
          {
!             ProcessMessage(connId, messageId, messageSize, data);
          }
      }
--- 150,165 ----
      {
          int connId = networkInterface->GetConnectionId(n);
!         const unsigned char *tcp_data = networkInterface->ReceiveMessage(connId, messageId, 
              messageSize, tcNetworkInterface::TCP);
!         if (tcp_data != NULL)
          {
!             ProcessMessage(connId, messageId, messageSize, tcp_data);
!         }
! 
!         const unsigned char *udp_data = networkInterface->ReceiveMessage(connId, messageId, 
!             messageSize, tcNetworkInterface::UDP);
!         if (udp_data != NULL)
!         {
!             ProcessMessage(connId, messageId, messageSize, udp_data);
          }
      }
***************
*** 141,144 ****
--- 174,179 ----
      char buff[256];
  
+     int protocol = tcpChat ? tcNetworkInterface::TCP : tcNetworkInterface::UDP;
+ 
      size_t messageLength = message.length();
      if (messageLength > 255) messageLength = 255;
***************
*** 146,152 ****
--- 181,217 ----
      buff[messageLength] = 0;
      networkInterface->SendMessage(destination, MSG_CHATTEXT, 
+         (unsigned)(messageLength+1), (unsigned char*)buff, 
+         protocol);
+     /**
+     networkInterface->SendMessage(destination, MSG_CHATTEXT, 
          (unsigned)(messageLength+1), (unsigned char*)buff);
+         */
  }
  
+  void tcMultiplayerInterface::SendTestUDP(int destination, std::string message)
+  {
+     size_t messageLength = message.length();
+     if (messageLength > 255) messageLength = 255;
+     networkInterface->SendMessage(
+         destination, MSG_CHATTEXT, 
+         (unsigned)(messageLength+1), (unsigned char*)message.c_str(),
+         tcNetworkInterface::UDP);
+  }
+ 
+  /**
+  * 0 - UDP, otherwise - TCP
+  */
+  void tcMultiplayerInterface::SetChatProtocol(int code)
+  {
+      if (code)
+      {
+          tcpChat = true;
+      }
+      else
+      {
+          tcpChat = false; // use UDP
+      }
+  }
+ 
  /**
  * This must be called regularly to perform network functions.
***************
*** 159,165 ****
--- 224,289 ----
      // process receive messages
      ProcessReceiveMessages();
+ 
+     UpdatePlayerInfo();
+ }
+ 
+ 
+ /**
+ *
+ */
+ void tcMultiplayerInterface::UpdatePlayerInfo()
+ {
+     static unsigned lastUpdate = 0;
+     unsigned currentTime = tcTime::Get30HzCount();
+     if (currentTime - lastUpdate < 5) return;
+     
+     lastUpdate = currentTime;
+ 
+     // add new connections
+     unsigned nConn = networkInterface->GetNumConnections();
+     for (unsigned n=0;n<nConn;n++)
+     {
+         int connId = networkInterface->GetConnectionId(n);
+         if (IsNewPlayer(connId))
+         {
+             tcPlayerStatus stat;
+             stat.timestamp = tcTime::Get30HzCount();
+             playerInfo[connId] = stat;
+             tcSound::Get()->PlayEffect("intercom");
+         }
+         else
+         {
+             playerInfo[connId].timestamp = tcTime::Get30HzCount();
+         }
+     }
+ 
+ 
+     std::queue<int> eraseKeys;
+ 
+     for (std::map<int,tcPlayerStatus>::iterator iter = playerInfo.begin();
+         iter != playerInfo.end(); ++iter) 
+     {
+         unsigned t = iter->second.timestamp;
+         // key is in iter->first, value in iter->second
+         if (currentTime - t > 15)
+         {
+             eraseKeys.push(iter->first);
+             tcSound::Get()->PlayEffect("fslide");
+         }
+     }
+ 
+     while (!eraseKeys.empty())
+     {
+         playerInfo.erase(eraseKeys.front());
+         eraseKeys.pop();
+     }
  }
  
+ 
+ 
+ 
+ 
  tcMultiplayerInterface::tcMultiplayerInterface()
+ : tcpChat(true)
  {
      networkInterface = new tcNetworkInterface();

Index: tcNetworkInterface.cpp
===================================================================
RCS file: /cvsroot/gcblue/gcb_wx/src/network/tcNetworkInterface.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** tcNetworkInterface.cpp	2 Mar 2004 02:52:15 -0000	1.5
--- tcNetworkInterface.cpp	6 Mar 2004 20:52:29 -0000	1.6
***************
*** 201,204 ****
--- 201,225 ----
  }
  
+ 
+ /**
+ * Lookup connection by peerName and return pointer to connection data
+ * @return NULL if idx is invalid, pointer to connection data otherwise
+ */
+ tcConnectionData* tcNetworkInterface::GetConnection(std::string peerName)
+ {
+     std::map<std::string,int>::const_iterator mapIter;
+ 
+     mapIter = peerMap.find(peerName);
+     if (mapIter == peerMap.end()) 
+     {
+         return NULL;
+     }
+     int connectionIdx = mapIter->second;
+ 
+     return GetConnection(connectionIdx);
+ }
+ 
+ 
+ 
  tcMessage* tcNetworkInterface::GetMessage(int id)
  {
***************
*** 231,234 ****
--- 252,289 ----
  
  /**
+ * Initializes UDP datagram socket
+ * See google groups post "Problem with RecvFrom in wxDatagramSocket (Windows XP)"
+ */
+ void tcNetworkInterface::InitializeUDP()
+ {
+     if (datagramSock) return; // already initialized
+ 
+     wxIPV4address addr;
+     if (!addr.AnyAddress())
+     {
+         std::cerr << "Error - error configuring datagram socket." << std::endl;
+         return;
+     }
+     addr.Service(UDP_PORT);
+ 
+     datagramSock = new wxDatagramSocket(addr, wxSOCKET_NOWAIT);
+     //datagramSocket->SetTimeout(1);
+     datagramSock->SetEventHandler(*this, UDP_EVENT_ID);
+     datagramSock->SetNotify(wxSOCKET_INPUT_FLAG);
+     datagramSock->Notify(TRUE);
+ 
+     datagramSock->GetLocal(addr);
+     if (!datagramSock->Ok())
+     {
+         fprintf(stderr, "Error - Dgram sock cannot listen at port %d\n",
+             addr.Service());
+         return;
+     }
+ 
+     fprintf(stdout, "Created datagram socket on port %d\n",
+         addr.Service());
+ }
+ 
+ /**
  * @return true if this interface is acting as a server
  */
***************
*** 268,271 ****
--- 323,328 ----
      // subscribe to no events, use polling
      clientSock->Notify(FALSE);
+ 
+     InitializeUDP();
  }
  
***************
*** 300,303 ****
--- 357,362 ----
      //serverSock->Notify(FALSE);
      serverSock->SetFlags(wxSOCKET_NOWAIT);
+ 
+     InitializeUDP();
  }
  
***************
*** 310,319 ****
      case wxSOCKET_INPUT:
          {
!             std::cout << "wxSOCKET_INPUT"; 
!             int connectionIdx = LookupConnectionIndex(event.m_id);
!             tcConnectionData *conn = GetConnection(connectionIdx);
!             if (conn) 
              {
!                 conn->ReadNextMessage();
              }
  
--- 369,386 ----
      case wxSOCKET_INPUT:
          {
!             if (event.m_id == UDP_EVENT_ID)
              {
!                 std::cout << "wxSOCKET_INPUT - UDP"; 
!                 RouteUDP();
!             }
!             else
!             {
!                 std::cout << "wxSOCKET_INPUT - TCP"; 
!                 int connectionIdx = LookupConnectionIndex(event.m_id);
!                 tcConnectionData *conn = GetConnection(connectionIdx);
!                 if (conn) 
!                 {
!                     conn->ReadNextMessageTCP();
!                 }
              }
  
***************
*** 454,470 ****
  * @return pointer to message data, data should be immediately used or copied to store
  */
! unsigned char* tcNetworkInterface::ReceiveMessage(int connectionId, int& messageId, 
                                                unsigned& messageSize, int protocol)
  {
-     if (protocol != TCP) return NULL; // only TCP supported right now
- 
      int connectionIdx = LookupConnectionIndex(connectionId);
      tcConnectionData *conn = GetConnection(connectionIdx);
      if (conn == NULL) return NULL;
  
      // get next message in queue
!     if (conn->readQueueTCP.empty()) return NULL; // no messages
!     int bufferIdx = conn->readQueueTCP.front();
!     conn->readQueueTCP.pop();
  
      tcMessage *message = GetMessage(bufferIdx);
--- 521,550 ----
  * @return pointer to message data, data should be immediately used or copied to store
  */
! const unsigned char* tcNetworkInterface::ReceiveMessage(int connectionId, int& messageId, 
                                                unsigned& messageSize, int protocol)
  {
      int connectionIdx = LookupConnectionIndex(connectionId);
      tcConnectionData *conn = GetConnection(connectionIdx);
      if (conn == NULL) return NULL;
  
+     std::queue<unsigned int> *messageQueue;
+ 
+     if (protocol == TCP)
+     {
+         messageQueue = &conn->readQueueTCP;
+     }
+     else if (protocol == UDP)
+     {
+         messageQueue = &conn->readQueueUDP;
+     }
+     else
+     {
+         return NULL; // only TCP and UDP supported 
+     }
+ 
      // get next message in queue
!     if (messageQueue->empty()) return NULL; // no messages
!     int bufferIdx = messageQueue->front();
!     messageQueue->pop();
  
      tcMessage *message = GetMessage(bufferIdx);
***************
*** 475,483 ****
      }
  
!     messageId = message->id;
!     messageSize = message->messageSize;
  
      ReturnMessage(bufferIdx); // dangerous, fix this
!     return message->buffer;
  }
  
--- 555,590 ----
      }
  
!     messageId = message->GetMessageId();
!     messageSize = message->GetMessageSize();
  
      ReturnMessage(bufferIdx); // dangerous, fix this
!     return message->GetMessageData();
! }
! 
! void tcNetworkInterface::RouteUDP()
! {    
!     static unsigned char buff[MAX_UDP_SIZE];
!     wxIPV4address peerAddr;
!     unsigned int messageSize;
! 
!     messageSize = MAX_UDP_SIZE;
! 
!     datagramSock->RecvFrom(peerAddr, buff, MAX_UDP_SIZE);
!     wxString peerName = peerAddr.Hostname();
!     unsigned readCount = datagramSock->LastCount();
! 
!     /*
!     fprintf(stdout, "Received UDP from %s, size: %d, data: %s\n",
!         peerName.c_str(), readCount, (char*)buff);
!     */
! 
!     tcConnectionData *conn = GetConnection(peerName.c_str());
!     if (conn == NULL)
!     {
!         std::cerr << "Error - RouteUDP() peer name not found"
!             << std::endl;
!         return;
!     }
!     conn->ReadNextMessageUDP(readCount, buff);
  }
  
***************
*** 485,489 ****
                                       const unsigned char *data, int protocol)
  {
!     if (protocol != TCP) return false; // only TCP supported right now
  
      int connectionIdx = LookupConnectionIndex(connectionId);
--- 592,597 ----
                                       const unsigned char *data, int protocol)
  {
!    
!     if ((protocol != TCP)&&(protocol != UDP)) return false; // only TCP and UDP supported right now
  
      int connectionIdx = LookupConnectionIndex(connectionId);
***************
*** 494,503 ****
      }
  
-     if (messageSize > tcMessage::BUFFER_SIZE)
-     {
-         std::cerr << "Error - Attempted to send oversized message." << std::endl;
-         return false;
-     }
- 
      // checkout new message
      int bufferIdx = CheckoutMessage();
--- 602,605 ----
***************
*** 506,517 ****
  
      // populate message
!     message->id = messageId;
!     message->messageSize = messageSize;
!     message->sourceId = connectionId;
!     message->timestamp = tcTime::Get30HzCount();
  
!     memcpy(message->buffer, data, messageSize);
  
-     connectionData[connectionIdx].SendTCP(bufferIdx);
  
      return true;
--- 608,622 ----
  
      // populate message
!     message->PopulateMessage(connectionId, messageId, messageSize, data);
  
!     if (protocol == TCP)
!     {
!         connectionData[connectionIdx].SendTCP(bufferIdx);
!     }
!     else if (protocol == UDP)
!     {
!         connectionData[connectionIdx].SendUDP(bufferIdx);
!     }
  
  
      return true;
***************
*** 526,533 ****
--- 631,640 ----
  void tcNetworkInterface::Update()
  {
+     /*
      static unsigned lastUpdate = tcTime::Get30HzCount();
  
      if ((tcTime::Get30HzCount() - lastUpdate) < 15) return;
      lastUpdate = tcTime::Get30HzCount();
+     */
      if (isServer)
      {
***************
*** 596,600 ****
  
  /**
! * Update connectionLookup map (by clearing and rebuilding)
  * This should be called after adding or deleting a connection.
  */
--- 703,707 ----
  
  /**
! * Update connectionLookup and peerMap maps (by clearing and rebuilding)
  * This should be called after adding or deleting a connection.
  */
***************
*** 602,610 ****
--- 709,725 ----
  {
      connectionLookup.clear();
+     peerMap.clear();
+ 
      size_t nConnections = connectionData.size();
  
      for(size_t n=0;n<nConnections;n++)
      {
+         wxIPV4address peerAddr;
+ 
          connectionLookup[connectionData[n].id] = (int)n;
+         
+         connectionData[n].socket->GetPeer(peerAddr);
+         std::string hostName = peerAddr.Hostname().c_str();
+         peerMap[hostName] = (int)n;
      }
  }
***************
*** 631,635 ****
    connectionStartTime(0),
    clientSock(NULL),
!   serverSock(NULL)
  {
      tcConnectionData::networkInterface = this;
--- 746,751 ----
    connectionStartTime(0),
    clientSock(NULL),
!   serverSock(NULL),
!   datagramSock(NULL)
  {
      tcConnectionData::networkInterface = this;
***************
*** 640,643 ****
--- 756,762 ----
  tcNetworkInterface::~tcNetworkInterface()
  {
+     if (clientSock) {clientSock->Destroy();}
+     if (serverSock) {serverSock->Destroy();}
+     if (datagramSock) {datagramSock->Destroy();}
  }