Exemplo n.º 1
0
        protected override void ConstructeResponse()
        {
            KeepAlivePacket packet = new KeepAlivePacket();

            packet.Parse(_recv);
            _sendingBuffer = packet.GenerateResponse();
            QRSession client = (QRSession)_session.GetInstance();
            var       result = GameServer.GetServers(client.RemoteEndPoint);

            if (result.Count != 1)
            {
                _errorCode = Entity.Enumerator.QRErrorCode.Database;
                return;
            }

            GameServer gameServer = result.First();

            gameServer.LastPacket = DateTime.Now;

            GameServer.UpdateServer
            (
                client.RemoteEndPoint,
                gameServer.ServerData.KeyValue["gamename"],
                gameServer);
        }
Exemplo n.º 2
0
 private void HandleKeepAlive(KeepAlivePacket packet)
 {
     if (packet.KeepAliveid.Equals(_lastKeepAlive))
     {
         KeepAliveReady = true;
     }
 }
Exemplo n.º 3
0
 public static void HandlePacketKeepAlive(Client client, KeepAlivePacket packet)
 {
     client.LastClientResponse = DateTime.Now;
     if (client.LastKeepAliveId > 0 && packet.KeepAliveID == client.LastKeepAliveId)
     {
         client.Ping = (int)Math.Round((DateTime.Now - client.KeepAliveStart).TotalMilliseconds, MidpointRounding.AwayFromZero);
     }
 }
Exemplo n.º 4
0
 /// <summary>
 /// 保持登录状态
 ///     <remark>abu 2008-03-10 </remark>
 /// </summary>
 public void KeepAlive()
 {
     if (IsLogon)
     {
         KeepAlivePacket packet = new KeepAlivePacket(QQUser);
         PacketManager.SendPacket(packet, QQPort.Main.Name);
     }
 }
Exemplo n.º 5
0
    public long KeepAlive()
    {
        var keepAliveId = TimeUtilities.GetElapsedMilliseconds();

        _keepAliveIdQueue.Enqueue(keepAliveId);

        using var keepAlivePacket = new KeepAlivePacket(keepAliveId);
        SendPacket(keepAlivePacket);

        return(keepAliveId);
    }
Exemplo n.º 6
0
        public static void ReadKeepAlive(Client client, PacketReader reader)
        {
            KeepAlivePacket ka = new KeepAlivePacket();

            ka.Read(reader);

            if (!reader.Failed)
            {
                Client.HandlePacketKeepAlive(client, ka);
            }
        }
        public static byte[] MakeKeepAliveBuffer()
        {
            var builder = new FlatBufferBuilder(DefaultBufferBytes);

            KeepAlivePacket.StartKeepAlivePacket(builder);

            KeepAlivePacket.AddOpcode(builder, (short)Opcode.KeepAlive);

            var abortOffset = KeepAlivePacket.EndKeepAlivePacket(builder);

            builder.Finish(abortOffset.Value);

            return(builder.SizedByteArray());
        }
Exemplo n.º 8
0
        public void Create_and_dispose()
        {
            KeepAlivePacket packet = new KeepAlivePacket();

            Assert.AreEqual(0, packet.DestinationId);
            Assert.IsFalse(packet.IsDisposed);
            Assert.IsTrue(packet.IsEditable);
            Assert.AreEqual(TimeSpan.Zero, packet.TimeStamp);

            packet.Dispose();

            Assert.Throws <ObjectDisposedException>(() => { var x = packet.DestinationId; });
            Assert.IsTrue(packet.IsDisposed);
            Assert.IsFalse(packet.IsEditable);
            Assert.Throws <ObjectDisposedException>(() => { var x = packet.TimeStamp; });
        }
Exemplo n.º 9
0
        public void Create_and_dispose()
        {
            KeepAlivePacket packet = new KeepAlivePacket();

            Assert.AreEqual(0, packet.DestinationId);
            Assert.IsFalse(packet.IsDisposed);
            Assert.IsTrue(packet.IsEditable);
            Assert.AreEqual(TimeSpan.Zero, packet.TimeStamp);

            packet.Dispose();

            Assert.Throws<ObjectDisposedException>(() => { var x = packet.DestinationId; });
            Assert.IsTrue(packet.IsDisposed);
            Assert.IsFalse(packet.IsEditable);
            Assert.Throws<ObjectDisposedException>(() => { var x = packet.TimeStamp; });
        }
