// ======================================
// 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 ProcessAckReliableSEFM(AckReliableSendEveryFrameMessage ackReliableSEFM)
{
for (int i = 0; i < outMessages.Count; i++)
{
if (outMessages[i].Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET &&
outMessages[i].ReliabilityId <= ackReliableSEFM.IdToAck)
{
outMessages.RemoveAt(i);
i--;
}
}
}
void ProcessAckReliableSendEveryFrame(AckReliableSendEveryFrameMessage ackReliableSendEveryFrameMessage)
{
for (int i = 0; i < outMessages.Count; i++)
{
Message message = outMessages [i];
if (message.Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET &&
message.ReliabilityId <= ackReliableSendEveryFrameMessage.MessageIdToAck)
{
outMessages.RemoveAt(i);
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;
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.C))
{
//send player connect message
outMessages.Add(ConnectPlayerMessage.CreateConnectPlayerMessageToSend(playerId));
}
if (Input.GetKeyDown(KeyCode.V))
{
//send player disconnect message
Packet p = new Packet();
DisconnectPlayerMessage disconnectPlayerMessage = new DisconnectPlayerMessage(GetNewReliableMessageId(), playerId);
p.buffer.PutInt(1);
disconnectPlayerMessage.Save(p.buffer);
p.buffer.Flush();
channel.Send(p);
}
Packet inPacket = channel.GetPacket();
if (inPacket != null)
{
//read it!
BitBuffer bitBuffer = inPacket.buffer;
int messageCount = bitBuffer.GetInt();
List <Message> serverMessages = new List <Message> ();
for (int i = 0; i < messageCount; i++)
{
//parse message
Message serverMessage = ReadServerMessage(bitBuffer);
if (serverMessage != null)
{
serverMessages.Add(serverMessage);
}
}
for (int i = 0; i < serverMessages.Count; i++)
{
ProcessServerMessage(serverMessages[i]);
}
}
if (localPlayerController != null)
{
PlayerInputMessage playerInputMessage = new PlayerInputMessage(-1, localPlayerController.Input);
outMessages.Add(playerInputMessage);
outMessages.Add(AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToSend(lastReceivedSendInEveryFramePacketMessageId));
}
int messagesReadyToSend = 0;
for (int i = 0; i < outMessages.Count; i++)
{
Message clientMessage = outMessages [i];
clientMessage.Update(Time.deltaTime);
if (clientMessage.NeedsToBeSent)
{
messagesReadyToSend++;
}
}
if (messagesReadyToSend > 0)
{
Packet outPacket = new Packet();
outPacket.buffer.PutInt(outMessages.Count);
for (int i = 0; i < outMessages.Count; i++)
{
Message clientMessage = outMessages [i];
clientMessage.Save(outPacket.buffer);
if (clientMessage.Reliability == ReliabilityType.UNRELIABLE)
{
outMessages.RemoveAt(i);
i--;
}
else if (clientMessage.Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET)
{
clientMessage.TimeToSend = 0;
}
else
{
clientMessage.TimeToSend = clientMessage.ReliableMaxTime;
}
}
outPacket.buffer.Flush();
channel.Send(outPacket);
}
}
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);
}
