{

#ifdef SYS_ENDIAN_LITTLE

U8* ptmp = ((U8*)(pval)) + 1;

*ptmp-- = *pget++;

*ptmp = *pget++;

#else

U8* ptmp = (U8*)(pval);

*ptmp++ = *pget++;

*ptmp = *pget++;

#endif

{

#ifdef SYS_ENDIAN_LITTLE

U8* ptmp = ((U8*)(pval)) + 3;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp = *pget++;

#else

U8* ptmp = (U8*)(pval);

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp = *pget++;

#endif

{

#ifdef SYS_ENDIAN_LITTLE

U8* ptmp = ((U8*)(pval)) + 7;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp-- = *pget++;

*ptmp = *pget++;

#else

U8* ptmp = (U8*)(pval);

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp++ = *pget++;

*ptmp = *pget++;

#endif

{

#ifdef SYS_ENDIAN_LITTLE

U8* ptmp = ((U8*)(&val)) + 1;

*pput++ = *ptmp--;

*pput++ = *ptmp;

#else

U8* ptmp = (U8*)(&val);

*pput++ = *ptmp++;

*pput++ = *ptmp;

#endif

{

#ifdef SYS_ENDIAN_LITTLE

U8*ptmp = ((U8*)(&val)) + 3;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp;

#else

U8*ptmp = (U8*)(&val);

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp;

#endif

{

#ifdef SYS_ENDIAN_LITTLE

U8*ptmp = ((U8*)(&val)) + 7;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp--;

*pput++ = *ptmp;

#else

U8*ptmp = (U8*)(&val);

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp++;

*pput++ = *ptmp;

#endif

RSocket::BLOCK_CALLBACK callback) // In: Blocking callback

{

// Do a reset to be sure we're starting at a good point

Reset();

// Save callback

m_callback = callback;

RSocket::Address* paddressHost, // In: Host's address

char* pszName, // In: Joiner's name

uint8_t ucColor, // In: Joiner's color

uint8_t ucTeam, // In: Joiner's team

int16_t sBandwidth) // In: Joiner's Net::Bandwidth

{

// Save server address (containing the base port)

m_addressServer = *paddressHost;

// Calculate server's listen address (the port is simply offset from the base port)

m_addressServerListen = *paddressHost;

RSocket::SetAddressPort(RSocket::GetAddressPort(&m_addressServer) + Net::ListenPortOffset, &m_addressServerListen);

// Temporarily stash the join data in peer #0

memcpy(m_aPeers[0].m_acName, pszName, sizeof(m_aPeers[0].m_acName));

m_aPeers[0].m_acName[sizeof(m_aPeers[0].m_acName)-1] = 0;

m_aPeers[0].m_ucColor = ucColor;

m_aPeers[0].m_ucTeam = ucTeam;

m_aPeers[0].m_sBandwidth = sBandwidth;

// Start the asynchronous connection process. If an error is returned, it's

// never going to succeed. If it doesn't return an error, we poll m_msgr's

// state in Update() to determine whether it failed or succeeded. We also

// set a timer so that if it takes too long, we'll give up.

// NOTE: Even though the caller could obviously check the result and not

// bother calling Update() if the result indicates failure, we do allow

// for the caller to ignore the value and go right into the normal "loop"

// which includes calling Update() and GetMsg(), so they can handle errors

// the "normal" way -- via GetMsg().

int16_t sResult = m_msgr.Connect(&m_addressServerListen, m_callback);

m_state = WaitForConnect;

m_lTimeOut = rspGetMilliseconds() + Net::MaxConnectWaitTime;

return sResult;

{

NetMsg msg;

// If there's an error message that the user hasn't retrieved yet, then

// we can't do anything.

if (m_msgError.msg.err.error == NetMsg::NoError)

{

switch (m_state)

{

case Nothing:

// Nothing to do

break;

case WaitForConnect:

// Wait for connect attempt to complete or fail or timeout

m_msgr.Update();

switch(m_msgr.GetState())

{

case CNetMsgr::Connecting:

if (rspGetMilliseconds() > m_lTimeOut)

{

TRACE("CNetClient::Update(): Timed-out trying to connect to server!\n");

m_msgError.msg.err.error = NetMsg::ConnectTimeoutError;

Drop();

}

break;

case CNetMsgr::Connected:

// Send login message to server and set state to wait for response

msg.msg.login.ucType = NetMsg::LOGIN;

msg.msg.login.ulMagic = CNetMsgr::MagicNum;

msg.msg.login.ulVersion = CNetMsgr::CurVersionNum;

SendMsg(&msg);

m_state = WaitForLoginResponse;

m_status = NetMsg::Connected;

break;

case CNetMsgr::Disconnecting:

case CNetMsgr::Disconnected:

default:

TRACE("CNetClient::Update(): Error trying to connect to server!\n");

m_msgError.msg.err.error = NetMsg::CantConnectError;

Drop();

break;

}

break;

case WaitForLoginResponse:

// Wait for response to our LOGIN message

m_msgr.Update();

m_msgr.GetMsg(&msg);

msg.ucSenderID = Net::InvalidID;

switch(msg.msg.nothing.ucType)

{

case NetMsg::NOTHING:

break;

case NetMsg::LOGIN_ACCEPT:

////////////////////////////////////////////////////////////////

// Version negotiation and useful error results ////////////////

////////////////////////////////////////////////////////////////

//

// In net implementation for Postal net version 1, both the

// server and the client would check the version numbers -- the

// server would check msg.login.ulVersion against its

// MinVersionNum & CurVersionNum and, if the server accepted the

// login, the client would check msg.loginAccept.ulVersion

// against its MinVersionNum & CurVersionNum. Although the

// version 1 client would display an error message when it

// decided it could not support the server's version, the server

// would refuse a login before that, never giving the client a

// chance to notice and report this to the user.

// To remedy this, the Postal Net version 2's server NEVER

// rejects a client and, instaed, relies on the client to reject

// it. This gives the client a chance to report the error.

// Since under our new scheme we never send a LOGIN_DENY, we

// know, if we receive a LOGIN_DENY, that we are dealing with a

// version 1 server.

//

// Additionally, bit fifteen of the version number is set if on

// a Mac platform so we can use the same mechanism to determine

// if we are attempting to connect a Mac and a PC.

//

// Here's the actual scenarios and results for version conflicts:

//

// Server 1 vs Client 2 -- Server sends Client a LOGIN_DENY so

// the client knows it's dealing with a version 1 server and

// reports the problem.

//

// Server 2 vs Client 1 -- Server accepts connection. Client

// drops, though, when it sees the server's version is 2 and

// reports the problem.

//

// For future versions:

//

// Server 3 vs Client 1 -- Server accepts connection. Client

// drops, though, when it sees the server's version is 3 and

// reports the problem.

//

// Server 3 vs Client 2 -- Server accepts connection. Client

// drops, though, when it sees the server's version is 3 and

// reports the problem.

//

// (see NetMsg::LOGIN_DENY case for handling of net version 1)

//

////////////////////////////////////////////////////////////////

// Check server's version number to see if we can support it

if ( (msg.msg.loginAccept.ulVersion >= CNetMsgr::MinVersionNum) && (msg.msg.loginAccept.ulVersion <= CNetMsgr::CurVersionNum))

{

// Save our assigned ID

m_id = msg.msg.loginAccept.idAssigned;

// Send join request and set state to wait for response. After this point, we no

// longer care about the data we temporarily stashed in peer #0 because if our join

// request is accepted, the server will send us info about ALL the clients, including

// ourself. If our request is denied, then nothing matters.

msg.msg.joinReq.ucType = NetMsg::JOIN_REQ;

memcpy(msg.msg.joinReq.acName, m_aPeers[0].m_acName, sizeof(msg.msg.joinReq.acName));

msg.msg.joinReq.ucColor = m_aPeers[0].m_ucColor;

msg.msg.joinReq.ucTeam = m_aPeers[0].m_ucTeam;

msg.msg.joinReq.sBandwidth = m_aPeers[0].m_sBandwidth;

SendMsg(&msg);

m_state = WaitForJoinResponse;

m_status = NetMsg::LoginAccepted;

}

else

{

// Determine error type (possibilities are incompatible

// versions and/or incompatible platforms).

if ( (msg.msg.loginAccept.ulVersion & CNetMsgr::MacVersionBit) ^ (CNetMsgr::MinVersionNum & CNetMsgr::MacVersionBit) )

{

// One of us is a Mac and one is a PC.

m_msgError.msg.err.error = NetMsg::ClientPlatformMismatchError;

}

else

{

// Incompatible version number.

m_msgError.msg.err.error = NetMsg::ClientVersionMismatchError;

m_msgError.msg.err.ulParam = msg.msg.loginAccept.ulVersion & ~CNetMsgr::MacVersionBit;

}

// Unsupported version number -- send LOGOUT message

msg.msg.logout.ucType = NetMsg::LOGOUT;

SendMsg(&msg);

Drop();

TRACE("CNetClient::Update(): Error trying to login to server -- unsupported version number!\n");

}

break;

case NetMsg::LOGIN_DENY:

Drop();

// There's ONLY ONE reason we'll ever get a LOGIN_DENY message and that is

// a version 1 server refused our connection b/c of our later version number

// so ... Incompatible version number.

m_msgError.msg.err.error = NetMsg::ClientVersionMismatchError;

m_msgError.msg.err.ulParam = 1;

TRACE("CNetClient::Update(): Login denied!\n");

break;

default:

TRACE("CNetClient::Update(): Unexpected message received while waiting for login response!\n");

break;

}

break;

case WaitForJoinResponse:

// Wait for response to our JOIN_REQ message

m_msgr.Update();

m_msgr.GetMsg(&msg);

msg.ucSenderID = Net::InvalidID;

switch(msg.msg.nothing.ucType)

{

case NetMsg::NOTHING:

break;

case NetMsg::JOIN_ACCEPT:

{

// Calculate our peer port based on the server's base port

uint16_t usPeerPort = RSocket::GetAddressPort(&m_addressServer) + Net::FirstPeerPortOffset + m_id;

// Open peer socket (this is an unconnected datagram socket, so all the peers

// simply hurl their data at this port, and we figure out who it came from).

if (m_socketPeers.Open(usPeerPort, RSocket::typDatagram, RSocket::optDontBlock, m_callback) == 0)

{

// We are now fully joined. HOWEVER, we don't adjust the m_sNumJoined here

// because we want to allow the server to be in direct control of that by

// virtue of JOINED and DROPPED messages.

m_state = Joined;

m_status = NetMsg::JoinAccepted;

}

else

{

Drop();

m_msgError.msg.err.error = NetMsg::CantOpenPeerSocketError;

TRACE("CNetClient::Update(): Error opening port!\n");

}

}

break;

case NetMsg::JOIN_DENY:

Drop();

m_msgError.msg.err.error = NetMsg::JoinDeniedError;

TRACE("CNetClient::Update(): Join denied!\n");

break;

default:

TRACE("CNetClient::Update(): Unexpected message received while waiting for join response!\n");

break;

}

break;

case Joined:

// Update messenger to server

m_msgr.Update();

// Always try receiving from peers before sending, because the data we

// receive can influence the data we'll send.

ReceiveFromPeers();

SendToPeers();

// If nothing was sent in a while, do a ping to tell server we're still alive

#if NET_PING

if ((rspGetMilliseconds() - m_msgr.GetMostRecentMsgSentTime()) > MaxTimeBetweenSends)

{

// Send ping msg

msg.msg.ping.ucType = NetMsg::PING;

msg.msg.ping.lTimeStamp = rspGetMilliseconds();

msg.msg.ping.lLatestPingResult = m_lLatestPingResult;

SendMsg(&msg);

}

#endif

break;

default:

TRACE("CNetClient::Update(): Unknown state!\n");

break;

}

}

NetMsg* pmsg) // Out: Message is returned here

{

// This indicates whether we got a message to be returned to the caller

bool bGotMsgForCaller = false;

if (m_msgError.msg.err.error != NetMsg::NoError)

{

// If an error occurred, generate an error message, then reset the error flag

*pmsg = m_msgError;

bGotMsgForCaller = true;

m_msgError.msg.err.error = NetMsg::NoError;

m_msgError.msg.err.ulParam = 0;

// Return this message to caller

bGotMsgForCaller = true;

}

else if (m_status != NetMsg::NoStatus)

{

// If a status occurred, generate a status message, then reset the status flag

pmsg->msg.stat.ucType = NetMsg::STAT;

pmsg->msg.stat.status = m_status;

bGotMsgForCaller = true;

m_status = NetMsg::NoStatus;

// Return this message to caller

bGotMsgForCaller = true;

}

else if (m_state == Joined)

{

// If we're waiting for the end the of the realm and we've reached the halt

// frame, then we generate a NEXT_REALM message for the caller.

if (m_bNextRealmPending && m_bReachedHaltFrame)

{

// Clear the flags

m_bUseHaltFrame = false;

m_bNextRealmPending = false;

m_bReachedHaltFrame = false;

// Create NEXT_REALM message (note that seqHalt is meaningless to caller)

pmsg->msg.nextRealm.ucType = NetMsg::NEXT_REALM;

pmsg->msg.nextRealm.seqHalt = 0;

// Return this message to caller

bGotMsgForCaller = true;

}

else

{

// If we're in the joined state, get the next message from the server and

// fill in the sender ID (it's always the server, which is Net::InvalidID)

m_msgr.GetMsg(pmsg);

pmsg->ucSenderID = Net::InvalidID;

switch (pmsg->msg.nothing.ucType)

{

case NetMsg::NOTHING:

break;

case NetMsg::STAT:

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::ERR:

// If an error occurs, there's no way to recover, so we have to drop.

// The drop may not fully work if there's a problem communicating with

// the server, but there's no harm in trying.

TRACE("CNetClient::GetMsg(): Error message received from messenger!\n");

Drop();

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::JOINED:

{

// Get id and verify that it's unused

Net::ID id = pmsg->msg.joined.id;

ASSERT(m_aPeers[id].m_state == CPeer::Unused);

// Save this peer's info

m_aPeers[id].m_address = pmsg->msg.joined.address;

memcpy(m_aPeers[id].m_acName, pmsg->msg.joined.acName, sizeof(m_aPeers[id].m_acName));

m_aPeers[id].m_ucColor = pmsg->msg.joined.ucColor;

m_aPeers[id].m_ucTeam = pmsg->msg.joined.ucTeam;

// Change state to "joined"

m_aPeers[id].m_state = CPeer::Joined;

// Adjust number of joined peers. Note that we rely fully on the server to send the

// appropriate JOINED and DROPPED messages -- if it screws up, our number will be off.

m_sNumJoined++;

// Return this message to caller

bGotMsgForCaller = true;

}

break;

case NetMsg::CHANGED:

{

// Get id and verify that it's joined

Net::ID id = pmsg->msg.changed.id;

ASSERT(m_aPeers[id].m_state == CPeer::Joined);

// Change this peer's info

memcpy(m_aPeers[id].m_acName, pmsg->msg.changed.acName, sizeof(m_aPeers[id].m_acName));

m_aPeers[id].m_ucColor = pmsg->msg.changed.ucColor;

m_aPeers[id].m_ucTeam = pmsg->msg.changed.ucTeam;

// Return this message to caller

bGotMsgForCaller = true;

}

break;

case NetMsg::DROPPED:

{

// Get id and verify that it's joined

Net::ID id = pmsg->msg.dropped.id;

ASSERT(m_aPeers[id].m_state == CPeer::Joined);

// If it was me that was dropped, it's a different case

if (id == m_id)

{

// We're done playing

m_bPlaying = false;

// Disconnect cleanly

m_msgr.Disconnect(true);

// Clear net ID

m_id = Net::InvalidID;

// Reset state

m_state = Nothing;

// Since we cleared our own ID, the caller will no longer be able to

// recognize himself, because the ID in the message will not match

// our own ID. Instead, we change the ID in the message to Net::InvalidID

// as a flag that indicates "you yourself have been dropped".

pmsg->msg.dropped.id = Net::InvalidID;

}

else

{

// If the game has started, dropping is easy. Otherwise, we merely

// kick off the beginning of a long sequence...

if (pmsg->msg.dropped.sContext == -1)

{

// Change specified peer's state to "unused"

m_aPeers[id].m_state = CPeer::Unused;

}

else

{

// Change specified peer's state to "dropped"

m_aPeers[id].m_state = CPeer::Dropped;

// Stop playing until we get a START_REALM, which the server

// will send when the drop process is completely done.

m_bPlaying = false;

// Respond with a DROP_ACK message that tells the server what frame

// we're on and the last input seq we got from the dropee.

NetMsg msg;

msg.msg.dropAck.ucType = NetMsg::DROP_ACK;

msg.msg.dropAck.seqLastDropeeInput = (Net::SEQ)(m_aPeers[id].m_netinput.FindFirstInvalid() - (Net::SEQ)1);

msg.msg.dropAck.seqLastDoneFrame = (Net::SEQ)(m_seqFrame - (Net::SEQ)1);

SendMsg(&msg);

}

}

// Adjust number of joined peers. Note that we rely fully on the server to send

// appropriate JOINED and DROPPED messages -- if it screws up, our number will be off.

m_sNumJoined--;

// Return this message to caller

bGotMsgForCaller = true;

}

break;

case NetMsg::INPUT_REQ:

{

// Get id

Net::ID id = pmsg->msg.inputReq.id;

// In response to this, we need to generate an INPUT_DATA message, which is a

// variable-size message. We'll have the message allocate memory for the

// input data, which is what varies in size. It will free the memory when it

// gets destroyed.

NetMsg msg;

msg.msg.inputData.ucType = NetMsg::INPUT_DATA;

msg.msg.inputData.id = id;

msg.msg.inputData.seqStart = pmsg->msg.inputReq.seqStart;

msg.msg.inputData.sNum = pmsg->msg.inputReq.sNum;

msg.msg.inputData.pInputs = (UINPUT*)msg.AllocVar((int32_t)pmsg->msg.inputReq.sNum * sizeof(UINPUT));

msg.msg.inputData.pFrameTimes = (U8*)msg.AllocVar((int32_t)pmsg->msg.inputReq.sNum * sizeof(U8));

// Copy the requested values into the allocated memory

Net::SEQ seq = msg.msg.inputData.seqStart;

for (int16_t s = 0; s < msg.msg.inputData.sNum; s++)

{

msg.msg.inputData.pFrameTimes[s] = m_aPeers[id].m_netinput.GetFrameTime(seq); // *SPA

msg.msg.inputData.pInputs[s] = m_aPeers[id].m_netinput.Get(seq++);

}

// Send to server. We force this to send immediately with no possibility

// of buffering because this message will be destroyed upon leaving this

// section of code, and with it will go the buffer containing all the

// inputs. Obviously, it must be sent BEFORE that happens.

SendMsg(&msg, true);

}

break;

case NetMsg::INPUT_DATA:

{

// Get id and verify that it's for a dropped client, which is the only

// situation in which we currently use this mechanism.

Net::ID id = pmsg->msg.inputData.id;

ASSERT(m_aPeers[id].m_state == CPeer::Dropped);

// Copy the supplied data to the input buffer for the specified peer. We

// have blind faith in the server, and assume it would never send us anything

// that was bad for us. :)

Net::SEQ seq = pmsg->msg.inputData.seqStart;

for (int16_t s = 0; s < pmsg->msg.inputData.sNum; s++)

{

m_aPeers[id].m_netinput.PutFrameTime(seq, pmsg->msg.inputData.pFrameTimes[s]); // *SPA

m_aPeers[id].m_netinput.Put(seq++, pmsg->msg.inputData.pInputs[s]);

}

}

break;

case NetMsg::INPUT_MARK:

{

// Get id and verify that it's for a dropped client, which is the only

// situation in which we currently use this mechanism.

Net::ID id = pmsg->msg.inputMark.id;

ASSERT(m_aPeers[id].m_state == CPeer::Dropped);

// The specified seq indicates the last seq for which the peer's input buffer

// should be used. This value could be ahead of m_seqFrame if other peer's

// are further ahead than us, or could be equal to m_SeqFrame (which, remember

// is the frame we're trying to do). Or, it could be one LESS than m_seqFrame!

// Consider that if we happen to be the furthest ahead of anyone, then the

// frame we last did would be the frame the entire drop sequence was based

// on, so that would be the last valid frame for the dropped peer. And the

// last frame we did is one LESS than m_seqFrame. So, we verify that the

// specified seq is >= m_seqFrame-1.

ASSERT(SEQ_GTE(pmsg->msg.inputMark.seqMark, (Net::SEQ)(m_seqFrame - (Net::SEQ)1)));

// Set peers last active frame

m_aPeers[id].m_seqLastActive = pmsg->msg.inputMark.seqMark;

// If the specified seq is m_seqFrame-1, then the peer is already inactive

// since we already used that input. Otherwise, it will remain active until

// we use that input.

if (m_aPeers[id].m_seqLastActive == (Net::SEQ)(m_seqFrame - (Net::SEQ)1))

m_aPeers[id].m_bInactive = true;

else

m_aPeers[id].m_bInactive = false;

}

break;

case NetMsg::CHAT:

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::SETUP_GAME:

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::START_GAME:

// Get some items of interest out of the message

m_idServer = pmsg->msg.startGame.idServer;

m_lFrameTime = (int32_t)pmsg->msg.startGame.sFrameTime;

m_seqMaxAhead = pmsg->msg.startGame.seqMaxAhead;

m_seqInputNotYetSent = m_seqMaxAhead + 1; // *SPA

// Game started, but we always start out "not playing"

m_bGameStarted = true;

m_bPlaying = false;

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::ABORT_GAME:

// Return this message to caller

bGotMsgForCaller = true;

m_bPlaying = false;

break;

case NetMsg::START_REALM:

{

// Start playing

m_bPlaying = true;

// *SPA 12/30/97 We can send the first frame now

m_bSendNextFrame = true;

m_u16PackageID = 0;

Net::ID id = 0;

for (id = 0; id < Net::MaxNumIDs; id++)

{

// Only set time for peers that are joined

if (m_aPeers[id].m_state == CPeer::Joined)

m_aPeers[id].m_lLastReceiveTime = rspGetMilliseconds();

}

}

break;

case NetMsg::HALT_REALM:

// Set the halt frame

SetHaltFrame(pmsg->msg.haltRealm.seqHalt);

break;

case NetMsg::NEXT_REALM:

// Set the halt frame. The server will never (in theory) allow more

// than one halt frame to be in effect at any time.

SetHaltFrame(pmsg->msg.nextRealm.seqHalt);

m_bSendNextFrame = false;

// Note that we don't return this message to the caller. Instead,

// we set this flag, which tells us to generate a NEXT_REALM for

// the caller when we reach the halt frame.

m_bNextRealmPending = true;

break;

case NetMsg::PROGRESS_REALM:

// Whenever the server receives a READY_REALM message from a client,

// it sends this message to all clients, telling them how many clients

// are ready. This is just a simple status message intended to allow

// the app to give the user feedback about what is happening.

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::PROCEED:

// This is a simple app-level message used by the server to tell all

// players to "proceed" to whatever the next step of the program is

// Return this message to caller

bGotMsgForCaller = true;

break;

case NetMsg::PING:

// Calculate ping time and stuff result back into message so high

// level has easy access to it.

break;

case NetMsg::RAND:

break;

default:

TRACE("CNetClient::GetMsg(): Unexpected message received!\n");

break;

}

}

}

// If we have a message for the caller, use it. Otherwise, return a NOTHING msg

if (!bGotMsgForCaller)

{

// Create a nothing message

pmsg->msg.nothing.ucType = NetMsg::NOTHING;

}