Esempio n. 1
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;
                default:
                    //Throw exception?
                    pack = null; //Add checks to see if packet == null
                    _log.Debug("Unknown packet!");
                    _stream.Flush(); //Flush data of unknown packet
                    break;

            }

            return pack;
        }
Esempio n. 2
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;
     }
 }