private static void RecieveCallbackUDP(IAsyncResult AR)
{
ClientSocket clientSocket = (ClientSocket)AR.AsyncState;
try
{
// Problem part! this is what locks it up when play/stop/play
byte[] packetData = clientSocket.udpClient.EndReceive(AR, ref clientSocket.udpEndPointRemote);
// continue recieving packets
clientSocket.udpClient.BeginReceive(new AsyncCallback(RecieveCallbackUDP), clientSocket);
FFBasePacket packet;
try
{
BinaryFormatter bf = new BinaryFormatter();
FFSystem.InitBinaryFormatter(bf);
MemoryStream ms = new MemoryStream((byte[])packetData);
packet = (FFBasePacket)bf.Deserialize(ms);
ms.Dispose();
}
catch (Exception exp)
{
Debug.Log("FFPacket not deserializable (Client UDP)" +
"\nException: " + exp.Message +
"\nPacket Sise: " + packetData.Length);
return;
}
FFSystem.DisbatchPacket(packet);
//Debug.Log("Recieve CallbackUDP (Client)"); // debug
}
catch (Exception exp)
{
Debug.LogError("Error in RecieveCallbackUDP (Client)" +
"\nException: " + exp.Message +
"\nClient ID: " + clientSocket.clientData.clientId +
"\nClient Name: " + clientSocket.clientData.clientName +
"\nUDPEndpointLocal: " + clientSocket.udpEndPointLocal +
"\nUDPEndPointRemote: " + clientSocket.udpEndPointRemote);
}
}
private static void ProcessRecievedPacket(ClientSocket clientSocket, byte[] packetData)
{
MemoryStream msSendBuffer = new MemoryStream(packetData);
BinaryFormatter bf = new BinaryFormatter();
FFSystem.InitBinaryFormatter(bf);
FFBasePacket packet;
try
{
packet = (FFBasePacket)bf.Deserialize(msSendBuffer); // if packed cannot
msSendBuffer.Dispose();
}
catch (Exception exp)
{
Debug.Log("FFPacket not deserializable (Server)" +
"\nException: " + exp.Message +
"\nPacket Sise: " + packetData.Length);
return;
}
#region MessageInspectors
List <BaseMessageInspector> inspectors;
uint sendToOtherClients = 0; // if any inspectors return a non-zero number, don't distribute to others
if (singleton._messageInspectors.TryGetValue(packet.messageType, out inspectors))
{
foreach (var insp in inspectors)
{
try
{
sendToOtherClients |= insp.Inspect(clientSocket, packet);
}
catch (Exception exp)
{
Debug.LogError("Error in messageInspector: " + insp.ToString() +
"\nException: " + exp.Message);
}
}
}
#endregion
#region RelayMessages
try
{
// if none of the inspectors return a non-zero number the message will be relayed to all other clients
if (sendToOtherClients == 0)
{
// inspectors can modify packects to be send to all other clients, need to re-serialize this
MemoryStream msBroadcast = new MemoryStream();
bf.Serialize(msBroadcast, packet);
byte[] broadcastPacketData = msBroadcast.ToArray();
msBroadcast.Flush();
msBroadcast.Dispose();
// Other Clients
if (clientSocket.udpClient == null) //TCP
{
// Send out packet to others
foreach (var cDataEntry in singleton._clientDataList)
{
ClientSocket sendToClientSocket = cDataEntry.clientSocketTCP;
if (clientSocket.Equals(sendToClientSocket) == false)
{
sendToClientSocket.socket.BeginSend(broadcastPacketData, 0, broadcastPacketData.Length, SocketFlags.None,
new AsyncCallback(SendCallbackTCP), sendToClientSocket);
}
}
}
else if (clientSocket.udpClient != null) //UDP
{
ClientData cData;
if (singleton._clientData.TryGetValue(packet.senderId, out cData))
{
// Send out packet to others
foreach (var cDataEntry in singleton._clientDataList)
{
if (cData.clientId != cDataEntry.clientId)
{
/*Debug.Log("Sending Data to: " + cDataEntry.clientSocketUDP.udpEndPointRemote +
* "\nClient Id: " + cDataEntry.clientId +
* "\nPacket.instructions: " + packet.packetInstructions +
* "\nPacket.entry: " + packet.entry +
* "\nPacket.messageType: " + packet.messageType +
* "\nPacket.senderId: " + packet.senderId);*/
// debug
//Debug.Log("Send UDP packet to " + sendToClientSocket.udpEndPointRemote);
cDataEntry.clientSocketUDP.udpClient.Send(broadcastPacketData, broadcastPacketData.Length, cDataEntry.clientSocketUDP.udpEndPointRemote);
}
/*else // debug
* {
* Debug.Log("NOT SENDING TO: " + cDataEntry.clientSocketUDP.udpEndPointRemote +
* "\nClient Id: " + cDataEntry.clientId +
* "\nPacket.instructions: " + packet.packetInstructions +
* "\nPacket.entry: " + packet.entry +
* "\nPacket.messageType: " + packet.messageType +
* "\nPacket.senderId: " + packet.senderId); //debug
* }*/
//debug
}
}
else
{
Debug.LogError("Error in ProcessingRecievedPackets" +
"\nCould not find the ClientData connected to the senderId." +
"\nPacket could not be relayed");
}
}
else // Socket Data is screwed up...
{
Debug.LogError("Error in ProcessingRecievedPackets" +
"\nClientData connected to ClientSocket is messed up...?");
}
// Send to Local, because this Unity instance doesn't have a local client to listen through packet.
// This will be done if we are a dedicated server
if (singleton._sendToLocal)
{
FFSystem.DisbatchPacket(packet);
}
}
}
catch (Exception exp)
{
Debug.LogError("Exception Error in ProcessingRecievedPackets" +
"\nException: " + exp.Message +
"\nPacketData.Instructions: " + packet.packetInstructions +
"\nPacketData.entry: " + packet.entry +
"\nPacketData.MessageType: " + packet.messageType);
}
#endregion
}
private static void RecieveCallbackTCP(IAsyncResult AR)
{
SocketError socketError = SocketError.Success;
ClientSocket clientSocket = (ClientSocket)AR.AsyncState;
try
{
int recieved = clientSocket.socket.EndReceive(AR, out socketError);
if (recieved != 0 && socketError == SocketError.Success)
{
byte[] packetData = new byte[recieved];
Array.Copy(clientSocket.recieveDataBuffer, packetData, recieved);
// continue recieving packets
clientSocket.socket.BeginReceive(clientSocket.recieveDataBuffer, 0, clientSocket.recieveDataBuffer.Length, SocketFlags.None, new AsyncCallback(RecieveCallbackTCP), clientSocket);
FFBasePacket packet;
try
{
BinaryFormatter bf = new BinaryFormatter();
FFSystem.InitBinaryFormatter(bf);
MemoryStream ms = new MemoryStream(packetData);
packet = (FFBasePacket)bf.Deserialize(ms);
ms.Dispose();
}
catch (Exception exp)
{
Debug.Log("FFPacket not deserializable (Client TCP)" +
"\nException: " + exp.Message +
"\nPacket Sise: " + packetData.Length);
return;
}
FFSystem.DisbatchPacket(packet);
//Debug.Log("Recieve CallbackTCP (Client)"); //debug
}
else
{
if (socketError != SocketError.Success)
{
Debug.LogError("RecieveCallbackTCP SocketShutdown (Client)" +
"\nSocketError: " + socketError +
"\nClient ID: " + clientSocket.clientData.clientId +
"\nClient Name: " + clientSocket.clientData.clientName);
}
else
{
Debug.Log("RecieveCallbackTCP SocketShutdown (Client)" +
"\nClient ID: " + clientSocket.clientData.clientId +
"\nClient Name: " + clientSocket.clientData.clientName);
}
}
}
catch (Exception exp)
{
if (socketError != SocketError.Success)
{
Debug.LogError("Error in RecieveCallbackTCP (Client)" +
"\nException: " + exp.Message +
"\nSocketError: " + socketError +
"\nClient ID: " + clientSocket.clientData.clientId +
"\nClient Name: " + clientSocket.clientData.clientName);
}
else
{
Debug.LogError("Error in RecieveCallbackTCP (Client)" +
"\nException: " + exp.Message +
"\nClient ID: " + clientSocket.clientData.clientId +
"\nClient Name: " + clientSocket.clientData.clientName);
}
}
}