public override void SendPacket(List <ServerPlayer> players, IBasePacket packet) { foreach (var player in players) { SendPacket(player, packet); } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (packet is FileSync fileSync && fileSync.SyncType == FileSync.FileSyncType.Request) { if (fileSync.Files.Count == 0) { return; } var file = FileSystem.GetFileInfo(fileSync.Files[0].RelativePath); if (file == null) { return; } var fu = new FileUpload(); fu.InputStream = new FileStream(file.FullPath, FileMode.Open, FileAccess.Read); fu.File = file.RelativePath; fu.ClientIndex = player.ClientIndex; fu.ChunkLength = ((ServerPlayer)player).MTU - 20; fu.SentOffset = 0; _uploads.Add(fu); } }
public override void SendPacket(ServerPlayer player, IBasePacket packet) { if (FindPeer(player, out NetPeer peer)) { _SendPacket(peer, packet); } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (packet is UserCmd cmd) { HandleUserCommand(player, cmd); } }
public static void SendWithErrorAnswer(IBasePacket data) { Protocol.SendTcp(Server, data); while (true) { var packet = Protocol.ReceiveTcp(Server); switch (packet) { case PingPacket: Protocol.SendTcp(Server, new PingPacket()); continue; case ErrorPacket error: throw new Exception(error.Error.ToString()); break; } if (packet is Ok) { return; } throw new Exception("Unexpected command received"); } }
public static void PutPacket(IBasePacket packet) { if (packet.DisableAutoPool) { return; } packet.Reset(); var t = packet.GetType(); if (!_pool.ContainsKey(t)) { _pool[t] = new Queue <IBasePacket>(maxPoolSize); } if (_pool[t].Count < maxPoolSize) { if (_pool[t].Contains(packet)) { UnityEngine.Debug.LogException(new System.Exception("Pooling a packet that is already pooled: " + t)); } else { _pool[t].Enqueue(packet); } } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (packet is FileSync fileSync) { _filesToSync = new List <FSFileInfo>(fileSync.Files); } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (packet is ChatMessage chatMessage) { if (chatMessage.Message.Length < 1) { return; } if (Game.IsHost) { if (chatMessage.Message.Length > MaxMessageLength) { chatMessage.Message = chatMessage.Message.Substring(0, MaxMessageLength); } if (chatMessage.Message[0] == CommandChar) { ParseCommand(player, chatMessage.Message); } else { var msgToSend = PacketUtility.TakePacket <ChatMessage>(); msgToSend.ClientIndex = player.ClientIndex; msgToSend.Name = player.DisplayName; msgToSend.Message = chatMessage.Message; msgToSend.Scope = chatMessage.Scope; msgToSend.SupporterLevel = chatMessage.SupporterLevel; Game.Network.BroadcastPacket(msgToSend); } } OnMessageReceived?.Invoke(chatMessage, chatMessage.Name, chatMessage.Message, chatMessage.ClientIndex == -1); } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (!Game.IsHost && packet is PlaySound playSound) { Emit(playSound.Event, playSound.Twod, playSound.Position); } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { switch (packet) { case PlayerIntroduction intro: ProcessPlayerIntroduction(player, intro); break; case FileSync fileSync: switch (fileSync.SyncType) { case FileSync.FileSyncType.Initiate: SendFileSync((ServerPlayer)player); break; } break; case MapChange mapChange: SendMapChange((ServerPlayer)player); break; case ChooseTeam chooseTeam: Game.PlayerManager.SetPlayerTeam(player, chooseTeam.TeamNumber); break; case PlayerEvent pe: if (pe.EventType == PlayerEventType.Spectate) { var spectator = Game.PlayerManager.FindPlayer(pe.ClientIndex); Game.PlayerManager.SetPlayerSpectateTarget(spectator, Game.PlayerManager.FindPlayer(pe.SpecTarget)); } break; } }
private void GetP2PPacket(IBasePacket packet, out byte[] data, out int dataLength, out int channel, out SendType send) { _buffer.Position = 0; _buffer.LengthBytes = 0; SocketMan.WritePacketHeader(_buffer, packet); packet.Write(_buffer); send = SendType.Unreliable; switch (packet.Sc.DeliveryMethod) { case NetDeliveryMethod.ReliableSequenced: case NetDeliveryMethod.ReliableOrdered: case NetDeliveryMethod.ReliableUnordered: send = SendType.Reliable; break; case NetDeliveryMethod.Unreliable: case NetDeliveryMethod.UnreliableSequenced: send = SendType.Unreliable; break; } data = _buffer.Data; dataLength = _buffer.LengthBytes; //channel = packet.Sc.SequenceChannel; channel = 1; if (packet.Sc == SendCategory.FileTransfer) { send = SendType.Reliable; channel = 2; } }
public void ParsePacket(IBaseProtocol<IBasePacket<IBaseOpcode>, IBaseOpcode> protocol, IBasePacket<IBaseOpcode> pPacket) { mTree.Nodes.Clear(); mSubNodes.Clear(); pPacket.Rewind(); string scriptPath = Application.StartupPath + Path.DirectorySeparatorChar + "Scripts" + Path.DirectorySeparatorChar + protocol.GetScriptLocation(pPacket); string commonPath = Application.StartupPath + Path.DirectorySeparatorChar + "Scripts" + Path.DirectorySeparatorChar + protocol.GetCommonScriptLocation(); if (File.Exists(scriptPath)) { mParsing = pPacket; try { StringBuilder scriptCode = new StringBuilder(); scriptCode.Append(File.ReadAllText(scriptPath)); if (File.Exists(commonPath)) scriptCode.Append(File.ReadAllText(commonPath)); Script script = Script.Compile(scriptCode.ToString()); script.Context.SetItem("ScriptAPI", new ScriptAPI(this)); script.Execute(); } catch (Exception exc) { OutputForm output = new OutputForm("Script Error"); output.Append(exc.ToString()); output.Show(DockPanel, new Rectangle(MainForm.Location, new Size(400, 400))); } mParsing = null; } if (pPacket.Remaining > 0) mTree.Nodes.Add(new StructureNode("Undefined", pPacket.Buffer, pPacket.Cursor, pPacket.Remaining)); }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (Game.IsHost || !(packet is FileChunk chunk)) { return; } ReceiveChunk(chunk); }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { switch (packet) { case PlayerEvent playerEvent: IncomingPlayerEvent(playerEvent); break; } }
public ScriptForm(string pPath, IBasePacket<IBaseOpcode> pPacket) { mPath = pPath; Packet = pPacket; InitializeComponent(); if (pPacket != null) Text = "Script " + pPacket.GetDisplayName() + ", " + (pPacket.Outbound ? "Outbound" : "Inbound"); else Text = "Common Script"; }
public void OnReceivePlayerPacket(IBasePacket packet, ServerPlayer player) { if (!(packet is CustomPacket)) { InvokeEventSubscriptions("OnReceivePlayerPacket", packet, player); } else { InvokeEventSubscriptions("OnReceiveCustomPacket", packet, player); } }
public void HandlePacket(IBasePacket packet) { var authPacket = packet as PythonPacket; if (authPacket == null) { return; } PacketRouter.RoutePacket(_handler, authPacket); }
public void EnqueueOutgoing(INetworkClient client, IBasePacket data) { var packet = new QueuedPacket { Client = client, Packet = data }; lock (_outgoingQueue) _outgoingQueue.Enqueue(packet); }
private bool PacketIsWaiting(IBasePacket packet) { foreach (var asyncWait in _waitingPackets) { if (asyncWait.Packet == packet) { return(true); } } return(false); }
public void HandlePacket(IBasePacket packet) { var authPacket = packet as IOpcodedPacket <ClientOpcode>; if (authPacket == null) { return; } PacketRouter.RoutePacket(this, authPacket); }
public override void SendPacket(List <ServerPlayer> players, IBasePacket packet) { GetP2PPacket(packet, out byte[] data, out int dataLength, out int channel, out SendType type); foreach (var player in SocketMan.Game.PlayerManager.Players) { if (player.Introduced) { SendPacket(player.SteamId, data, dataLength, type); } } }
protected unsafe override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (!(packet is CompressedVoiceData voicePacket)) { return; } if (Game.IsHost) { var packetToSend = PacketUtility.TakePacket <CompressedVoiceData>(); packetToSend.SetData(voicePacket.Data, voicePacket.DataLength); packetToSend.ClientIndex = player.ClientIndex; Server.GameServer.Instance.Socket.BroadcastPacket(packetToSend); } else { var vol = DevConsole.GetVariable <float>("audio.voiceoutput"); if (vol == 0) { return; } var clientIndex = voicePacket.ClientIndex; if (clientIndex == Game.ClientIndex && !_loopback) { return; } int uncompressedDataLength = 0; var speakingPlayer = Game.PlayerManager.FindPlayer(clientIndex); fixed(byte *src = voicePacket.Data) { fixed(byte *dst = _data) { uncompressedDataLength = SteamUser.DecompressVoice((IntPtr)src, voicePacket.DataLength, (IntPtr)dst, _data.Length); } } if (uncompressedDataLength == 0 || speakingPlayer == null) { return; } throw new System.NotImplementedException(); // _data to audio.. //UnityEngine.Debug.Log($"size: {data.Length} - group: {getChannelGroupResult} - create: {createSoundResult} - play: {playSoundResult}"); } }
private void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (Game.IsHost || !(packet is CustomPacket cp)) { return; } if (cp.Label == _loadTemplPacketLabel) { LoadLoaders(Structure.PluginsTempPath); } else if (cp.Label == _clearTempPacketLabel) { FileSystem.EmptyTempFolder(); } }
public static IBasePacket SendWithResult(IBasePacket data) { Protocol.SendTcp(Server, data); while (true) { var result = Protocol.ReceiveTcp(Server); if (result is PingPacket) { Protocol.SendTcp(Server, new PingPacket()); continue; } return(result); } }
public void SendPacket(IBasePacket packet) { var pPacket = packet as ProtocolPacket; if (pPacket == null) { Debugger.Break(); return; } if (pPacket.Channel != 0) { pPacket.SequenceNumber = SendSequence[pPacket.Channel]++; } Socket.Send(pPacket); }
public void HandlePacket(IBasePacket packet) { var pPacket = packet as ProtocolPacket; if (pPacket == null) { return; } try { HandleProtocolPacket(pPacket); } catch (InvalidClientMessageException) { Close(); } }
private void _SendPacket(NetPeer peer, IBasePacket packet) { if (_server == null || !_server.IsRunning || peer == null || peer.ConnectionState != ConnectionState.Connected) { return; } _writeBuffer.Position = 0; _writeBuffer.LengthBytes = 0; SocketMan.WritePacketHeader(_writeBuffer, packet); packet.Write(_writeBuffer); var dm = DeliveryMethod.ReliableOrdered; switch (packet.Sc.DeliveryMethod) { case Lidgren.Network.NetDeliveryMethod.ReliableOrdered: dm = DeliveryMethod.ReliableOrdered; break; case Lidgren.Network.NetDeliveryMethod.ReliableSequenced: dm = DeliveryMethod.ReliableSequenced; break; case Lidgren.Network.NetDeliveryMethod.ReliableUnordered: dm = DeliveryMethod.ReliableUnordered; break; case Lidgren.Network.NetDeliveryMethod.Unreliable: case Lidgren.Network.NetDeliveryMethod.UnreliableSequenced: dm = DeliveryMethod.Unreliable; break; case Lidgren.Network.NetDeliveryMethod.Unknown: dm = DeliveryMethod.Unreliable; break; } peer.Send(_writeBuffer.Data, 0, _writeBuffer.LengthBytes, (byte)packet.Sc.SequenceChannel, dm); }
/// <summary> /// Read metabuffer (the actual data). /// </summary> private void InternalReceiveMetaBuffer() { if (socket.Connected) { byte[] buffer = new byte[4]; // Read metadata receivedBytes += (ulong)socket.Receive(buffer, 0, 4, SocketFlags.None); int sizeOfMeta = BitConverter.ToInt32(buffer, 0); int readSizeOfMeta = 0; if (sizeOfMeta != 0) { byte[] metaBuffer = new byte[1024]; readSizeOfMeta = socket.Receive(metaBuffer, 0, sizeOfMeta, SocketFlags.None); while (readSizeOfMeta < sizeOfMeta) { int i = socket.Receive(metaBuffer, readSizeOfMeta, sizeOfMeta - readSizeOfMeta, SocketFlags.None); readSizeOfMeta += i; } receivedBytes += (ulong)readSizeOfMeta; if (readSizeOfMeta != sizeOfMeta) { throw new Exception( "InternalReceiveMetaBuffer metadata length: " + readSizeOfMeta.ToString() + " instead of: " + sizeOfMeta.ToString()); } else { Type typeToCreate = Type.GetType(metatype); IBasePacket packet = (IBasePacket)Activator.CreateInstance(typeToCreate); packet.Initialize(metaBuffer); metadata = packet; } } } }
protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (Game.IsHost || FSGameLoop.GetGameInstance(true) != null || !(packet is CustomPacket cp && cp.Label == "Replicate")) { return; } var replStr = cp.GetString(0); var cmds = replStr.Split('&'); if (cmds != null && cmds.Length > 0) { foreach (var cmd in cmds) { DevConsole.ExecuteLine(cmd); } } }
private void OnPlayerPacketReceived(IPlayer player, IBasePacket packet) { if (!Game.IsHost) { switch (packet) { case DeleteEntity delEntity: DeleteEntity(delEntity.EntityId); break; case EntityUpdate entityUpdate: UpdateEntity(entityUpdate); break; } } if (packet is EntityCommand entCommand) { FindEntity(entCommand.EntityId)?.ReceiveCommand(entCommand); } }
public override void SendPacket(IBasePacket packet) { if (_client == null || !_client.IsRunning) { return; } _writeBuffer.Position = 0; _writeBuffer.LengthBytes = 0; SocketMan.WritePacketHeader(packet, _writeBuffer); packet.Write(_writeBuffer); var dm = DeliveryMethod.ReliableOrdered; switch (packet.Sc.DeliveryMethod) { case Lidgren.Network.NetDeliveryMethod.ReliableOrdered: dm = DeliveryMethod.ReliableOrdered; break; case Lidgren.Network.NetDeliveryMethod.ReliableSequenced: dm = DeliveryMethod.ReliableSequenced; break; case Lidgren.Network.NetDeliveryMethod.ReliableUnordered: dm = DeliveryMethod.ReliableUnordered; break; case Lidgren.Network.NetDeliveryMethod.Unreliable: case Lidgren.Network.NetDeliveryMethod.UnreliableSequenced: dm = DeliveryMethod.Unreliable; break; case Lidgren.Network.NetDeliveryMethod.Unknown: dm = DeliveryMethod.Unreliable; break; } _client.SendToAll(_writeBuffer.Data, 0, _writeBuffer.LengthBytes, (byte)packet.Sc.SequenceChannel, dm); }
public void Send(IBasePacket packet) { var args = SetupEventArgs(SocketAsyncOperation.Send); var data = args.GetUserToken <BufferData>(); int length; // Keep space for the length header data.Offset = LengthSize; // Write the packet data to the buffer using (var sw = data.CreateWriter()) { packet.Write(sw); length = (int)sw.BaseStream.Position; } OnEncrypt?.Invoke(data, ref length); // Reset the offset to send everything (including the size header) data.Offset = 0; data.Length = length + LengthSize; var sizeLen = CountSize ? length + LengthSize : length; // Copy the size header into the buffer for (var i = 0; i < LengthSize; ++i) { data[i] = (byte)((sizeLen >> (i * 8)) & 0xFF); } args.SetBuffer(data.BaseOffset, data.Length); SendAsync(args); }