Пример #1
0
 public override void SendPacket(List <ServerPlayer> players, IBasePacket packet)
 {
     foreach (var player in players)
     {
         SendPacket(player, packet);
     }
 }
Пример #2
0
        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);
            }
        }
Пример #3
0
 public override void SendPacket(ServerPlayer player, IBasePacket packet)
 {
     if (FindPeer(player, out NetPeer peer))
     {
         _SendPacket(peer, packet);
     }
 }
Пример #4
0
 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");
            }
        }
Пример #6
0
        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);
                }
            }
        }
Пример #7
0
 protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
 {
     if (packet is FileSync fileSync)
     {
         _filesToSync = new List <FSFileInfo>(fileSync.Files);
     }
 }
Пример #8
0
        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);
            }
        }
Пример #9
0
 protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
 {
     if (!Game.IsHost && packet is PlaySound playSound)
     {
         Emit(playSound.Event, playSound.Twod, playSound.Position);
     }
 }
Пример #10
0
        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;
            }
        }
Пример #11
0
        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;
            }
        }
Пример #12
0
        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));
        }
Пример #13
0
 protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
 {
     if (Game.IsHost || !(packet is FileChunk chunk))
     {
         return;
     }
     ReceiveChunk(chunk);
 }
Пример #14
0
 protected override void OnPlayerPacketReceived(IPlayer player, IBasePacket packet)
 {
     switch (packet)
     {
     case PlayerEvent playerEvent:
         IncomingPlayerEvent(playerEvent);
         break;
     }
 }
Пример #15
0
 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";
 }
Пример #16
0
 public void OnReceivePlayerPacket(IBasePacket packet, ServerPlayer player)
 {
     if (!(packet is CustomPacket))
     {
         InvokeEventSubscriptions("OnReceivePlayerPacket", packet, player);
     }
     else
     {
         InvokeEventSubscriptions("OnReceiveCustomPacket", packet, player);
     }
 }
Пример #17
0
        public void HandlePacket(IBasePacket packet)
        {
            var authPacket = packet as PythonPacket;

            if (authPacket == null)
            {
                return;
            }

            PacketRouter.RoutePacket(_handler, authPacket);
        }
Пример #18
0
        public void EnqueueOutgoing(INetworkClient client, IBasePacket data)
        {
            var packet = new QueuedPacket
            {
                Client = client,
                Packet = data
            };

            lock (_outgoingQueue)
                _outgoingQueue.Enqueue(packet);
        }
Пример #19
0
 private bool PacketIsWaiting(IBasePacket packet)
 {
     foreach (var asyncWait in _waitingPackets)
     {
         if (asyncWait.Packet == packet)
         {
             return(true);
         }
     }
     return(false);
 }
Пример #20
0
        public void HandlePacket(IBasePacket packet)
        {
            var authPacket = packet as IOpcodedPacket <ClientOpcode>;

            if (authPacket == null)
            {
                return;
            }

            PacketRouter.RoutePacket(this, authPacket);
        }
Пример #21
0
        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);
                }
            }
        }
Пример #22
0
        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}");
            }
        }
Пример #23
0
 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);
            }
        }
Пример #25
0
        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);
        }
Пример #26
0
        public void HandlePacket(IBasePacket packet)
        {
            var pPacket = packet as ProtocolPacket;

            if (pPacket == null)
            {
                return;
            }

            try
            {
                HandleProtocolPacket(pPacket);
            }
            catch (InvalidClientMessageException)
            {
                Close();
            }
        }
Пример #27
0
        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);
        }
Пример #28
0
        /// <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;
                    }
                }
            }
        }
Пример #29
0
        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);
                }
            }
        }
Пример #30
0
        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);
            }
        }
Пример #31
0
        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);
        }
Пример #32
0
        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);
        }