Exemplo n.º 10
0
 /// <summary>
 /// Sends an input packet and handles inputs if game is active, sends keep alive packet if inactive
 /// </summary>
 private void SendInputOrKeepAlive()
 {
     if (client.ConnectionStatus == ConnectionStatus.Connected)
     {
         if (client.IngameStatus == IngameStatus.InRunningGame)
         {
             GameAction[] pressedActions = ActiveForm == this ? ActionManager.GetActions() : new GameAction[] { };
             InputPacket  p = new InputPacket(client.XorSalt, pressedActions, client.WorldStateAck, thePlayer.Rotation);
             client.SendPacket(p);
             control?.HandleInputs(pressedActions);
         }
         else
         {
             KeepAlivePacket kap = new KeepAlivePacket(client.XorSalt);
             client.SendPacket(kap);
         }
     }
 }
Exemplo n.º 11
0
 public void OnKeepAlive(KeepAlivePacket packet)
 {
     // DO NOTHING
 }
Exemplo n.º 12
0
 public static void HandlePacketKeepAlive(TestClient client, KeepAlivePacket ka)
 {
     client.SendPacket(new KeepAlivePacket());
 }
Exemplo n.º 13
0
        /// <summary>
        /// Gets a packet from the server and returns it.
        /// </summary>
        /// <returns>The received packet.</returns>
        public Packet GetPacket()
        {
            var packetID = (byte)_stream.ReadByte();

            //_log.Debug("Got packet ID: " + packetID); // Spammy debug message
            if (!Enum.IsDefined(typeof(PacketType), (int)packetID))
            {
                return(null);
            }
            var    type = (PacketType)packetID;
            Packet pack = null;

            switch (type)
            {
            case PacketType.KeepAlive:
                pack = new KeepAlivePacket(_tools.ReadInt32());
                break;

            case PacketType.LoginRequest:
                pack = new LoginRequestPacketSC
                {
                    EntityID    = _tools.ReadInt32(),
                    NotUsed     = _tools.ReadString(),
                    LevelType   = _tools.ReadString(),
                    Gamemode    = _tools.ReadInt32(),
                    Dimension   = _tools.ReadInt32(),
                    Difficulty  = _tools.ReadSignedByte(),
                    WorldHeight = _tools.ReadByte(),                             // Not Used
                    MaxPlayers  = _tools.ReadByte()
                };
                break;

            case PacketType.Handshake:
                pack = new HandshakePacketSC(_tools.ReadString());
                break;

            case PacketType.ChatMessage:
                pack = new ChatMessagePacket(_tools.ReadString());
                break;

            case PacketType.TimeUpdate:
                pack = new TimeUpdatePacket(_tools.ReadInt32());
                break;

            case PacketType.EntityEquipment:
                pack = new EntityEquipmentPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.SpawnPosition:
                pack = new SpawnPositionPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.UseEntity:
                pack = new UseEntityPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadBoolean());
                break;

            case PacketType.UpdateHealth:
                pack = new UpdateHealthPacket(_tools.ReadInt16(), _tools.ReadInt16(), _tools.ReadSingle());
                break;

            case PacketType.Respawn:
                pack = new RespawnPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                         _tools.ReadInt16(), _tools.ReadString());
                break;

            case PacketType.Player:
                pack = new PlayerPacket(_tools.ReadBoolean());
                break;

            case PacketType.PlayerPosition:
                pack = new PlayerPositionPacket(_tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(),
                                                _tools.ReadBoolean());
                break;

            case PacketType.PlayerLook:
                pack = new PlayerLookPacket(_tools.ReadSingle(), _tools.ReadSingle(), _tools.ReadBoolean());
                break;

            case PacketType.PlayerPositionAndLook:
                pack = new PlayerPositionAndLookPacket(_tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(),
                                                       _tools.ReadDouble(), _tools.ReadSingle(), _tools.ReadSingle(),
                                                       _tools.ReadBoolean());
                break;

            case PacketType.PlayerDigging:
                pack = new PlayerDiggingPacket(_tools.ReadSignedByte(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                               _tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.PlayerBlockPlacement:
                pack = new PlayerBlockPlacementPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(),
                                                      _tools.ReadSignedByte(), _tools.ReadSlotData());
                break;

            case PacketType.UseBed:
                pack = new UseBedPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                        _tools.ReadInt32());
                break;

            case PacketType.Animation:
                pack = new AnimationPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.NamedEntitySpawn:
                pack = new NamedEntitySpawnPacket(_tools.ReadInt32(), _tools.ReadString(), _tools.ReadInt32(), _tools.ReadInt32(),
                                                  _tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                  _tools.ReadInt16());
                break;

            case PacketType.PickupSpawn:
                pack = new PickupSpawnPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadSignedByte(), _tools.ReadInt16(),
                                             _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                             _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.CollectItem:
                pack = new CollectItemPacket(_tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.AddObjectVehicle:
                pack = new AddObjectVehiclePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(),
                                                  _tools.ReadInt32(), _tools.ReadInt32());
                var ftEid = _tools.ReadInt32(); ((AddObjectVehiclePacket)pack).FireballThrowerID = ftEid;
                if (ftEid > 0)
                {
                    var aovpPack = (AddObjectVehiclePacket)pack;
                    aovpPack.SpeedX = _tools.ReadInt16();
                    aovpPack.SpeedY = _tools.ReadInt16();
                    aovpPack.SpeedZ = _tools.ReadInt16();
                    pack            = aovpPack;
                }
                break;

            case PacketType.HoldingChange:
                pack = new HoldingChangePacket(_tools.ReadInt16());
                break;

            case PacketType.MobSpawn:
                pack = new MobSpawnPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(), _tools.ReadInt32(),
                                          _tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                          _tools.ReadSignedByte(), _tools.ReadEntityMetadata());
                break;

            case PacketType.EntityPainting:
                pack = new EntityPaintingPacket(_tools.ReadInt32(), _tools.ReadString(), _tools.ReadInt32(),
                                                _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.ExperienceOrb:
                pack = new ExperienceOrbPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(),
                                               _tools.ReadInt32(), _tools.ReadInt16());
                break;

            case PacketType.EntityVelocity:
                pack = new EntityVelocityPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.DestroyEntity:
                pack = new DestroyEntityPacket(_tools.ReadInt32());
                break;

            case PacketType.Entity:
                pack = new EntityPacket(_tools.ReadInt32());
                break;

            case PacketType.EntityRelativeMove:
                pack = new EntityRelativeMovePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                    _tools.ReadSignedByte());
                break;

            case PacketType.EntityLook:
                pack = new EntityLookPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.EntityLookAndRelativeMove:
                pack = new EntityLookAndRelativeMovePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                           _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                                           _tools.ReadSignedByte());
                break;

            case PacketType.EntityTeleport:
                pack = new EntityTeleportPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadInt32(),
                                                _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.EntityHeadLook:
                pack = new EntityHeadLookPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.EntityStatus:
                pack = new EntityStatusPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.AttachEntity:
                pack = new AttachEntityPacket(_tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.EntityMetadata:
                var entityMetadataPacket = new EntityMetadataPacket(_tools.ReadInt32());

                var metaData = new List <sbyte>();
                var b        = true;
                while (b)
                {
                    var value = _tools.ReadSignedByte();
                    if (value == 127)
                    {
                        b = false;
                    }
                    metaData.Add(value);
                }
                entityMetadataPacket.Metadata = metaData.ToArray();

                break;

            case PacketType.EntityEffect:
                pack = new EntityEffectPacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadSignedByte(),
                                              _tools.ReadInt16());
                break;

            case PacketType.RemoveEntityEffect:
                pack = new RemoveEntityEffectPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.Experience:
                pack = new ExperiencePacket(_tools.ReadSingle(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.PreChunk:
                pack = new PreChunkPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadBoolean());
                break;

            case PacketType.MapChunk:
                var mapChunkPacket = new MapChunkPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt32(),
                                                        _tools.ReadSignedByte(), _tools.ReadSignedByte(), _tools.ReadSignedByte());

                mapChunkPacket.CompressedSize = _tools.ReadInt32();
                mapChunkPacket.CompressedData = _tools.ReadSignedBytes(mapChunkPacket.CompressedSize);

                pack = mapChunkPacket;
                break;

            case PacketType.MultiBlockChange:
                var multiBlockChangePacket = new MultiBlockChangePacket(_tools.ReadInt32(), _tools.ReadInt32());

                var arraySize = _tools.ReadInt16();
                multiBlockChangePacket.ArraySize = arraySize;

                var coordinates = new short[arraySize, 3];
                for (short i = 0; i < arraySize; i++)
                {
                    coordinates[i, 0] = _tools.ReadInt16();
                    coordinates[i, 1] = _tools.ReadInt16();
                    coordinates[i, 2] = _tools.ReadInt16();
                }
                multiBlockChangePacket.Coordinates = coordinates;

                var types = new sbyte[arraySize];
                for (short i = 0; i < arraySize; i++)
                {
                    types[i] = _tools.ReadSignedByte();
                }
                multiBlockChangePacket.Types = types;

                var metadata = new sbyte[arraySize];
                for (short i = 0; i < arraySize; i++)
                {
                    metadata[i] = _tools.ReadSignedByte();
                }
                multiBlockChangePacket.Metadata = metadata;

                pack = multiBlockChangePacket;
                break;

            case PacketType.BlockChange:
                pack = new BlockChangePacket(_tools.ReadInt32(), _tools.ReadSignedByte(), _tools.ReadInt32(),
                                             _tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.BlockAction:
                pack = new BlockActionPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                             _tools.ReadSignedByte());
                break;

            case PacketType.Explosion:
                var explosionPacket = new ExplosionPacket(_tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadDouble(), _tools.ReadSingle());

                var recordCount = _tools.ReadInt32();
                explosionPacket.Count = recordCount;

                var records = new sbyte[recordCount, 3];
                for (var i = 0; i < recordCount; i++)
                {
                    records[i, 0] = _tools.ReadSignedByte();
                    records[i, 1] = _tools.ReadSignedByte();
                    records[i, 2] = _tools.ReadSignedByte();
                }
                explosionPacket.Records = records;

                pack = explosionPacket;
                break;

            case PacketType.SoundParticleEffect:
                pack = new SoundParticleEffectPacket(_tools.ReadInt32(), _tools.ReadInt32(), _tools.ReadSignedByte(),
                                                     _tools.ReadInt32(), _tools.ReadInt32());
                break;

            case PacketType.NewInvalidState:
                pack = new NewInvalidStatePacket(_tools.ReadSignedByte(), _tools.ReadSignedByte());
                break;

            case PacketType.Thunderbolt:
                pack = new ThunderboltPacket(_tools.ReadInt32(), _tools.ReadBoolean(), _tools.ReadInt32(), _tools.ReadInt32(),
                                             _tools.ReadInt32());
                break;

            case PacketType.OpenWindow:
                pack = new OpenWindowPacket(_tools.ReadSignedByte(), _tools.ReadSignedByte(), _tools.ReadString(),
                                            _tools.ReadSignedByte());
                break;

            case PacketType.CloseWindow:
                pack = new CloseWindowPacket(_tools.ReadSignedByte());
                break;

            case PacketType.SetSlot:
                pack = new SetSlotPacket(_tools.ReadSignedByte(), _tools.ReadInt16(), _tools.ReadSlotData());
                break;

            case PacketType.WindowItems:
                var windowItemsPacket = new WindowItemsPacket(_tools.ReadSignedByte());

                var count = _tools.ReadInt16();
                windowItemsPacket.Count = count;

                var slotData = new SlotData[count];
                for (short i = 0; i < count; i++)
                {
                    slotData[i] = _tools.ReadSlotData();
                }
                windowItemsPacket.SlotData = slotData;

                pack = windowItemsPacket;
                break;

            case PacketType.UpdateWindowProperty:
                pack = new UpdateWindowPropertyPacket(_tools.ReadSignedByte(), _tools.ReadInt16(), _tools.ReadInt16());
                break;

            case PacketType.Transaction:
                pack = new TransactionPacket(_tools.ReadSignedByte(), _tools.ReadInt16(), _tools.ReadBoolean());
                break;

            case PacketType.CreativeInventoryAction:
                pack = new CreativeInventoryActionPacket(_tools.ReadInt16(), _tools.ReadSlotData());
                break;

            case PacketType.UpdateSign:
                pack = new UpdateSignPacket(_tools.ReadInt32(), _tools.ReadInt16(), _tools.ReadInt32(), _tools.ReadString(),
                                            _tools.ReadString(), _tools.ReadString(), _tools.ReadString());
                break;

            case PacketType.ItemData:
                pack = new ItemDataPacket(_tools.ReadInt16(), _tools.ReadInt16());

                byte len = _tools.ReadByte();
                ((ItemDataPacket)pack).Length = len;
                ((ItemDataPacket)pack).Text   = _tools.ReadSignedBytes(len);

                break;

            case PacketType.IncrementStatistic:
                pack = new IncrementStatisticPacket(_tools.ReadInt32(), _tools.ReadSignedByte());
                break;

            case PacketType.PlayerListItem:
                pack = new PlayerListItemPacket(_tools.ReadString(), _tools.ReadBoolean(), _tools.ReadInt16());
                break;

            case PacketType.PluginMessage:
                pack = new PluginMessagePacket(_tools.ReadString());
                var length = _tools.ReadInt16(); ((PluginMessagePacket)pack).Length = length;
                ((PluginMessagePacket)pack).Data = _tools.ReadSignedBytes(length);
                break;

            case PacketType.DisconnectKick:
                pack = new DisconnectKickPacket(_tools.ReadString());
                break;
            }

            return(pack);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Handles all packets received.
        /// </summary>
        /// <param name="sender">N/A (Not Used) (See MSDN)</param>
        /// <param name="e"><see cref="PacketEventArgs" /> containing the packet and other info.</param>
        private void PacketReceived(object sender, PacketEventArgs e)
        {
            Packet response;

            switch (e.Packet.Type)
            {
            case PacketType.KeepAlive:
                response = new KeepAlivePacket(((KeepAlivePacket)e.Packet).KeepAliveID);
                //_log.Debug("Client received KeepAlive request, sending KeepAlive packet...");
                _protocol.SendPacket(response);
                break;

            case PacketType.LoginRequest:
                ParseLoginRequestSC((LoginRequestPacketSC)e.Packet);
                break;

            case PacketType.ChatMessage:
                ReceiveMessage(((ChatMessagePacket)e.Packet).Message);
                break;

            case PacketType.SpawnPosition:
                var spPack = (SpawnPositionPacket)e.Packet;
                _log.Debug(string.Format("Received SpawnPosition packet: {0}, {1}, {2}. Updating world spawn...", spPack.X, spPack.Y, spPack.Z));
                _world.SetSpawn(spPack.X, spPack.Y, spPack.Z);
                _log.Debug("Spawn position set!");
                break;

            case PacketType.Player:
                var playerPack = (PlayerPacket)e.Packet;
                response = new PlayerPacket(playerPack.OnGround);
                _log.Debug("Updating player OnGround...");
                _player.SetOnGround(playerPack.OnGround);
                _log.Debug("Client received Player packet, responding with identical packet...");
                _protocol.SendPacket(response);
                break;

            case PacketType.PlayerPosition:
                var pPack = (PlayerPositionPacket)e.Packet;
                response = new PlayerPositionPacket(pPack.X, pPack.Y, pPack.Stance, pPack.Z, pPack.OnGround);
                _log.Debug("Updating player position...");
                _player.SetPosition(pPack.X, pPack.Y, pPack.Z);
                _player.SetStance(pPack.Stance);
                _player.SetOnGround(pPack.OnGround);
                _log.Debug("Client received PlayerPosition packet (0x0B), responding with identical packet...");
                _protocol.SendPacket(response);
                break;

            case PacketType.PlayerLook:
                var lPack = (PlayerLookPacket)e.Packet;
                response = new PlayerLookPacket(lPack.Yaw, lPack.Pitch, lPack.OnGround);
                _log.Debug("Updating player look...");
                _player.SetDirection(lPack.Yaw, lPack.Pitch);
                _player.SetOnGround(lPack.OnGround);
                _log.Debug("Client received PlayerLook packet (0x0C), responding with identical packet...");
                _protocol.SendPacket(response);
                break;

            case PacketType.PlayerPositionAndLook:
                var plPack = (PlayerPositionAndLookPacket)e.Packet;
                response = new PlayerPositionAndLookPacket
                {
                    X        = plPack.X,
                    Y        = plPack.Y,
                    Z        = plPack.Y,
                    Stance   = plPack.Stance,
                    Yaw      = plPack.Yaw,
                    Pitch    = plPack.Pitch,
                    OnGround = plPack.OnGround
                };
                _log.Debug("Updating player position and look...");
                _player.SetPosition(plPack.X, plPack.Y, plPack.Z);
                _player.SetDirection(plPack.Yaw, plPack.Pitch);
                _player.SetStance(plPack.Stance);
                _player.SetOnGround(plPack.OnGround);
                _log.Debug("Client received PlayerPositionAndLook packet (0x0D), responding with identical packet...");
                _protocol.SendPacket(response);
                break;

            case PacketType.DisconnectKick:
                _log.Debug("Client DISCONNECT or KICK with reason: " + ((DisconnectKickPacket)e.Packet).Reason);
                _listener.Stop();
                break;

            default:
                //_log.Warn("Received packet: " + e.Packet.Type + " but Client is not configured to respond to this packet!");
                break;
            }
        }
