Exemplo n.º 1
0
        public void OnUdpReceived(BitBuffer buffer, ushort packetTimestamp)
        {
            if (!DoubleProtocol.IsPacketNewest(ref _newestPacketTimestamp, packetTimestamp))
            {
                return;
            }

            foreach (Player player in _players.Values)
            {
                player.LoopOverCells((x, y) => _cellMap.Set(x, y, CellMap.DefaultBrush));
            }

            for (ulong i = buffer.ReadBits(2); i > 0; i--)
            {
                if (_players.TryGetValue((byte)buffer.ReadBits(2), out Player player))
                {
                    player.X = (byte)buffer.ReadBits(4);
                    player.Y = (byte)buffer.ReadBits(4);
                }
                else
                {
                    buffer.AdvanceReader(8);
                }
            }

            foreach (Player player in _players.Values)
            {
                player.LoopOverCells((x, y) => _cellMap.Set(x, y, player.Brush));
            }
        }
Exemplo n.º 2
0
            public void OnUdpReceived(IDoubleServerClient client, BitBuffer buffer, ushort packetTimestamp)
            {
                NetworkServerClient serverClient = (NetworkServerClient)client.ExtraData;

                if (serverClient.TakeResetPacketTimestamp())
                {
                    serverClient.LastPacketTimestamp = packetTimestamp;
                }
                else if (!DoubleProtocol.IsPacketNewest(ref serverClient.LastPacketTimestamp, packetTimestamp))
                {
                    return;
                }

                byte[] bytes = buffer.ReadBytes();
                // ReSharper disable once ConvertToLocalFunction
                Action handler = () => {
                    if (_server != null)
                    {
                        _handlerBuffer.SetContents(bytes);
                        UdpHandler(serverClient, _handlerBuffer);
                    }
                };

                if (!NetworkUtils.SimulateNetworkConditions || NetworkUtils.IsLocal(serverClient.Id))
                {
                    UnityFixedDispatcher.InvokeNoDelay(handler);
                }
                else
                {
                    UnityFixedDispatcher.InvokeDelayed(NetworkUtils.SimulatedNetDelay, handler);
                }
            }
Exemplo n.º 3
0
        public void OnUdpReceived(IDoubleServerClient client, BitBuffer buffer, ushort packetTimestamp)
        {
            Player player = (Player)client.ExtraData;

            if (DoubleProtocol.IsPacketNewest(ref player.NewestPacketTimestamp, packetTimestamp))
            {
                player.X = (byte)buffer.ReadBits(4);
                player.Y = (byte)buffer.ReadBits(4);
            }
        }
Exemplo n.º 4
0
            public void OnUdpReceived(BitBuffer buffer, ushort packetTimestamp)
            {
                bool resetPacketTimestamp;

                lock (SmallLock) {
                    resetPacketTimestamp  = _resetPacketTimestamp;
                    _resetPacketTimestamp = false;
                }

                if (resetPacketTimestamp)
                {
                    _lastPacketTimestamp = packetTimestamp;
                }
                else if (!DoubleProtocol.IsPacketNewest(ref _lastPacketTimestamp, packetTimestamp))
                {
                    return;
                }

                byte[] bytes = buffer.ReadBytes();
                // ReSharper disable once ConvertToLocalFunction
                Action handler = () => {
                    if (_client != null)
                    {
                        _handlerBuffer.SetContents(bytes);
                        UdpHandler(_handlerBuffer);
                    }
                };

                // ReSharper disable once PossibleNullReferenceException
                int netDelayIncrease = DoubleProtocol.TripTime(_client.ConnectionStartTimestamp, packetTimestamp);

                if (!NetworkUtils.SimulateNetworkConditions || NetworkUtils.IsServer)
                {
                    UnityFixedDispatcher.InvokeNoDelay(handler);
                }
                else if (!NetworkUtils.SimulateLosingPacket)
                {
                    int delay = NetworkUtils.SimulatedNetDelay;
                    netDelayIncrease += delay;
                    UnityFixedDispatcher.InvokeDelayed(delay, handler);
                }
                else
                {
                    return;
                }

                UdpNetDelay += (netDelayIncrease - UdpNetDelay) * 0.1f;
            }