private void HandlePingPongMessage(FrameStream frame, NetworkingPlayer player) { long receivedTimestep = frame.StreamData.GetBasicType <long>(); DateTime received = new DateTime(receivedTimestep); TimeSpan ms = DateTime.UtcNow - received; if (frame.GroupId == MessageGroupIds.PING) { Pong(player, received); } else { OnPingRecieved(ms.TotalMilliseconds, player); } }
public void Send(NetworkingPlayer player, FrameStream frame, bool reliable = false) { UDPPacketComposer composer = new UDPPacketComposer(this, player, frame, reliable); // If this message is reliable then make sure to keep a reference to the composer // so that there are not any run-away threads if (reliable) { lock (pendingComposers) { // Use the completed event to clean up the object from memory composer.completed += ComposerCompleted; pendingComposers.Add(composer); } } }
private void HandleDefaultMessages(FrameStream frame, NetworkingPlayer currentPlayer) { if (IsFrameNetworkIdRequest(frame)) { HandleNetworkIdRequest(currentPlayer, frame); } else if (IsFrameAuthenticationResponse(frame)) { HandleAuthenticationResponse(currentPlayer, frame); } else if (IsFrameConnectionClose(frame)) { HandleConnectionCloseFrame(); } }
public void Send(FrameStream frame, bool reliable = false, NetworkingPlayer skipPlayer = null) { if (frame.Receivers == Receivers.AllBuffered || frame.Receivers == Receivers.OthersBuffered) { bufferedMessages.Add(frame); } lock (Players) { foreach (NetworkingPlayer player in Players) { // Don't send messages to a player who has not been accepted by the server yet if ((!player.Accepted && !player.PendingAccpeted) || player == skipPlayer) { continue; } if (player == frame.Sender) { // Don't send a message to the sending player if it was meant for others if (frame.Receivers == Receivers.Others || frame.Receivers == Receivers.OthersBuffered || frame.Receivers == Receivers.OthersProximity) { continue; } } // Check to see if the request is based on proximity if (frame.Receivers == Receivers.AllProximity || frame.Receivers == Receivers.OthersProximity) { // If the target player is not in the same proximity zone as the sender // then it should not be sent to that player if (player.ProximityLocation.Distance(frame.Sender.ProximityLocation) > ProximityDistance) { continue; } } try { Send(player, frame, reliable); } catch { Disconnect(player, true); } } } }
public override void Send(FrameStream frame, bool reliable = false) { UDPPacketComposer composer = new UDPPacketComposer(); // If this message is reliable then make sure to keep a reference to the composer // so that there are not any run-away threads if (reliable) { // Use the completed event to clean up the object from memory composer.completed += ComposerCompleted; pendingComposers.Add(composer); } //TODO: New constructor for setting up callbacks before regular constructor (as seen above) composer.Init(this, Server, frame, reliable); }
public async Task <int> SendAsync(FrameStream frames, CancellationToken token) { var bytesSent = 0; foreach (var frame in frames.GetBuffers()) { var frameBytes = new byte[4]; MessageFramingUtil.EncodeLength((int)frame.Length, frameBytes, 0); await _stream.WriteAsync(frameBytes, 0, 4, token); bytesSent += 4; await _stream.WriteAsync(frame.GetBuffer(), 0, (int)frame.Length, token); bytesSent += (int)frame.Length; } return(bytesSent); }
public override void FireRead(FrameStream frame, NetworkingPlayer currentPlayer) { // The client has told the server that it is disconnecting if (frame is ConnectionClose) { // Confirm the connection close Send(currentPlayer.TcpClientHandle, new ConnectionClose(Time.Timestep, false, Receivers.Target, MessageGroupIds.DISCONNECT, true)); Disconnect(currentPlayer, false); CommitDisconnects(); return; } // A message has been successfully read from the network so relay that // to all methods registered to the event OnMessageReceived(currentPlayer, frame); }
private void BufferMessageForMissingObject(uint id, byte routerId, FrameStream frame, NetworkingPlayer player) { lock (missingObjectBuffer) { if (!missingObjectBuffer.ContainsKey(id)) { missingObjectBuffer.Add(id, new List <Action <NetworkObject> >()); } missingObjectBuffer[id].Add((networkObject) => { ExecuteRouterAction(routerId, networkObject, (Binary)frame, player); }); } // TODO: If the server is missing an object, it should have a timed buffer // that way useless messages are not setting around in memory }
private void PacketSequenceComplete(BMSByte data, int groupId, byte receivers, bool isReliable) { // Pull the frame from the sent message FrameStream frame = Factory.DecodeMessage(data.CompressBytes(), false, groupId, currentReadingPlayer, receivers); if (isReliable) { frame.ExtractReliableId(); // TODO: If the current reliable index for this player is not at // the specified index, then it needs to wait for the correct ordering currentReadingPlayer.WaitReliable(frame); } else { FireRead(frame, currentReadingPlayer); } }
public async Task <FrameStream> RequestAsync(string messageName, FrameStream frames, CancellationToken token) { var request = WebRequest.CreateHttp(new Uri(_remoteUri, messageName)); request.Method = "POST"; request.ContentType = "avro/binary"; var requestStream = await request.GetRequestStreamAsync(); await frames.CopyToAsync(requestStream); var response = await request.GetResponseAsync(); var result = new FrameStream(); using (var resonseStream = response.GetResponseStream()) await resonseStream.CopyToAsync(result, token); return(result); }
public void NetworkCreateObject(NetWorker networker, int identity, uint id, FrameStream frame, System.Action <NetworkObject> callback) { bool availableCallback = false; NetworkObject obj = null; switch (identity) { case BasicCubeNetworkObject.IDENTITY: availableCallback = true; obj = new BasicCubeNetworkObject(networker, id, frame); callback?.Invoke(obj); break; } if (!availableCallback && callback != null) { callback(obj); } }
public override void Send(FrameStream frame, bool reliable = false) { UDPPacketComposer composer = new UDPPacketComposer(); //如果这个信息是可靠的,那么一定要保持对作曲家的引用 //这样就没有任何失控的线程 // If this message is reliable then make sure to keep a reference to the composer // so that there are not any run-away threads if (reliable) { //使用完成的事件从内存中清理对象 // Use the completed event to clean up the object from memory composer.completed += ComposerCompleted; pendingComposers.Add(composer); } // TODO:在正则构造函数之前设置回调的新构造函数(如上所示) //TODO: New constructor for setting up callbacks before regular constructor (as seen above) composer.Init(this, Server, frame, reliable); }
/// <summary> /// Handle network id requests /// </summary> /// <param name="currentPlayer"></param> /// <param name="frame"></param> private void HandleNetworkIdRequest(NetworkingPlayer currentPlayer, FrameStream frame) { currentPlayer.InstanceGuid = frame.ToString(); // If the player was rejected during the handling of the playerGuidAssigned event, don't accept them. if (!TryPlayerGuidAssignment(currentPlayer)) { return; } // If so, check if there's a user authenticator if (authenticator != null) { authenticator.IssueChallenge(this, currentPlayer, IssueChallenge, AuthUser); } else { AuthUser(currentPlayer); } }
public override void FireRead(FrameStream frame, NetworkingPlayer currentPlayer) { // Check for default messages if (frame is Text) { // This packet is sent if the player did not receive it's network id if (frame.GroupId == MessageGroupIds.NETWORK_ID_REQUEST) { currentPlayer.InstanceGuid = frame.ToString(); bool rejected; OnPlayerGuidAssigned(currentPlayer, out rejected); // If the player was rejected during the handling of the playerGuidAssigned event, don't accept them. if (rejected) { return; } // If so, just resend the player id writeBuffer.Clear(); writeBuffer.Append(BitConverter.GetBytes(currentPlayer.NetworkId)); Send(currentPlayer, new Binary(Time.Timestep, false, writeBuffer, Receivers.Target, MessageGroupIds.NETWORK_ID_REQUEST, false), true); SendBuffer(currentPlayer); return; } } if (frame is ConnectionClose) { //Send(currentReadingPlayer, new ConnectionClose(Time.Timestep, false, Receivers.Server, MessageGroupIds.DISCONNECT, false), false); Disconnect(currentReadingPlayer, true); CleanupDisconnections(); return; } // Send an event off that a packet has been read OnMessageReceived(currentReadingPlayer, frame); }
public override void Send(FrameStream frame, bool reliable = false) { /*//might have to go back to UDP packet composers. needs testing * byte[] data = frame.GetData(reliable); * * Client.Send(data, data.Length, Server.SteamID, reliable ? EP2PSend.k_EP2PSendReliable : EP2PSend.k_EP2PSendUnreliable);*/ SteamP2PPacketComposer composer = new SteamP2PPacketComposer(this, Server, frame, reliable); // If this message is reliable then make sure to keep a reference to the composer // so that there are not any run-away threads if (reliable) { // Use the completed event to clean up the object from memory composer.completed += ComposerCompleted; pendingComposers.Add(composer); } //TODO: New constructor for setting up callbacks before regular constructor (as seen above) //composer.Init(this, Server, frame, reliable); }
public override void FireRead(FrameStream frame, NetworkingPlayer currentPlayer) { if (frame is ConnectionClose) { CloseConnection(); return; } if (frame.GroupId == MessageGroupIds.AUTHENTICATION_CHALLENGE) { if (authenticator != null && (Me == null || !Me.Connected)) { authenticator.AcceptChallenge(this, frame.StreamData, AuthServer, RejectServer); } } else { // Send an event off that a packet has been read OnMessageReceived(currentPlayer, frame); } }
// 检测玩家是否接收该消息 public bool PlayerIsReceiver(NetworkingPlayer player, FrameStream frame, NetworkingPlayer skipPlayer = null) { // 不要将消息发送给尚未被服务器接受的播放器 // Don't send messages to a player who has not been accepted by the server yet if ((!player.Accepted && !player.PendingAccepted) || player == skipPlayer) { return(false); } if (player == frame.Sender) { //如果发送给其他人,则不要发送消息给发送方 // Don't send a message to the sending player if it was meant for others if (frame.Receivers == Receivers.Others || frame.Receivers == Receivers.OthersBuffered || frame.Receivers == Receivers.OthersProximity) { return(false); } } return(true); }
/// <summary> /// A wrapper around the various raw send methods for the client and server types /// </summary> /// <param name="networker">The networker that is going to be sending the data</param> /// <param name="frame">The frame that is to be sent across the network</param> /// <param name="targetPlayer">The player to send the frame to, if null then will send to all</param> public static void SendFrame(NetWorker networker, FrameStream frame, NetworkingPlayer targetPlayer = null) { if (networker is IServer) { if (targetPlayer != null) { if (networker is TCPServer) { ((TCPServer)networker).SendToPlayer(frame, targetPlayer); } else { ((UDPServer)networker).Send(targetPlayer, frame, true); } } else { if (networker is TCPServer) { ((TCPServer)networker).SendAll(frame); } else { ((UDPServer)networker).Send(frame, true); } } } else { if (networker is TCPClientBase) { ((TCPClientBase)networker).Send(frame); } else { ((UDPClient)networker).Send(frame, true); } } }
public async Task <FrameStream> ReceiveAsync(CancellationToken token) { var result = new FrameStream(); var frameSizeBytes = new byte[4]; await ReadBytesAsync(_stream, frameSizeBytes, 0, 4, token); var frameSize = MessageFramingUtil.DecodeLength(frameSizeBytes, 0); if (frameSize == 0) { return(FrameStream.EMPTY); } var frame = new MemoryStream(new byte[frameSize], 0, frameSize, true, true); await ReadBytesAsync(_stream, frame.GetBuffer(), 0, frameSize, token); frame.SetLength(frameSize); result.AppendFrame(frame); return(result); }
public bool Send(TcpClient client, FrameStream frame) #endif { // Make sure that we don't have any race conditions with writing to the same client lock (client) { try { // Get the raw bytes from the frame and send them byte[] data = frame.GetData(); RawWrite(client, data); return(true); } catch { // The client is no longer connected or is unresponsive } } return(false); }
/// <summary> /// 执行消息数据包 /// </summary> /// <param name="frame"></param> /// <param name="currentPlayer">发送消息的玩家</param> public override void FireRead(FrameStream frame, NetworkingPlayer currentPlayer) { //检查默认消息 // Check for default messages if (frame is Text) { //如果播放器没有收到网络标识,则发送此数据包 // This packet is sent if the player did not receive it's network id if (frame.GroupId == MessageGroupIds.NETWORK_ID_REQUEST) { currentPlayer.InstanceGuid = frame.ToString(); OnPlayerGuidAssigned(currentPlayer); //如果是这样,只需重新发送 玩家ID // If so, just resend the player id writeBuffer.Clear(); writeBuffer.Append(BitConverter.GetBytes(currentPlayer.NetworkId)); Send(currentPlayer, new Binary(Time.Timestep, false, writeBuffer, Receivers.Target, MessageGroupIds.NETWORK_ID_REQUEST, false), true); SendBuffer(currentPlayer); return; } } // 踢该玩家 if (frame is ConnectionClose) { //Send(currentReadingPlayer, new ConnectionClose(Time.Timestep, false, Receivers.Server, MessageGroupIds.DISCONNECT, false), false); Disconnect(currentReadingPlayer, true); CleanupDisconnections(); return; } //发送一个事件关闭已经被读取的数据包 // Send an event off that a packet has been read OnMessageReceived(currentReadingPlayer, frame); }
public virtual void SendFrame(FrameStream pFrame, NetworkingPlayer pTargetPlayer = null) { if (_networker is IServer) { if (pTargetPlayer != null) { if (_networker is TCPServer) { ((TCPServer)_networker).SendToPlayer(pFrame, pTargetPlayer); } else { ((UDPServer)_networker).Send(pTargetPlayer, pFrame, true); } } else { if (_networker is TCPServer) { ((TCPServer)_networker).SendAll(pFrame); } else { ((UDPServer)_networker).Send(pFrame, true); } } } else { if (_networker is TCPClientBase) { ((TCPClientBase)_networker).Send(pFrame); } else { ((UDPClient)_networker).Send(pFrame, true); } } }
/// <summary> /// A wrapper around the various raw send methods for the client and server types /// </summary> /// <param name="networker">The networker that is going to be sending the data</param> /// <param name="frame">The frame that is to be sent across the network</param> /// <param name="targetPlayer">The player to send the frame to, if null then will send to all</param> public static void SendFrame(NetWorker networker, FrameStream frame, NetworkingPlayer targetPlayer = null) { ///if (networker is IServer) if (NetworkManager.Instance.IsMaster) { if (targetPlayer != null) { if (networker is TCPServer) { ((TCPServer)networker).SendToPlayer(frame, targetPlayer); } else { ((UDPServer)networker).Send(targetPlayer, frame, true); } } else { if (networker is TCPServer) { ((TCPServer)networker).SendAll(frame); } else { ((UDPServer)networker).Send(frame, true); } } } else { /* * if (networker is TCPClientBase) * ((TCPClientBase)networker).Send(frame); * else * ((UDPClient)networker).Send(frame, true); */ } }
public void UpdateStep() { if (!IsBound) { CheckConnection(); return; } int length = ForgeContainsData(); if (length == 0) { return; } IntPtr ptr = ForgeShiftDataRead(); byte[] bytes = new byte[length]; Marshal.Copy(ptr, bytes, 0, bytes.Length); if (bytes.Length > 0) { byte messageType = 130; // Get the frame that was sent by the server, the server // does not send masked data, only the client so send false for mask //获取由服务器,服务器发送的帧 //不发送被屏蔽的数据,只有客户端发送false为掩码 FrameStream frame = Factory.ReadFrameStream(messageType, bytes, 0, MessageGroupIds.TCP_FIND_GROUP_ID, Server); // A message has been successfully read from the network so relay that // to all methods registered to the event //已成功从网络读取消息,以便中继 //注册到事件的所有方法 OnMessageReceived(Server, frame); } }
private void PacketSequenceComplete(BMSByte data, int groupId, byte receivers) { // Pull the frame from the sent message FrameStream frame = Factory.DecodeMessage(data.CompressBytes(), false, groupId, currentReadingPlayer, receivers); // Check for default messages if (frame is Text) { // This packet is sent if the player did not receive it's network id if (frame.GroupId == MessageGroupIds.NETWORK_ID_REQUEST) { currentReadingPlayer.InstanceGuid = frame.ToString(); OnPlayerGuidAssigned(currentReadingPlayer); // If so, just resend the player id writeBuffer.Clear(); writeBuffer.Append(BitConverter.GetBytes(currentReadingPlayer.NetworkId)); Send(currentReadingPlayer, new Binary(Time.Timestep, false, writeBuffer, Receivers.Target, MessageGroupIds.NETWORK_ID_REQUEST, false), true); SendBuffer(currentReadingPlayer); return; } } if (frame is ConnectionClose) { Send(currentReadingPlayer, new ConnectionClose(Time.Timestep, false, Receivers.Server, MessageGroupIds.DISCONNECT, false), false); Disconnect(currentReadingPlayer, false); CleanupDisconnections(); return; } // Send an event off that a packet has been read OnMessageReceived(currentReadingPlayer, frame); }
public void Send(FrameStream frame, bool reliable = false, NetworkingPlayer skipPlayer = null) { if (frame.Receivers == Receivers.AllBuffered || frame.Receivers == Receivers.OthersBuffered) { bufferedMessages.Add(frame); } lock (Players) { foreach (NetworkingPlayer player in Players) { if (!commonServerLogic.PlayerIsReceiver(player, frame, ProximityDistance, skipPlayer, ProximityModeUpdateFrequency)) { continue; } try { Send(player, frame, reliable); } catch { Disconnect(player, true); } } } }
private void HandleBinaryFrameMessage(FrameStream frame, NetworkingPlayer player) { byte routerId = ((Binary)frame).RouterId; if (routerId == RouterIds.RPC_ROUTER_ID || routerId == RouterIds.BINARY_DATA_ROUTER_ID || routerId == RouterIds.CREATED_OBJECT_ROUTER_ID) { uint id = frame.StreamData.GetBasicType <uint>(); NetworkObject targetObject = null; lock (NetworkObjects) { NetworkObjects.TryGetValue(id, out targetObject); } if (targetObject == null) { BufferMessageForMissingObject(id, routerId, frame, player); } else { ExecuteRouterAction(routerId, targetObject, (Binary)frame, player); } } else if (routerId == RouterIds.NETWORK_OBJECT_ROUTER_ID) { NetworkObject.CreateNetworkObject(this, player, (Binary)frame); } else if (routerId == RouterIds.ACCEPT_MULTI_ROUTER_ID) { NetworkObject.CreateMultiNetworkObject(this, player, (Binary)frame); } else if (binaryMessageReceived != null) { binaryMessageReceived(player, (Binary)frame, this); } }
public override void FireRead(FrameStream frame, NetworkingPlayer currentPlayer) { if (frame.GroupId == MessageGroupIds.AUTHENTICATION_CHALLENGE) { if ((Me != null && Me.Connected) || authenticator == null) { return; } authenticator.AcceptChallenge(this, frame.StreamData, AuthServer, RejectServer); return; } if (frame.GroupId == MessageGroupIds.AUTHENTICATION_FAILURE) { Logging.BMSLog.LogWarning("The server rejected the authentication attempt"); // Wait for the second message (Disconnect) return; } // A message has been successfully read from the network so relay that // to all methods registered to the event OnMessageReceived(currentPlayer, frame); }
public bool PlayerIsReceiver(NetworkingPlayer player, FrameStream frame, float proximityDistance, NetworkingPlayer skipPlayer = null, int proximityModeUpdateFrequency = 0) { // Don't send messages to a player who has not been accepted by the server yet if ((!player.Accepted && !player.PendingAccepted) || player == skipPlayer) { return(false); } if (player == frame.Sender) { // Don't send a message to the sending player if it was meant for others if (frame.Receivers == Receivers.Others || frame.Receivers == Receivers.OthersBuffered || frame.Receivers == Receivers.OthersProximity || frame.Receivers == Receivers.OthersProximityGrid) { return(false); } } // check if sender is null as it doesn't get sent in certain cases if (frame.Sender != null) { return(PlayerIsDistanceReceiver(frame.Sender, player, frame, proximityDistance, proximityModeUpdateFrequency)); } return(true); }
public WhaleburtNetworkNetworkObject(NetWorker networker, uint serverId, FrameStream frame) : base(networker, serverId, frame) { Initialize(); }