private void OnPacketReceived(Packet packet)
{
if (packet is PingPacket pingPacket)
{
PingResponsePacket pingResponsePacket = new PingResponsePacket(pingPacket.GetPingId());
karmanClient.Send(pingResponsePacket);
}
}
private void udpNetworking_PacketWasReceived(Clutch.Net.UDP.UDPPacketBuffer udpPacketBuffer)
{
try
{
IPacket packet = PacketTypeChecker.GetPacket(udpPacketBuffer.Data);
if (PacketReceivedEvent != null)
PacketReceivedEvent(packet);
switch (packet.PacketType)
{
case PacketTypeEnumeration.PingRequest:
PingResponsePacket pingResponsePacket = new PingResponsePacket();
if (playerIdField.HasValue)
{
pingResponsePacket.PlayerId = playerIdField.Value;
pingResponsePacket.PacketId = packetIdCounter.Next();
pingResponsePacket.TimeStamp = DateTime.Now;
udpNetworking.SendPacket(pingResponsePacket.ToByte());
}
break;
case PacketTypeEnumeration.StandardServerPacket:
bool start = false;
if (last10Packeges.LastPacket == null)
start = true;
else
{
try
{
if (last10Packeges.LastPacket.PacketId.Value == packet.PacketId.Value)
{
//the same packet - ignore it
Diagnostic.NetworkingDiagnostics.Logging.Warn("Old ServerPacket was received and ignored id" + packet.PacketId);
return;
}
else if (last10Packeges.LastPacket.PacketId > packet.PacketId)
{
// old packet received
Diagnostic.NetworkingDiagnostics.Logging.Warn("Old ServerPacket was received and ignored id" + packet.PacketId);
List<Interfaces.IGameplayEvent> gpEvents = GameEvents.GameEventExtractor.GetGameplayEvents((ServerPacket)packet, null, playerIdField);
lock (gameplayEventListLock)
{
for (int i = 0; i < gpEvents.Count; i++)
gameplayEventList.Add(gpEvents[i]);
}
return;
}
}
catch (Usefull.IdCompareException idEx)
{
Diagnostic.NetworkingDiagnostics.Logging.Error("Error when comparing id " + packet.PacketId + " with id " + last10Packeges.LastPacket.PacketId, idEx);
return;
}
}
List<Interfaces.IGameplayEvent> gameplayEvents = GameEvents.GameEventExtractor.GetGameplayEvents((ServerPacket)packet, (ServerPacket)last10Packeges.LastPacket, playerIdField);
lock (gameplayEventListLock)
{
for (int i = 0; i < gameplayEvents.Count; i++)
gameplayEventList.Add(gameplayEvents[i]);
}
if (start)
{
lock (gameEventListLock)
{
gameEventList.Add(new GameEvents.GameStartedEvent());
}
}
last10Packeges.AddPacket(packet);
break;
case PacketTypeEnumeration.GameInfoPacket:
GameInfoPacket gameInfoPacket = (GameInfoPacket)packet;
lock (gameInfoPacketsLock)
{
if (gameInfoPackets.ContainsKey(gameInfoPacket.GameId))
{
if (gameInfoPackets[gameInfoPacket.GameId].LastPacket.PacketId > packet.PacketId || gameInfoPackets[gameInfoPacket.GameId].LastPacket.PacketId == packet.PacketId)
{
Diagnostic.NetworkingDiagnostics.Logging.Warn("Old GameInfoPacket was received and ignored");
return;
}
gameInfoPackets[gameInfoPacket.GameId].AddPacket(gameInfoPacket);
}
else
{
gameInfoPackets.Add(gameInfoPacket.GameId, new UDPClientServerCommons.Usefull.Last10Packages());
gameInfoPackets[gameInfoPacket.GameId].AddPacket(gameInfoPacket);
}
//if this is my game - get events
if (gameIdField.HasValue && gameInfoPacket.GameId == gameIdField.Value)
{
List<IGameEvent> gameEvents = GameEvents.GameEventExtractor.GetGameEvents(gameInfoPacket, (GameInfoPacket)gameInfoPackets[gameIdField.Value].GetPrevious(2), playerIdField);
lock (gameInfoPacketsLock)
{
for (int i = 0; i < gameEvents.Count; i++)
gameEventList.Add(gameEvents[i]);
}
}
}
//if this is my game - update player status'es
if (gameIdField.HasValue && gameInfoPacket.GameId == gameIdField)
{
for (int i = 0; i < gameInfoPacket.PlayerStatusList.Count; i++)
{
if (gameInfoPacket.PlayerStatusList[i].PlayerName == playerNameField)
{
lock (clientPacketLock)
{
playerIdField = gameInfoPacket.PlayerStatusList[i].PlayerId;
teamIdField = gameInfoPacket.PlayerStatusList[i].PlayerTeam;
}
break;
}
}
}
break;
}
}
catch (Exception ex)
{
Diagnostic.NetworkingDiagnostics.Logging.Error("Packet was received", ex);
}
}
/// <summary>
/// 向服务器发送ServerListPing相关的包并解析返回的json
/// </summary>
/// <exception cref="ArgumentNullException"/>
/// <exception cref="InvalidPacketException"/>
/// <exception cref="SocketException"/>
/// <exception cref="PacketException"/>
/// <exception cref="JsonException"/>
public PingReply Send(Socket socket, bool reuseSocket)
{
if (socket == null)
{
throw new ArgumentNullException(nameof(socket));
}
PingReply PingResult; string JsonResult;
if (EnableDnsRoundRobin && IPAddressList != null && IPAddressList.Length > 1)
{
DnsRoundRobinHandler();
}
if (!socket.Connected)
{
socket.Connect(ServerIP, this.ServerPort);
}
if (ReceiveTimeout != default)
{
socket.ReceiveTimeout = ReceiveTimeout;
}
//Send Ping Packet
Packet Handshake = new HandshakePacket(string.IsNullOrWhiteSpace(Host) ? ServerIP.ToString() : Host, this.ServerPort, -1, HandshakePacket.State.GetStatus);
socket.Send(Handshake.ToBytes());
Packet PingRequest = new PingRequestPacket();
socket.Send(PingRequest.ToBytes());
//Receive Packet
int PacketLength = ProtocolHandler.GetPacketLength(socket);
if (PacketLength > 0)
{
List <byte> Packet = new List <byte>(ProtocolHandler.ReceiveData(0, PacketLength, socket));
int PacketID = ProtocolHandler.ReadVarInt(Packet);
if (PacketID != PingResponsePacket.GetPacketID())
{
throw new InvalidPacketException("Invalid ping response packet id ", new Packet(PacketID, Packet));
}
JsonResult = ProtocolHandler.ReadString(Packet);
if (!string.IsNullOrWhiteSpace(JsonResult))
{
PingResult = ResolveJson(JsonResult);
PingResult.Elapsed = EnableDelayDetect ? GetTime(socket) : null;
PingResult.Json = JsonResult;
}
else
{
PingResult = null;
}
socket.Shutdown(SocketShutdown.Both);
socket.Disconnect(reuseSocket);
}
else
{
throw new PacketException($"Response Packet Length too Small (PacketLength:{PacketLength})");
}
return(PingResult);
}