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; } }