/// <inheritdoc/> public void SendSingleData(TPacketId packetId, IPacketData packetData, params ushort[] playerIds) { foreach (var playerId in playerIds) { SendSingleData(packetId, packetData, playerId); } }
public void SendMessage(MyMessageId id, IPacketData data, bool reliable, List <EndpointId> endpoints, byte index = 0) { MyNetworkWriter.MyPacketDescriptor packet = this.InitSendStream(EndpointId.Null, reliable ? MyP2PMessageEnum.ReliableWithBuffering : MyP2PMessageEnum.Unreliable, id, index); packet.Recipients.AddRange(endpoints); packet.Data = data; MyNetworkWriter.SendPacket(packet); }
/// <inheritdoc/> public void BroadcastSingleData(TPacketId packetId, IPacketData packetData) { if (!_netServer.IsStarted) { throw new InvalidOperationException(ServerNotStartedExceptionMsg); } if (!PacketIdLookup.TryGetValue(packetId, out var idValue)) { throw new InvalidOperationException( PacketIdInvalidExceptionMsg); } if (!_serverAddon.Id.HasValue) { throw new InvalidOperationException(NoAddonIdMsg); } _netServer.SetDataForAllClients(updateManager => { updateManager?.SetAddonData( _serverAddon.Id.Value, idValue, _packetIdSize, packetData ); }); }
/// <inheritdoc/> public void SendSingleData(TPacketId packetId, IPacketData packetData) { if (!_netClient.IsConnected) { throw new InvalidOperationException(NotConnectedMsg); } if (!PacketIdLookup.TryGetValue(packetId, out var idValue)) { throw new InvalidOperationException( InvalidPacketIdMsg); } if (!_clientAddon.Id.HasValue) { throw new InvalidOperationException(NoClientAddonId); } _netClient.UpdateManager.SetAddonData( _clientAddon.Id.Value, idValue, _packetIdSize, packetData ); }
/// <summary> /// Execute the packet handler for the client addon data. /// </summary> /// <param name="addonId">The ID of the addon.</param> /// <param name="packetId">The ID of the packet data for the addon.</param> /// <param name="packetData">The packet data instance.</param> private void ExecuteClientAddonPacketHandler( byte addonId, byte packetId, IPacketData packetData ) { var addonPacketIdMessage = $"for addon ID: {addonId} and packet ID: {packetId}"; var noHandlerWarningMessage = $"There is no client addon packet handler registered {addonPacketIdMessage}"; if (!_clientAddonPacketHandlers.TryGetValue(addonId, out var addonPacketHandlers)) { Logger.Get().Warn(this, noHandlerWarningMessage); return; } if (!addonPacketHandlers.TryGetValue(packetId, out var handler)) { Logger.Get().Warn(this, noHandlerWarningMessage); return; } // Invoke the packet handler on the Unity main thread ThreadUtil.RunActionOnMainThread(() => { try { handler.Invoke(packetData); } catch (Exception e) { Logger.Get().Error(this, $"Exception occurred while executing client addon packet handler {addonPacketIdMessage}, type: {e.GetType()}, message: {e.Message}, stacktrace: {e.StackTrace}"); } }); }
/// <inheritdoc/> public void SendSingleData(TPacketId packetId, IPacketData packetData, ushort playerId) { if (!_netServer.IsStarted) { throw new InvalidOperationException(ServerNotStartedExceptionMsg); } if (!PacketIdLookup.TryGetValue(packetId, out var idValue)) { throw new InvalidOperationException( PacketIdInvalidExceptionMsg); } var updateManager = _netServer.GetUpdateManagerForClient(playerId); if (updateManager == null) { throw new InvalidOperationException($"Player with ID '{playerId}' is not connected"); } if (!_serverAddon.Id.HasValue) { throw new InvalidOperationException(NoAddonIdMsg); } updateManager.SetAddonData( _serverAddon.Id.Value, idValue, _packetIdSize, packetData ); }
/// <summary> /// Execute the packet handler for the server addon data from a client. /// </summary> /// <param name="id">The ID of the client.</param> /// <param name="addonId">The ID of the addon.</param> /// <param name="packetId">The ID of the packet data for the addon.</param> /// <param name="packetData">The packet data instance.</param> private void ExecuteServerAddonPacketHandler( ushort id, byte addonId, byte packetId, IPacketData packetData ) { var addonPacketIdMessage = $"for addon ID: {addonId} and packet ID: {packetId}"; var noHandlerWarningMessage = $"There is no server addon packet handler registered {addonPacketIdMessage}"; if (!_serverAddonPacketHandlers.TryGetValue(addonId, out var addonPacketHandlers)) { Logger.Get().Warn(this, noHandlerWarningMessage); return; } if (!addonPacketHandlers.TryGetValue(packetId, out var handler)) { Logger.Get().Warn(this, noHandlerWarningMessage); return; } // Invoke the packet handler for this ID directly, in contrast to the client packet handling. // We don't do anything game specific with server packet handler, so there's no need to do it // on the Unity main thread try { handler.Invoke(id, packetData); } catch (Exception e) { Logger.Get().Error(this, $"Exception occurred while executing server addon packet handler {addonPacketIdMessage}, type: {e.GetType()}, message: {e.Message}, stacktrace: {e.StackTrace}"); } }
public void Reset() { if (this.Data != null) { this.Data.Return(); } this.Header.Position = 0L; this.Data = null; this.Recipients.Clear(); }
public static TPKGHead CreateMessage(AsyncSocketConnection agent, IPacketData data) { TPKGHead ts = new TPKGHead() { Data = data, Major_Ver = 1, Minor_Ver = 1, Term_Code = agent.TerminalId, }; return(ts); }
private static void Split(MyPacketDescriptor packet) { int offset = 0xf4240 - ((int)packet.Header.Position); int size = packet.Data.Size; while (offset < size) { int num3 = Math.Min(size - offset, 0xf4240); IPacketData item = (packet.Data.Data == null) ? GetPacketData(packet.Data.Ptr, offset, num3) : GetPacketData(packet.Data.Data, offset, num3); m_packetsTmp.Add(item); offset += num3; } }
public static TPKGHead CreateResponseMessage(TPKGHead msg, IPacketData data) { TPKGHead ts = new TPKGHead() { Data = data, Major_Ver = 1, Minor_Ver = 1, SessionId = msg.SessionId, Seq_Id = ++msg.Seq_Id, Term_Code = msg.Term_Code, }; return(ts); }
public override Task Invoke(IPacketData context) { try { var json = JsonConvert.SerializeObject(context); var eventData = new EventData(Encoding.UTF8.GetBytes(json)); return _eventHubClient.SendAsync(eventData); } catch (Exception) { // todo: log? } return Task.FromResult(false); }
/** * Executes the correct packet handler corresponding to this packet. * Assumes that the packet is not read yet. */ private void ExecuteServerPacketHandler(ushort id, ServerPacketId packetId, IPacketData packetData) { if (!_serverPacketHandlers.ContainsKey(packetId)) { Logger.Get().Warn(this, $"There is no server packet handler registered for ID: {packetId}"); return; } // Invoke the packet handler for this ID directly, in contrast to the client packet handling. // We don't do anything game specific with server packet handler, so there's no need to do it // on the Unity main thread try { _serverPacketHandlers[packetId].Invoke(id, packetData); } catch (Exception e) { Logger.Get().Error(this, $"Exception occured while executing server packet handler for packet ID: {packetId}, message: {e.Message}, stacktrace: {e.StackTrace}"); } }
/// <summary> /// Executes the correct packet handler corresponding to this packet data. /// </summary> /// <param name="packetId">The client packet ID for this data.</param> /// <param name="packetData">The packet data instance.</param> private void ExecuteClientPacketHandler(ClientPacketId packetId, IPacketData packetData) { if (!_clientPacketHandlers.ContainsKey(packetId)) { Logger.Get().Warn(this, $"There is no client packet handler registered for ID: {packetId}"); return; } // Invoke the packet handler for this ID on the Unity main thread ThreadUtil.RunActionOnMainThread(() => { try { _clientPacketHandlers[packetId].Invoke(packetData); } catch (Exception e) { Logger.Get().Error(this, $"Exception occured while executing client packet handler for packet ID: {packetId}, message: {e.Message}, stacktrace: {e.StackTrace}"); } }); }
/// <summary> /// Find or create a packet data instance in the current packet that matches the given ID of a client. /// </summary> /// <param name="id">The ID of the client in the generic client data.</param> /// <param name="packetId">The ID of the packet data.</param> /// <typeparam name="T">The type of the generic client packet data.</typeparam> /// <returns>An instance of the packet data in the packet.</returns> private T FindOrCreatePacketData <T>(ushort id, ClientPacketId packetId) where T : GenericClientData, new() { PacketDataCollection <T> packetDataCollection; IPacketData packetData = null; // First check whether there actually exists a data collection for this packet ID if (CurrentUpdatePacket.TryGetSendingPacketData(packetId, out var iPacketDataAsCollection)) { // And if so, try to find the packet data with the requested client ID packetDataCollection = (PacketDataCollection <T>)iPacketDataAsCollection; foreach (var existingPacketData in packetDataCollection.DataInstances) { if (((GenericClientData)existingPacketData).Id == id) { packetData = existingPacketData; break; } } } else { // If no data collection exists, we create one instead packetDataCollection = new PacketDataCollection <T>(); CurrentUpdatePacket.SetSendingPacketData(packetId, packetDataCollection); } // If no existing instance was found, create one and add it to the (newly created) collection if (packetData == null) { packetData = new T { Id = id }; packetDataCollection.DataInstances.Add(packetData); } return((T)packetData); }
private void SendClientUpdate(IPacketData data) { TransportLayer.SendMessage(MyMessageId.CLIENT_UPDATE, data, false, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index); }
private void SendClientAcks(IPacketData data) { TransportLayer.SendMessage(MyMessageId.CLIENT_ACKS, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index); }
/// <summary> /// Sets the given packetData with the given packet ID for sending. /// </summary> /// <param name="packetId">The packet ID to set data for.</param> /// <param name="packetData">The packet data to set.</param> public void SetSendingPacketData(T packetId, IPacketData packetData) { _normalPacketData[packetId] = packetData; }
/// <summary> /// Tries to get packet data that is going to be sent with the given packet ID. /// </summary> /// <param name="packetId">The packet ID to try and get.</param> /// <param name="packetData">Variable to store the retrieved data in. Null if this method returns false.</param> /// <returns>true if the packet data exists and will be stored in the packetData variable; otherwise /// false.</returns> public bool TryGetSendingPacketData(T packetId, out IPacketData packetData) { return(_normalPacketData.TryGetValue(packetId, out packetData)); }
public override Task Invoke(IPacketData context) { var line = string.Format("[{0}: {1}] {2}", context.Timestamp, context.Sender, context.Data); Trace.WriteLine(line); return Next.Invoke(context); }
void IReplicationServerCallback.SendWorldData(IPacketData data, List <EndpointId> endpoints) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.WORLD_DATA, data, true, endpoints, 0); }
private void SendReplicableReady(IPacketData data) { TransportLayer.SendMessage(MyMessageId.REPLICATION_READY, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index); }
void IReplicationServerCallback.SendReplicationDestroy(IPacketData data, List <EndpointId> endpoints) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_DESTROY, data, true, endpoints, 0); }
void IReplicationServerCallback.SendStateSync(IPacketData data, Endpoint endpoint, bool reliable) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.SERVER_STATE_SYNC, data, reliable, endpoint.Id, endpoint.Index); }
private void ProcessPacket(string packet, IPacketData context) { ParsedPacket parsedPacket; var packetResult = PacketParser.TryParse(packet, out parsedPacket); if (packetResult != PacketParseResult.Ok) { IncCounter(string.Format(StatsdServiceStatConstants.PacketBadFormat, _config.ServiceStatsPrefix)); return; } Func<ParsedPacket, bool> handler; if (!_handlers.TryGetValue(parsedPacket.MetricType, out handler)) { IncCounter(string.Format(StatsdServiceStatConstants.PacketBadFormat, _config.ServiceStatsPrefix)); return; } if (!handler(parsedPacket)) { IncCounter(string.Format(StatsdServiceStatConstants.PacketBadFormat, _config.ServiceStatsPrefix)); } IncCounter(string.Format(StatsdServiceStatConstants.MetricsCountFormat, _config.ServiceStatsPrefix)); }
public abstract Task Invoke(IPacketData context);
void IReplicationServerCallback.SentClientJoined(IPacketData data, EndpointId endpoint) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.CLIENT_CONNNECTED, data, true, endpoint, 0); }
private void SendConnectRequest(IPacketData data) { TransportLayer.SendMessage(MyMessageId.CLIENT_CONNNECTED, data, true, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index); }
void IReplicationServerCallback.SendServerData(IPacketData data, Endpoint endpoint) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.SERVER_DATA, data, true, endpoint.Id, endpoint.Index); }
private void SendEvent(IPacketData data, bool reliable) { TransportLayer.SendMessage(MyMessageId.RPC, data, reliable, new EndpointId(Sync.ServerId), this.m_clientState.EndpointId.Index); }
void IReplicationServerCallback.SendReplicationIslandDone(IPacketData data, Endpoint endpoint) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_ISLAND_DONE, data, true, endpoint.Id, endpoint.Index); }
public Task Invoke(IPacketData context) { IncCounter(string.Format(StatsdServiceStatConstants.PacketCountFormat, _config.ServiceStatsPrefix)); IEnumerable<string> packets; if (context.Data.Contains("\n")) { packets = context.Data.Split('\n'); } else { packets = new[] { context.Data }; } foreach (var packet in packets.Where(i => !string.IsNullOrWhiteSpace(i)).Select(i=>i.Replace("\r", ""))) { ProcessPacket(packet, context); } // Done return Task.FromResult(true); }
void IReplicationServerCallback.SendWorld(IPacketData data, EndpointId endpoint) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.WORLD, data, true, endpoint, 0); }
void IReplicationServerCallback.SendJoinResult(IPacketData data, EndpointId endpoint) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.JOIN_RESULT, data, true, endpoint, 0); }
void IReplicationServerCallback.SendReplicationCreateStreamed(IPacketData data, Endpoint endpoint) { base.SyncLayer.TransportLayer.SendMessage(MyMessageId.REPLICATION_STREAM_BEGIN, data, true, endpoint.Id, endpoint.Index); }
public void Parse(Encoder s) { packetType = s.Read<PacketType>(); reserved1 = s.ReadByte(); reserved2 = s.ReadByte(); reserved3 = s.ReadByte(); packetId = s.Read<PacketId>(); reserved = s.ReadUshort(); dataSize = s.ReadUint(); switch (packetId) { case PacketId.StartSession: data = new PSessionStarted(); data.Parse(s); break; case PacketId.ProductData: data = new PProductData(); data.Parse(s); break; case PacketId.ProtocolArray: data = new PProtocolArray(); data.Parse(s); break; case PacketId.RecordCount: data = new PRecords(); data.Parse(s); break; case PacketId.TrackData: data = new PTrkData(); data.Parse(s); break; case PacketId.TrackHeader: data = new PTrackHeader(); data.Parse(s); break; case PacketId.TransferComplete: data = new PXferComplete(); data.Parse(s); break; case PacketId.CourseTrackData: data = new PTrkData(); data.Parse(s); break; } }
public override Task Invoke(IPacketData context) { return Task.FromResult(true); }