Exemplo n.º 15
0
 private void HandleKeepAlive(Client client, KeepAlivePacket packet)
 {
     // TODO: Check sent value against received value
 }
Exemplo n.º 16
0
 /// <summary>处理保持登录应答
 ///     <remark>abu 2008-03-10 </remark>
 /// </summary>
 /// <param name="packet">The packet.</param>
 private void ProcessKeepAliveReply(KeepAliveReplyPacket inPacket, KeepAlivePacket outPacket)
 {
     client.ConnectionManager.OnReceivedKeepAlive(new QQEventArgs <KeepAliveReplyPacket, KeepAlivePacket>(client, inPacket, outPacket));
 }
Exemplo n.º 17
0
 internal void ProcessKeepAliveReply(KeepAliveReplyPacket keepAliveReplyPacket, KeepAlivePacket keepAlivePacket)
 {
     QQClient.LogManager.Log("Recived KeepAlive Packet:Onlines: " + keepAliveReplyPacket.Onlines.ToString() + " ServerTime:" + keepAliveReplyPacket.ServerTime.ToString());
 }
Exemplo n.º 18
0
        public void Handle(int id, MemoryStream ms)
        {
            if (_loginSucces)
            {
                IPacket packet = null;
                switch (id)
                {
                case BlockChangePacket.PACKET_ID:
                    packet = new BlockChangePacket(ms);
                    break;

                case ChatMessagePacket.PACKET_ID:
                    packet = new ChatMessagePacket(ms);
                    break;

                case UpdateHealthPacket.PACKET_ID:
                    packet = new UpdateHealthPacket(ms);
                    break;

                case ChunkDataPacket.PACKET_ID:
                    packet = new ChunkDataPacket(ms);
                    break;

                case DisconnectPacket.PACKET_ID:
                    packet = new DisconnectPacket(ms);
                    break;

                case KeepAlivePacket.PACKET_ID:
                    packet = new KeepAlivePacket(ms);
                    break;

                case PlayerAbilitiesPacket.PACKET_ID:
                    packet = new PlayerAbilitiesPacket(ms);
                    break;

                case PlayerPositionAndLookPacket.PACKET_ID:
                    packet = new PlayerPositionAndLookPacket(ms);
                    break;

                case SpawnExperienceOrbPacket.PACKET_ID:
                    packet = new SpawnExperienceOrbPacket(ms);
                    break;

                case SpawnGlobalEntityPacket.PACKET_ID:
                    packet = new SpawnGlobalEntityPacket(ms);
                    break;

                case SpawnObjectPacket.PACKET_ID:
                    packet = new SpawnObjectPacket(ms);
                    break;

                case UnloadChunkPacket.PACKET_ID:
                    packet = new UnloadChunkPacket(ms);
                    break;

                case SpawnPositionPacket.PACKET_ID:
                    packet = new SpawnPositionPacket(ms);
                    break;
                }

                if (packet != null && PlayPacketReceivedEvent != null)
                {
                    this.PlayPacketReceivedEvent(packet);
                }
            }
            else
            {
                IPacket packet = null;
                switch (id)
                {
                case Packet.Clientbound.Login.DisconnectPacket.PACKET_ID:
                    packet = new Packet.Clientbound.Login.DisconnectPacket(ms);
                    break;

                case Packet.Clientbound.Login.LoginSuccessPacket.PACKET_ID:
                    packet = new Packet.Clientbound.Login.LoginSuccessPacket(ms);
                    break;

                case Packet.Clientbound.Login.SetCompressionPacket.PACKET_ID:
                    packet = new Packet.Clientbound.Login.SetCompressionPacket(ms);
                    break;
                }

                if (packet != null && LoginPacketReceivedEvent != null)
                {
                    this.LoginPacketReceivedEvent(packet);
                }
            }
            ms.Dispose();
        }
Exemplo n.º 19
0
 public void OnKeepAlivePacket(KeepAlivePacket packet)
 {
     _logger.Info("KeepAlive!");
     Connection.SendPacketAsync(packet);
 }