// ======================================
// Server message reception
// ======================================
private static Message ReceiveServerMessage(BitBuffer bitBuffer)
{
var messageType = bitBuffer.GetEnum <MessageType>((int)MessageType.TOTAL);
Message message;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
message = PlayerConnectedMessage.CreatePlayerConnectedMessageToReceive();
break;
case MessageType.PLAYER_DISCONNECTED:
message = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToReceive();
break;
case MessageType.SNAPSHOT:
message = new SnapshotMessage();
break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
message = AckReliableMessage.CreateAckReliableMessageMessageToReceive();
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
message = AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToReceive();
break;
default:
return(null); // Return null if the message is not a "from server" type
}
message.Load(bitBuffer);
return(message);
}
Message ReadServerMessage(BitBuffer bitBuffer)
{
MessageType messageType = bitBuffer.GetEnum <MessageType>((int)MessageType.TOTAL);
Message serverMessage = null;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
serverMessage = PlayerConnectedMessage.CreatePCMToReceive(); break;
case MessageType.PLAYER_DISCONNECTED:
serverMessage = PlayerDisconnectedMessage.CreatePDMToReceive(); break;
case MessageType.SNAPSHOT:
serverMessage = new SnapshotMessage(); break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
serverMessage = AckReliableMessage.CreateAckReliableMessageToReceive(); break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
serverMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSEFMToReceive(); break;
default:
Debug.LogError("Unknown server message received.");
return(null);
}
serverMessage.Load(bitBuffer);
return(serverMessage);
}
Message ReadClientMessage(BitBuffer bitBuffer, IPEndPoint clientEndPoint)
{
MessageType messageType = bitBuffer.GetEnum <MessageType> ((int)MessageType.TOTAL);
Message clientMessage = null;
switch (messageType)
{
case MessageType.CONNECT_PLAYER:
clientMessage = ConnectPlayerMessage.CreateConnectPlayerMessageToReceive(clientEndPoint); break;
case MessageType.DISCONNECT_PLAYER:
clientMessage = new DisconnectPlayerMessage(); break;
case MessageType.PLAYER_INPUT:
clientMessage = new PlayerInputMessage(); break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
clientMessage = AckReliableMessage.CreateAckReliableMessageToReceive(); break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
clientMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSEFMToReceive(); break;
default:
Debug.LogError("Unknown client message received.");
return(null);
}
clientMessage.From = clientEndPoint;
clientMessage.Load(bitBuffer);
return(clientMessage);
}
private Message readServerMessage(BitBuffer bf)
{
MessageType messageType = bf.GetEnum <MessageType> ((int)MessageType.TOTAL);
Message serverMessage = null;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
serverMessage = PlayerConnectedMessage.CreatePlayerConnectedMessageToReceive();
break;
case MessageType.PLAYER_DISCONNECTED:
serverMessage = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToReceive();
break;
case MessageType.SNAPSHOT:
serverMessage = new SnapshotMessage();
break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
serverMessage = AckReliableMessage.CreateAckReliableMessageMessageToReceive();
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
serverMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToReceive();
break;
default:
Debug.LogError("Got a Server message that cannot be understood");
return(null);
}
serverMessage.Load(bf);
return(serverMessage);
}
private void ProcessAckReliable(AckReliableMessage ackReliableMessage)
{
for (int i = 0; i < outMessages.Count; i++)
{
if (outMessages[i].ReliabilityId == ackReliableMessage.IdToAck)
{
outMessages.RemoveAt(i);
break;
}
}
}
void ProcessAckReliable(AckReliableMessage ackReliableMessage)
{
for (int i = 0; i < outMessages.Count; i++)
{
Message message = outMessages [i];
if (message.ReliabilityId == ackReliableMessage.MessageIdToAck)
{
outMessages.RemoveAt(i);
break;
}
}
}
public void ProcessAckReliable(AckReliableMessage ackReliableMessage)
{
Debug.Log("Client::ProcessAckReliable " + ackReliableMessage.MessageIdToAck);
for (int i = 0; i < outMessages.Count; i++)
{
Message message = outMessages [i];
if (message.ReliabilityId == ackReliableMessage.MessageIdToAck)
{
outMessages.RemoveAt(i);
}
}
}
public void ReceiveMessage(Message message)
{
if (message.Reliability == ReliabilityType.RELIABLE_MAX_WAIT_TIME)
{
SendMessage(AckReliableMessage.CreateAckReliableMessageMessageToSend(message.ReliabilityId));
if (message.ReliabilityId == (LastReceivedReliableMessageId + 1))
{
//accept it... valid message since its +1 since the last received
//send to the sender that its reliable message has been received
LastReceivedReliableMessageId = message.ReliabilityId;
}
else
{
//we need to discard it... either its been already processed or out of order
return;
}
//send to the sender that its reliable message has been received
SendMessage(AckReliableMessage.CreateAckReliableMessageMessageToSend(message.ReliabilityId));
}
else if (message.Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET)
{
//TODO: optimize this. if outMessages already contains an ack with id less than this one then it should be removed
SendMessage(AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToSend(message.ReliabilityId));
if (message.ReliabilityId > LastReliableSendInEveryPacketMessageIdReceived)
{
//accept it... valid message since its +1 since the last received
//send to the sender that its reliable message has been received
LastReliableSendInEveryPacketMessageIdReceived = message.ReliabilityId;
}
else
{
//must discard.. got out of order message
return;
}
}
switch (message.Type)
{
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
ProcessAckReliable(message as AckReliableMessage);
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
ProcessAckReliableSendEveryFrame(message as AckReliableSendEveryFrameMessage);
break;
default:
inMessages.Add(message);
break;
}
}
public void ReceiveMessage(Message message)
{
switch (message.Reliability)
{
case ReliabilityType.RELIABLE_MAX_WAIT_TIME:
SendMessage(AckReliableMessage.CreateAckReliableMessageToSend(message.ReliabilityId));
if (message.ReliabilityId != (LatestReliableMessageId + 1))
{
return;
}
LatestReliableMessageId = message.ReliabilityId;
SendMessage(AckReliableMessage.CreateAckReliableMessageToSend(message.ReliabilityId));
break;
case ReliabilityType.RELIABLE_SEND_EVERY_PACKET:
SendMessage(AckReliableSendEveryFrameMessage.CreateAckReliableSEFMToSend(message.ReliabilityId));
if (message.ReliabilityId <= LatestSEFMessageIdReceived)
{
return;
}
LatestSEFMessageIdReceived = message.ReliabilityId;
break;
}
switch (message.Type)
{
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
ProcessAckReliable(message as AckReliableMessage); break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
ProcessAckReliableSEFM(message as AckReliableSendEveryFrameMessage); break;
default:
inMessages.Add(message);
break;
}
}
Message ReadServerMessage(BitBuffer bitBuffer)
{
MessageType messageType = bitBuffer.GetEnum <MessageType> ((int)MessageType.TOTAL);
Message serverMessage = null;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
serverMessage = PlayerConnectedMessage.CreatePlayerConnectedMessageToReceive();
break;
case MessageType.PLAYER_DISCONNECTED:
serverMessage = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToReceive();
break;
case MessageType.SNAPSHOT:
serverMessage = new SnapshotMessage();
break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
Debug.Log("Client::got ack reliable wait time ");
serverMessage = AckReliableMessage.CreateAckReliableMessageMessageToReceive();
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
serverMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToReceive();
break;
default:
Debug.LogError("Got a server message that cannot be understood");
return(null);
}
serverMessage.Load(bitBuffer);
if (serverMessage.Reliability == ReliabilityType.RELIABLE_MAX_WAIT_TIME)
{
if (serverMessage.ReliabilityId == (LastReceivedReliableMessageId + 1))
{
//accept it... valid message since its +1 since the last received
//send to the sender that its reliable message has been received
outMessages.Add(AckReliableMessage.CreateAckReliableMessageMessageToSend(serverMessage.ReliabilityId));
LastReceivedReliableMessageId = serverMessage.ReliabilityId;
}
else
{
//we need to discard it... either its been already processed or out of order
return(null);
}
}
else if (serverMessage.Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET)
{
if (serverMessage.ReliabilityId > LastReceivedSendInEveryFramePacketMessageId)
{
//set the last "reliable send in every packet" message id.. it will get sent to the server on the next packet
LastReceivedSendInEveryFramePacketMessageId = serverMessage.ReliabilityId;
Debug.Log("Client::lastReceivedSendInEveryFramePacketMessageId = " + lastReceivedSendInEveryFramePacketMessageId);
}
else
{
//discard
return(null);
}
}
return(serverMessage);
}
