private static void OnClientConnected(ClientConnectedEvent e)
{
if (e.clientGuid == singleton._clientData.clientGuid)
{
double localwatchtime = FFSystem.clientWatchTime;
FFSystem.ResetClientWatch();
// Set ping ( 0 < ping < 1.0 )
double calculatedPingTime = Math.Min(Math.Max((localwatchtime - e.clientSendTime) / 2.0, 0.0), 1.0);
singleton._serverPingTime = (calculatedPingTime + singleton._serverPingTime * 4.0) / 5.0;
singleton._clientId = e.clientId;
singleton._serverLifeTime = e.serverTime + singleton._serverPingTime;
singleton._serverStartDateTime = e.serverStartTime;
singleton._serverName = e.serverName;
Debug.Log("Retrieved id: " + singleton._clientId
+ " from Server with start time of: " + e.serverStartTime
+ ", and a server life time of: " + e.serverTime);
singleton._ready = true;
ClientConnectionReadyEvent CCRE;
CCRE.clientId = singleton._clientId;
CCRE.clientTime = clientTime;
FFMessage <ClientConnectionReadyEvent> .SendToLocal(CCRE);
FFLocalEvents.TimeChangeEvent TCE;
TCE.newCurrentTime = FFSystem.time;
FFMessage <FFLocalEvents.TimeChangeEvent> .SendToLocal(TCE);
}
}
private static void OnClientSyncTime(ClientSyncTimeEvent e)
{
if (e.isDistortionSyncEvent)
{
// Set ping
double calculatedPingTime = Math.Max((clientTimeNoDistortion - e.clientSendTime) / 2.0, 0.0);
singleton._serverPingTime = (calculatedPingTime + singleton._serverPingTime * 3.0) / 4.0;
double calculatedServerWatchDialation = Math.Min(Math.Max(-_serverWatchDialationLimits,
(clientTimeNoDistortion) - e.serverLifeTime),
_serverWatchDialationLimits);
FFSystem.ResetClientWatch();
singleton._serverLifeTime = e.serverLifeTime + singleton._serverPingTime;
// _serverWatchDialation average
singleton._serverWatchDialation = (calculatedServerWatchDialation + singleton._serverWatchDialation) / 2.0;
//_serverWatchDialation = calculatedServerWatchDialation; // debug (non-averaged)
Debug.Log("ClientSyncTimeEvent (Dialation Event)" +
"\nCalculated Dialation: " + calculatedServerWatchDialation +
"\nCalculated Ping: " + calculatedPingTime); // debug
}
else
{
// Set ping
double calculatedPingTime = Math.Max(clientTimeNoDistortion - e.clientSendTime, 0.0);
singleton._serverPingTime = (calculatedPingTime + singleton._serverPingTime * 4.0) / 5.0;
//_serverPingTime = calculatedPingTime;
/*Debug.Log("ClientSyncTimeEvent" +
* "\nCalculated Ping: " + calculatedPingTime); *///debug
}
}
private static void GetLocalIPEventRun()
{
try
{
IPHostEntry host;
IPAddress localIP = null;
host = Dns.GetHostEntry(Dns.GetHostName());
foreach (var ip in host.AddressList)
{
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
localIP = ip;
}
}
GetIPAddressEvent GIAE;
GIAE.isLocalIP = true;
GIAE.ip = localIP;
// Because Unity doesn't allow anything to touch game objects with anything besides the main thread
// this event will be disbatched via FFSystem through FFMessageSystem.
FFSystem.DisbatchMessage <GetIPAddressEvent>(GIAE);
}
catch (Exception exp)
{
Debug.LogError("Error in GetPublicIPBegin" +
"\nException: " + exp.Message);
}
}
/// <summary>
/// Removes Net data, and destroys object
/// </summary>
/// <param name="netId"></param>
public static void DestroyNetGameObject(long netId)
{
GameObjectData goData_C0;
if (singleton._netIdToGameObjectData.TryGetValue(netId, out goData_C0))
{
GameObjectData goData_C1;
if (singleton._netIdToGameObjectData.TryGetValue(goData_C0.gameObjectInstanceId, out goData_C1))
{
if (goData_C0.Equals(goData_C1) == false) // should be the same
{
Debug.LogError("ERROR, GameObjectData is messed up!");
}
// if we own the object, we can destroy it accross call clients
if (FFSystem.OwnGameObject(goData_C0.gameObject))
{
//Debug.Log("Sent NetObjectDestroyedEvent");//debug
NetObjectDestroyedEvent e;
e.destructiontime = FFSystem.time;
e.gameObjectNetId = goData_C1.gameObjectNetId;
FFMessage <NetObjectDestroyedEvent> .SendToNet(e, true);
}
singleton._netIdToGameObjectData.Remove(goData_C1.gameObjectNetId);
singleton._localIdToGameObjectData.Remove(goData_C1.gameObjectInstanceId);
}
}
}
// returns a clean fresh sequence for use.
public ActionSequence Sequence()
{
FFSystem.GetReady();
ActionSequence myseq = new ActionSequence(this);
ActionSequenceList.Add(myseq);
return(myseq);
}
private FFSystem()
{
if (singleton != null)
{
Debug.LogError("Error created a second Singleton of FFSystem");
return;
}
singleton = this;
}
/// <summary>
/// Registers the Game Object to other clients. If this is called on the game object it will be created
/// on all other connected clients. This should be called on Awake in order for OwnGameObject to work.
/// </summary>
public static bool RegisterNetGameObject(GameObject go, string prefabName)
{
if (go == null)
{
throw new ArgumentNullException();
}
FFSystem.GetReady();
FFPrivate.FFMessageSystem.GetReady();
// object registered/created by another client, or already registered once on this client
GameObjectData localGoData;
int id = go.GetInstanceID();
if (singleton._GameObjecttRegistryIsLocked || singleton._localIdToGameObjectData.TryGetValue(id, out localGoData))
{
return(false);
}
//if (FFClient.isReady)
//{
// int instanceId = go.GetInstanceID();
// singleton._localIdToGameObjectData.Add(instanceId, new GameObjectData(go, FFClient.clientId, -1, id));
//
// NetObjectCreatedEvent NOCE;
//
// NOCE.pos = go.transform.position;
// NOCE.rot = go.transform.rotation;
// NOCE.scale = go.transform.localScale;
//
// NOCE.creationTime = FFClient.clientTime;
// NOCE.gameObjectInstanceId = instanceId;
// NOCE.clientOwnerNetId = FFClient.clientId;
//
// NOCE.gameObjectNetId = -1; // Set by server, -1 == Not Uninitialized
//
// // Strip (clone)
// int cloneBegin = prefabName.IndexOf("(Clone)");
// if (cloneBegin == -1)
// NOCE.prefabName = prefabName;
// else
// NOCE.prefabName = prefabName.Substring(0, cloneBegin);
//
// //Debug.Log("NewObjectCreatedEvent!"); // debug
// FFMessageSystem.SendMessageToNet<NetObjectCreatedEvent>(NOCE, true);
//}
//else
//{
// GameObjectPreFabPair goPre;
// goPre.go = go;
// goPre.prefab = prefabName;
// singleton._gameObjectsToRegisterToServer.Enqueue(goPre);
//}
return(true);
}
public static void GetReady()
{
if (singleton == null)
{
FFPrivate.FFMessageSystem.GetReady();
GameObject newFFSystem;
newFFSystem = new GameObject("FFSystem");
singleton = newFFSystem.AddComponent <FFSystem>();
}
}
// TODO optimization, change FFPacket's message/eventEntry to type object for gameObject Interface for sending netId as a number versus string
// GameObject Interface
public static void SendMessageToNet <EventType>(EventType message, int gameObjectInstanceId, FFPacketInstructionFlags instructions, bool varifiedPacket)
{
FFSystem.GameObjectData gameObjectData;
if (FFSystem.TryGetGameObjectDataByInstanceId(gameObjectInstanceId, out gameObjectData))
{
FFPacket <EventType> netpacket = new FFPacket <EventType>(instructions, typeof(EventType).ToString(), message, gameObjectData.gameObjectNetId.ToString());
SendToNet <EventType>(netpacket, varifiedPacket);
}
else
{
Debug.Log("Tried to send a Message through Net via non-registered GameObject" +
"\nInstance ID: " + gameObjectInstanceId +
"\nObjects which send events to other NetObject need to be Registered via FFSystem.RegisterNetGameObject");
}
}
void OnDestroy()
{
_clientWatch.Reset();
// Notify any FFAction of the time shift
FFLocalEvents.TimeChangeEvent TCE;
TCE.newCurrentTime = FFSystem.time;
FFMessage <FFLocalEvents.TimeChangeEvent> .SendToLocal(TCE);
singleton.recievedMessages.Clear();
singleton = null;
//FFMessage<ClientConnectionReadyEvent>.Disconnect(OnClientConnectionReady);
//FFMessage<GameObjectNetIdRecievedEvent>.Disconnect(OnGameObjectNetIdRecieved);
//FFMessage<NetObjectCreatedEvent>.Disconnect(OnNetObjectCreatedEvent);
//FFMessage<NetObjectDestroyedEvent>.Disconnect(OnNetObjectDestroyedEvent);
Debug.Log("On Destroy of FFSystem, recieved Messages erased: " + recievedMessages.Count);
}
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);
}
}
void Awake()
{
foreach (var group in damageGroups)
{
damageGroup |= group;
}
FFSystem.RegisterNetGameObject(gameObject, gameObject.name);
FFMessageBoard <ApplyHealthEvent> .Connect(OnApplyHealth, gameObject);
FFMessageBoard <EmptyHealthEvent> .Connect(OnHealthEmpty, gameObject);
if (FFServer.isLocal == false)
{
FFMessageBoard <ExHealth> .Connect(OnServerUpdate, gameObject);
}
else
{
FFMessage <FFNetEvents.ClientConnectedEvent> .Connect(OnClientConnected);
}
}
void Awake()
{
bool localNetObject = FFSystem.RegisterNetGameObject(gameObject, "Player");
// Make Sequences
MoveSeq = action.Sequence();
// Update Sequence
// Input Events only if object was created by local source
if (localNetObject)
{
FFMessage <FFLocalEvents.UpdateEvent> .Connect(OnUpdateEvent);
PositionUpdateSeq = action.Sequence();
PositionUpdateSeq.Call(UpdatePositionCall);
}
FFMessageBoard <ExPlayerPositionUpdate> .Connect(OnPlayerPositionUpdate, gameObject);
FFMessageBoard <ExPlayerMoveAction> .Connect(OnPlayerMoveAction, gameObject);
FFMessageBoard <ExPlayerFireAction> .Connect(OnPlayerFireAction, gameObject);
}
public static void StartClient(string ipAddress, int port, string clientName)
{
FFClient.GetReady();
FFSystem.GetReady();
FFMessageSystem.GetReady();
if ((singleton._clientData.IsOrBeingConnected = true &&
singleton._clientData.clientSocketTCP != null && singleton._clientData.clientSocketTCP.socket != null && singleton._clientData.clientSocketTCP.socket.IsBound) &&
singleton._clientData.clientSocketUDP != null && singleton._clientData.clientSocketUDP.udpClient != null)
{
return;
}
singleton._clientData.IsOrBeingConnected = true;
singleton._clientData.clientName = clientName;
singleton._ipAddress = ipAddress;
singleton._port = port;
singleton._ipEndPoint = new IPEndPoint(IPAddress.Parse(singleton._ipAddress), singleton._port);
try
{
// TCP
singleton._clientData.clientSocketTCP = new ClientSocket(new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp));
singleton._clientData.clientSocketTCP.socket.BeginConnect(singleton._ipEndPoint, new AsyncCallback(ConnectCallback), singleton._clientData);
singleton._clientData.clientSocketTCP.clientData = singleton._clientData;
Debug.Log("Connecting to Server..." +
"\nIPEndPoint: " + singleton._ipEndPoint);
}
catch (Exception e)
{
Debug.Log("Client Failed to beging connecting to Server" +
"\nException: " + e.Message);
}
}
private static void GetPublicIPEventRun()
{
try
{
//Debug.Log("Start GetPulicIPEventRun"); // debug
string webResponce = "";
WebRequest request = WebRequest.Create("http://ipinfo.io/ip");
//Debug.Log("Request"); // debug
using (WebResponse response = request.GetResponse()) // May not work always.
{
//Debug.Log("Responce"); //debug
using (StreamReader stream = new StreamReader(response.GetResponseStream()))
{
webResponce = stream.ReadToEnd();
}
}
/* Get Ip address from responce which is of format
* XX.XXX.XXX.XX <- 1 following space
*/
IPAddress publicIP = IPAddress.Parse(webResponce.Substring(0, webResponce.Length - 1));
GetIPAddressEvent GIAE;
GIAE.isLocalIP = false;
GIAE.ip = publicIP;
// Because Unity doesn't allow anything to touch game objects with anything besides the main thread
// this event will be disbatched via FFSystem through FFMessageSystem.
FFSystem.DisbatchMessage <GetIPAddressEvent>(GIAE);
}
catch (Exception exp)
{
Debug.LogError("Error in GetPublicIPBegin" +
"\nException: " + exp.Message);
}
}
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 SendThreadLoop()
{
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms = new MemoryStream();
FFSystem.InitBinaryFormatter(bf);
uint PingCycle = (uint)(singleton._PingCycle * 1000.0f);
uint DialationSyncCycle = (uint)(singleton._DialationSyncCycle * 1000.0f);
// Sync Counters (in milliseconds)
uint DialationSyncTimeCounter = DialationSyncCycle;
uint PingTimeCounter = 0;
System.Diagnostics.Stopwatch sendThreadWatch = new System.Diagnostics.Stopwatch();
sendThreadWatch.Start();
while (true)
{
int cyclePacketCount = 0;
// sync Client if needed
if (FFClient.isReady)
{
if (sendThreadWatch.ElapsedMilliseconds >= PingTimeCounter)
{
PingTimeCounter += PingCycle;
SendClientSyncTimeEvent(false);
//Debug.Log("SendThread sent a ClientSyncTimeEvent w/o Dialation"); //debug
}
if (sendThreadWatch.ElapsedMilliseconds >= DialationSyncTimeCounter)
{
DialationSyncTimeCounter += DialationSyncCycle;
SendClientSyncTimeEvent(true);
//Debug.Log("SendThread sent a ClientSyncTimeEvent w/ Dialation"); //debug
}
}
while (singleton._packetsToSendViaTCP.Count != 0)
{
ms = new MemoryStream();
FFBasePacket packet = singleton._packetsToSendViaTCP.Dequeue();
bf.Serialize(ms, packet);
byte[] packetData = ms.GetBuffer();
ms.Flush();
ms.Dispose();
SendPacketTCP(packetData);
++cyclePacketCount;
//Debug.Log("SendThead Sent a TCP packet"); // debug
}
while (singleton._packetsToSendViaUDP.Count != 0)
{
ms = new MemoryStream();
FFBasePacket packet = singleton._packetsToSendViaUDP.Dequeue();
bf.Serialize(ms, packet);
byte[] packetData = ms.GetBuffer();
ms.Flush();
ms.Dispose();
SendPacketUDP(packetData);
++cyclePacketCount;
//Debug.Log("SendThead Sent a UDP packet"); // debug
}
if (cyclePacketCount == 0) // if we didn't send anything
{
Thread.Sleep(1); // Throw on CPU thead queue
}
}
}
public static bool isOwnedNetObject(this GameObject _go)
{
return(FFSystem.OwnGameObject(_go));
}
// ExtensionMethods
#region Gameobject
public static void Destroy(this GameObject _go)
{
FFSystem.UnRegisterNetGameObject(_go, true);
}
// MessageBoards/Messages executed by main thread in FFNetSystem
// MessageBoards/Messages Unpacking of packetdata
// MessageBoards/Messages direction and distribution
public static void SendPacketToLocal(FFBasePacket baseNetPacket)
{
#region FFMessage
if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.Message).Equals(FFPacketInstructionFlags.Message))
{
BaseMessage netMessage;
if (messageDictionary.TryGetValue(baseNetPacket.messageType, out netMessage))
{
netMessage.SendToLocal(baseNetPacket);
}
else
{
Debug.Log("Recieved message of non-registered NetMessage: " + baseNetPacket.messageType);
}
}
#endregion
#region FFMessageBoard
else if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.MessageBoard).Equals(FFPacketInstructionFlags.MessageBoard))
{
BaseMessageBoard netMessageBoard;
if (messageBoardDictionary.TryGetValue(baseNetPacket.messageType, out netMessageBoard))
{
// goes to an entry
if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.MessageBoardEntry).Equals(FFPacketInstructionFlags.MessageBoardEntry))
{
netMessageBoard.SendToLocalEntry(baseNetPacket, baseNetPacket.entry);
}
// goes to a GameObject
else if ((baseNetPacket.packetInstructions & FFPacketInstructionFlags.MessageBoardGameObjectSend).Equals(FFPacketInstructionFlags.MessageBoardGameObjectSend))
{
FFSystem.GameObjectData goToSendToData;
long netId = Convert.ToInt64(baseNetPacket.entry);
if (FFSystem.TryGetGameObjectDataByNetId(netId, out goToSendToData))
{
netMessageBoard.SendToLocalGameObject(baseNetPacket, goToSendToData.gameObject);
}
else
{
Debug.Log("Recieved messageBoard packet for netId which is not registered" +
"\nMessageType: " + baseNetPacket.messageType +
"\nFlag: " + baseNetPacket.packetInstructions +
"\nEntry: " + baseNetPacket.entry +
"\nNetId: " + netId);
}
}
else
{
Debug.Log("Recieved Invalid FFPacketInstructionFlags" +
"\nMessageType: " + baseNetPacket.messageType +
"\nFlag: " + baseNetPacket.packetInstructions +
"\nEntry: " + baseNetPacket.entry);
}
}
else
{
Debug.Log("Recieved message for a non-registered NetMessageBoard" +
"\nMessageType: " + baseNetPacket.messageType +
"\nFlag: " + baseNetPacket.packetInstructions +
"\nEntry: " + baseNetPacket.entry);
}
}
#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);
}
}
}
public void SendNetPacket <MessageType>(FFPacket <MessageType> packet, bool varifiedPacket)
{
long senderId = packet.senderId; // Client Id
packet.senderId = 0; // from Server, id: 0
MemoryStream ms = new MemoryStream();
BinaryFormatter bf = new BinaryFormatter();
FFSystem.InitBinaryFormatter(bf);
FFPacket <MessageType> .Encrypt(ref packet.message);
/*------------------------------*/
// Get client Data
ClientData cData;
// Valid Client Ids: 1 - MaxLong
if (singleton._clientData.TryGetValue(senderId, out cData))
{
}
else if (senderId == -1) // -1 is for UnInitialized IDs
{
// Un Initialized ID will not be able to send UDP Packets to the correct client, but TCP should work.
cData = clientData;
Debug.Log("Recieved Uninitialized SenderId"); // debug
}
else // Bad ID
{
Debug.LogError("Error in FFServer.ClientSocket.SendNetPacket<" + typeof(MessageType).ToString() + ">(FFPacket<" + typeof(MessageType).ToString() + ">, bool " +
"\nTried to Send a packet, but we couldn't find the senderId's ClientData." +
"\nSenderId: " + senderId);
return;
}
/*------------------------------*/
bf.Serialize(ms, packet);
byte[] packetData = ms.GetBuffer();
ms.Flush();
ms.Dispose();
try
{
if (varifiedPacket == true)
{
//Debug.Log("Server Sent Packet via TCP of type :" + typeof(MessageType).ToString()); // debug
cData.clientSocketTCP.socket.BeginSend(packetData, 0, packetData.Length, SocketFlags.None, new AsyncCallback(SendCallbackTCP), cData.clientSocketTCP);
}
else
{
//Debug.Log("Server Sent Packet via UDP of type :" + typeof(MessageType).ToString()); // debug
cData.clientSocketUDP.udpClient.Send(packetData, packetData.Length, cData.clientSocketUDP.udpEndPointRemote);
}
}
catch (Exception exp)
{
Debug.LogError("Error in FFServer.ClientSocket.SendNetPacket<" + typeof(MessageType).ToString() + ">(FFPacket<" + typeof(MessageType).ToString() + ">, bool)" +
"\nException: " + exp.Message +
"\nClient ID: " + clientData.clientId +
"\nClient Name: " + clientData.clientName);
return;
}
}
