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