public void TCP_EnqueueMessage(NET_Messages.IMessage message)
{
lock (tcpOUT_MessageQueue)
{
tcpOUT_MessageQueue.Enqueue(message);
}
}
public void UDP_EnqueueMessage(NET_Messages.IMessage message)
{
lock (udpOUT_MessageQueue)
{
udpOUT_MessageQueue.Enqueue(message);
}
}
private void UDP_MainThread()
{
while (status != UDP_Status.UDP_Shutdown)
{
while (status == UDP_Status.UDP_Running)
{
//Host is only broadcasting
if (isHost == true)
{
if (udpOUT_MessageQueue.Count > 0)
{
lock (udpOUT_MessageQueue)
{
while (udpOUT_MessageQueue.Count > 0)
{
NET_Messages.IMessage message = udpOUT_MessageQueue.Dequeue();
UDP_Broadcast(UDP_Serialize(message));
}
}
}
}
//Client is only listening
else
{
UDP_Listen();
}
Thread.Sleep(60);
}
Thread.Sleep(250);
}
udpClient.Client.Close();
udpClient.Close();
//Game is closing! --> Exit thread
}
private byte[] UDP_Serialize(NET_Messages.IMessage message)
{
BinaryFormatter binForm = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
binForm.Serialize(ms, message);
return(ms.ToArray());
}
}
public void TCP_EnqueueMessage(NET_Messages.IMessage message, int playerID)
{
if (playerID != 1 && message != null)
{
if (connections[playerID - 2] != null)
{
this.connections[playerID - 2].TCP_EnqueueMessage(message);
}
}
}
private void TCP_Receive()
{
if (stream.DataAvailable == true)
{
try
{
byte[] messageData = null;
using (MemoryStream ms = new MemoryStream())
{
//Read byte size of message
byte[] header = new byte[8];
byte[] message = new byte[1];
this.stream.Read(header, 0, 8);
if (header[0] == 65 && header[1] == 81 && header[2] == 69 && header[3] == 88)
{
int totalSize = BitConverter.ToInt32(header, 4);
int size = totalSize;
//Read main message
while (size > 0)
{
byte[] buffer = new byte[size];
int received = this.stream.Read(buffer, 0, size);
ms.Write(buffer, 0, received);
size -= received;
}
messageData = ms.ToArray();
}
else
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[ERROR] Wrong header");
}
}
//Deserialize message
if (messageData != null)
{
NET_Messages.IMessage deserialized = TCP_Deserialize(messageData);
if (deserialized != null)
{
lock (tcpIN_MessageQueue)
{
tcpIN_MessageQueue.Enqueue(deserialized);
}
}
}
}
catch
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[ERROR] Receiving");
//Nothing to do here...
}
}
Thread.Sleep(1);
}
private byte[] TCP_Serialize(NET_Messages.IMessage message)
{
try
{
BinaryFormatter binForm = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
binForm.Serialize(ms, message);
return(ms.ToArray());
}
}
catch
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[FATAL ERROR] Serializing failed");
return(null);
}
}
private void UDP_Listen()
{
if (udpClient.Available >= 12)
{
byte[] buffer = udpClient.Receive(ref endPoint);
byte[] header = new byte[12];
byte[] message = new byte[1]; //Placeholder
Array.Copy(buffer, 0, header, 0, 12); //Copy bytes from buffer[] to header[]
//Check if message is valid
if (header[0] == 0 && header[1] == 0 && header[2] == 0 && header[3] == 0)
{
if (header[4] == 65 && header[5] == 81 && header[6] == 69 && header[7] == 88)
{
int mainMessageLength = BitConverter.ToInt32(header, 8);
message = new byte[mainMessageLength];
int rest = mainMessageLength;
if (buffer.Length - 12 > 0)
{
//Looks like this never happens. Seems like (receive) handles amount of received bytes automatically.
//Copy rest of message bytes from buffer[] to message[]
if (buffer.Length - 12 <= rest)
{
Array.Copy(buffer, 0, message, 12, buffer.Length - 12);
rest -= buffer.Length - 12;
}
else
{
Array.Copy(buffer, 0, message, 12, rest);
rest = 0;
}
}
while (rest > 0)
{//Receive rest of message data
if (udpClient.Available > 0)
{
buffer = null;
buffer = udpClient.Receive(ref endPoint);
if (buffer.Length <= rest)
{
Array.Copy(buffer, 0, message, mainMessageLength - rest, buffer.Length);
rest -= buffer.Length;
}
else
{
//Looks like this never happens. (See above)
Array.Copy(buffer, 0, message, mainMessageLength - rest, rest);
rest = 0;
}
}
}
//Deserialize binary data
NET_Messages.IMessage deserialized = UDP_Deserialize(message);
//Enqueue message to global queue
if (deserialized != null)
{
lock (udpIN_MessageQueue)
{
udpIN_MessageQueue.Enqueue(deserialized);
}
}
}
}
}
}
private void NET_ProcessMessage(NET_Messages.IMessage message)
{
//---------------------------------------------------------------------------------------------//
//Message handling:
//---------------------------------------------------------------------------------------------//
if (message != null)
{
//Host message handling
if (isHost == true)
{
//Update message
if (message as NET_Messages.NET_Message_Update != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
//Set update data to internal slots
int messagePID = (int)pack.GetData("PlayerID");
playersGameData[messagePID - 1] = pack;
}
//Event call message
else if (message as NET_Messages.NET_Message_EventCall != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
//Add event to list
NET_EventCall call = new NET_EventCall(pack);
eventCalls.Add(call);
}
//Disconnect message
else if (message as NET_Messages.NET_Message_Disconnect != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
int messagePID = (int)pack.GetData("PlayerID");
tcpServer.TCP_Server_ClientDisconnected(messagePID);
}
}
//Client message handling
else
{
//Server broadcast
if (message as NET_Messages.NET_Message_ServerBroadcast != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
string ipAddress = (string)pack.GetData("ServerIPAddress");
int playerC = (int)pack.GetData("PlayerSlotsUsed");
string serName = (string)pack.GetData("ServerName");
GAME_State state = (GAME_State)pack.GetData("GameState");
if (serverInfos.ContainsKey(ipAddress) == false)
{
NET_ServerInfo info = new NET_ServerInfo(ipAddress, playerC, gameState, serName);
serverInfos.Add(ipAddress, info);
}
else
{
NET_ServerInfo info = serverInfos[ipAddress];
info.INFO_SetPlayerCount(playerC);
info.INFO_SetState(gameState);
serverInfos[ipAddress] = info;
}
//If server broadcast is from connected server --> set player count
if (ipAddress == this.serverIP.ToString())
{
this.playerCount = playerC;
}
}
//Update message
else if (message as NET_Messages.NET_Message_Update != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_UberPack uberPack = new NET_UberPack(byteBuffer);
//Unpack uber pack
NET_DataPack packP1 = uberPack.GetPack(1);
NET_DataPack packP2 = uberPack.GetPack(2);
NET_DataPack packP3 = uberPack.GetPack(3);
NET_DataPack packP4 = uberPack.GetPack(4);
//Set update data to internal slots
if (packP1 != null && playerID != 1)
{
playersGameData[0] = packP1;
}
if (packP2 != null && playerID != 2)
{
playersGameData[1] = packP2;
}
if (packP3 != null && playerID != 3)
{
playersGameData[2] = packP3;
}
if (packP4 != null && playerID != 4)
{
playersGameData[3] = packP4;
}
}
//Event call message
else if (message as NET_Messages.NET_Message_EventCall != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
NET_EventCall call = new NET_EventCall(pack);
eventCalls.Add(call);
}
//Welcome message --> Set playerID for clients
else if (message as NET_Messages.NET_Message_Welcome != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
this.playerID = (int)pack.GetData("YourPlayerID");
}
//Disconnect message
else if (message as NET_Messages.NET_Message_Disconnect != null)
{
object objectBuffer = 0;
byte[] byteBuffer = new byte[1];
message.GetData(ref byteBuffer, ref objectBuffer, false);
NET_DataPack pack = new NET_DataPack(byteBuffer);
int messagePID = (int)pack.GetData("PlayerID");
if (messagePID == playerID)
{
tcpClient.TCP_Disconnected();
playerID = 0;
}
}
}
}
}
public void TCP_EnqueueMessage(NET_Messages.IMessage message)
{
connectionToServer.TCP_EnqueueMessage(message);
}
