private bool processPacket(byte id)
        {
            int nbr = 0;

            switch (id)
            {
            case 0x00: byte[] keepalive = new byte[5] {
                    0, 0, 0, 0, 0
            };
                Receive(keepalive, 1, 4, SocketFlags.None);
                handler.OnServerKeepAlive();
                Send(keepalive); break;

            case 0x01: readData(4); readNextString(); readData(5); break;

            case 0x02: readData(1); readNextString(); readNextString(); readData(4); break;

            case 0x03:
                string message = readNextString();
                handler.OnTextReceived(message, protocolversion >= 72); break;

            case 0x04: readData(16); break;

            case 0x05: readData(6); readNextItemSlot(); break;

            case 0x06: readData(12); break;

            case 0x07: readData(9); break;

            case 0x08: if (protocolversion >= 72)
                {
                    readData(10);
                }
                else
                {
                    readData(8);
                } break;

            case 0x09: readData(8); readNextString(); break;

            case 0x0A: readData(1); break;

            case 0x0B: readData(33); break;

            case 0x0C: readData(9); break;

            case 0x0D: readData(41); break;

            case 0x0E: readData(11); break;

            case 0x0F: readData(10); readNextItemSlot(); readData(3); break;

            case 0x10: readData(2); break;

            case 0x11: readData(14); break;

            case 0x12: readData(5); break;

            case 0x13: if (protocolversion >= 72)
                {
                    readData(9);
                }
                else
                {
                    readData(5);
                } break;

            case 0x14: readData(4); readNextString(); readData(16); readNextEntityMetaData(); break;

            case 0x16: readData(8); break;

            case 0x17: readData(19); readNextObjectData(); break;

            case 0x18: readData(26); readNextEntityMetaData(); break;

            case 0x19: readData(4); readNextString(); readData(16); break;

            case 0x1A: readData(18); break;

            case 0x1B: if (protocolversion >= 72)
                {
                    readData(10);
                }
                break;

            case 0x1C: readData(10); break;

            case 0x1D: nbr = (int)readNextByte(); readData(nbr * 4); break;

            case 0x1E: readData(4); break;

            case 0x1F: readData(7); break;

            case 0x20: readData(6); break;

            case 0x21: readData(9); break;

            case 0x22: readData(18); break;

            case 0x23: readData(5); break;

            case 0x26: readData(5); break;

            case 0x27: if (protocolversion >= 72)
                {
                    readData(9);
                }
                else
                {
                    readData(8);
                } break;

            case 0x28: readData(4); readNextEntityMetaData(); break;

            case 0x29: readData(8); break;

            case 0x2A: readData(5); break;

            case 0x2B: readData(8); break;

            case 0x2C: if (protocolversion >= 72)
                {
                    readNextEntityProperties(protocolversion);
                }
                break;

            case 0x33: readData(13); nbr = readNextInt(); readData(nbr); break;

            case 0x34: readData(10); nbr = readNextInt(); readData(nbr); break;

            case 0x35: readData(12); break;

            case 0x36: readData(14); break;

            case 0x37: readData(17); break;

            case 0x38: readNextChunkBulkData(); break;

            case 0x3C: readData(28); nbr = readNextInt(); readData(3 * nbr); readData(12); break;

            case 0x3D: readData(18); break;

            case 0x3E: readNextString(); readData(17); break;

            case 0x3F: if (protocolversion > 51)
                {
                    readNextString(); readData(32);
                }
                break;

            case 0x46: readData(2); break;

            case 0x47: readData(17); break;

            case 0x64: readNextWindowData(protocolversion); break;

            case 0x65: readData(1); break;

            case 0x66: readData(7); readNextItemSlot(); break;

            case 0x67: readData(3); readNextItemSlot(); break;

            case 0x68: readData(1); for (nbr = readNextShort(); nbr > 0; nbr--)
                {
                    readNextItemSlot();
                }
                break;

            case 0x69: readData(5); break;

            case 0x6A: readData(4); break;

            case 0x6B: readData(2); readNextItemSlot(); break;

            case 0x6C: readData(2); break;

            case 0x82: readData(10); readNextString(); readNextString(); readNextString(); readNextString(); break;

            case 0x83: readData(4); nbr = readNextShort(); readData(nbr); break;

            case 0x84: readData(11); nbr = readNextShort(); if (nbr > 0)
                {
                    readData(nbr);
                }
                break;

            case 0x85: if (protocolversion >= 74)
                {
                    readData(13);
                }
                break;

            case 0xC8:
                if (readNextInt() == 2022)
                {
                    ConsoleIO.WriteLogLine("You are dead. Type /respawn to respawn.");
                }
                if (protocolversion >= 72)
                {
                    readData(4);
                }
                else
                {
                    readData(1);
                }
                break;

            case 0xC9:
                string name = readNextString(); bool online = readNextByte() != 0x00; readData(2);
                Guid   FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray());
                if (online)
                {
                    handler.OnPlayerJoin(FakeUUID, name);
                }
                else
                {
                    handler.OnPlayerLeave(FakeUUID);
                }
                break;

            case 0xCA: if (protocolversion >= 72)
                {
                    readData(9);
                }
                else
                {
                    readData(3);
                } break;

            case 0xCB: autocomplete_result = readNextString(); autocomplete_received = true; break;

            case 0xCC: readNextString(); readData(4); break;

            case 0xCD: readData(1); break;

            case 0xCE: if (protocolversion > 51)
                {
                    readNextString(); readNextString(); readData(1);
                }
                break;

            case 0xCF: if (protocolversion > 51)
                {
                    readNextString(); readData(1); readNextString();
                }
                readData(4); break;

            case 0xD0: if (protocolversion > 51)
                {
                    readData(1); readNextString();
                }
                break;

            case 0xD1: if (protocolversion > 51)
                {
                    readNextTeamData();
                }
                break;

            case 0xFA: string channel = readNextString();
                byte[]        payload = readNextByteArray();
                handler.OnPluginChannelMessage(channel, payload);
                break;

            case 0xFF: string reason = readNextString();
                handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick, reason); break;

            default: return(false); //unknown packet!
            }
            return(true);           //packet has been successfully skipped
        }
Beispiel #2
0
        /// <summary>
        /// Handle the given packet
        /// </summary>
        /// <param name="packetID">Packet ID</param>
        /// <param name="packetData">Packet contents</param>
        /// <returns>TRUE if the packet was processed, FALSE if ignored or unknown</returns>
        internal bool HandlePacket(int packetID, List <byte> packetData)
        {
            try
            {
                if (login_phase)
                {
                    switch (packetID) //Packet IDs are different while logging in
                    {
                    case 0x03:
                        if (protocolversion >= MC18Version)
                        {
                            compression_treshold = dataTypes.ReadNextVarInt(packetData);
                        }
                        break;

                    default:
                        return(false);    //Ignored packet
                    }
                }
                // Regular in-game packets
                switch (Protocol18PacketTypes.GetPacketIncomingType(packetID, protocolversion))
                {
                case PacketIncomingType.KeepAlive:
                    SendPacket(PacketOutgoingType.KeepAlive, packetData);
                    break;

                case PacketIncomingType.JoinGame:
                    handler.OnGameJoined();
                    dataTypes.ReadNextInt(packetData);
                    dataTypes.ReadNextByte(packetData);
                    if (protocolversion >= MC191Version)
                    {
                        this.currentDimension = dataTypes.ReadNextInt(packetData);
                    }
                    else
                    {
                        this.currentDimension = (sbyte)dataTypes.ReadNextByte(packetData);
                    }
                    if (protocolversion < MC114Version)
                    {
                        dataTypes.ReadNextByte(packetData);               // Difficulty - 1.13 and below
                    }
                    dataTypes.ReadNextByte(packetData);
                    dataTypes.ReadNextString(packetData);
                    if (protocolversion >= MC114Version)
                    {
                        dataTypes.ReadNextVarInt(packetData);             // View distance - 1.14 and above
                    }
                    if (protocolversion >= MC18Version)
                    {
                        dataTypes.ReadNextBool(packetData);               // Reduced debug info - 1.8 and above
                    }
                    break;

                case PacketIncomingType.ChatMessage:
                    string message = dataTypes.ReadNextString(packetData);
                    try
                    {
                        //Hide system messages or xp bar messages?
                        byte messageType = dataTypes.ReadNextByte(packetData);
                        if ((messageType == 1 && !Settings.DisplaySystemMessages) ||
                            (messageType == 2 && !Settings.DisplayXPBarMessages))
                        {
                            break;
                        }
                    }
                    catch (ArgumentOutOfRangeException) { /* No message type */ }
                    handler.OnTextReceived(message, true);
                    break;

                case PacketIncomingType.Respawn:
                    this.currentDimension = dataTypes.ReadNextInt(packetData);
                    if (protocolversion < MC114Version)
                    {
                        dataTypes.ReadNextByte(packetData);               // Difficulty - 1.13 and below
                    }
                    dataTypes.ReadNextByte(packetData);
                    dataTypes.ReadNextString(packetData);
                    handler.OnRespawn();
                    break;

                case PacketIncomingType.PlayerPositionAndLook:
                    if (handler.GetTerrainEnabled())
                    {
                        double x       = dataTypes.ReadNextDouble(packetData);
                        double y       = dataTypes.ReadNextDouble(packetData);
                        double z       = dataTypes.ReadNextDouble(packetData);
                        float  yaw     = dataTypes.ReadNextFloat(packetData);
                        float  pitch   = dataTypes.ReadNextFloat(packetData);
                        byte   locMask = dataTypes.ReadNextByte(packetData);

                        if (protocolversion >= MC18Version)
                        {
                            Location location = handler.GetCurrentLocation();
                            location.X = (locMask & 1 << 0) != 0 ? location.X + x : x;
                            location.Y = (locMask & 1 << 1) != 0 ? location.Y + y : y;
                            location.Z = (locMask & 1 << 2) != 0 ? location.Z + z : z;
                            handler.UpdateLocation(location, yaw, pitch);
                        }
                        else
                        {
                            handler.UpdateLocation(new Location(x, y, z), yaw, pitch);
                        }
                    }

                    if (protocolversion >= MC19Version)
                    {
                        int teleportID = dataTypes.ReadNextVarInt(packetData);
                        // Teleport confirm packet
                        SendPacket(PacketOutgoingType.TeleportConfirm, dataTypes.GetVarInt(teleportID));
                    }
                    break;

                case PacketIncomingType.ChunkData:
                    if (handler.GetTerrainEnabled())
                    {
                        int    chunkX           = dataTypes.ReadNextInt(packetData);
                        int    chunkZ           = dataTypes.ReadNextInt(packetData);
                        bool   chunksContinuous = dataTypes.ReadNextBool(packetData);
                        ushort chunkMask        = protocolversion >= MC19Version
                                ? (ushort)dataTypes.ReadNextVarInt(packetData)
                                : dataTypes.ReadNextUShort(packetData);
                        if (protocolversion < MC18Version)
                        {
                            ushort addBitmap          = dataTypes.ReadNextUShort(packetData);
                            int    compressedDataSize = dataTypes.ReadNextInt(packetData);
                            byte[] compressed         = dataTypes.ReadData(compressedDataSize, packetData);
                            byte[] decompressed       = ZlibUtils.Decompress(compressed);
                            pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, addBitmap, currentDimension == 0, chunksContinuous, currentDimension, new List <byte>(decompressed));
                        }
                        else
                        {
                            if (protocolversion >= MC114Version)
                            {
                                dataTypes.ReadNextNbt(packetData);      // Heightmaps - 1.14 and above
                            }
                            int dataSize = dataTypes.ReadNextVarInt(packetData);
                            pTerrain.ProcessChunkColumnData(chunkX, chunkZ, chunkMask, 0, false, chunksContinuous, currentDimension, packetData);
                        }
                    }
                    break;

                case PacketIncomingType.MultiBlockChange:
                    if (handler.GetTerrainEnabled())
                    {
                        int chunkX      = dataTypes.ReadNextInt(packetData);
                        int chunkZ      = dataTypes.ReadNextInt(packetData);
                        int recordCount = protocolversion < MC18Version
                                ? (int)dataTypes.ReadNextShort(packetData)
                                : dataTypes.ReadNextVarInt(packetData);

                        for (int i = 0; i < recordCount; i++)
                        {
                            byte   locationXZ;
                            ushort blockIdMeta;
                            int    blockY;

                            if (protocolversion < MC18Version)
                            {
                                blockIdMeta = dataTypes.ReadNextUShort(packetData);
                                blockY      = (ushort)dataTypes.ReadNextByte(packetData);
                                locationXZ  = dataTypes.ReadNextByte(packetData);
                            }
                            else
                            {
                                locationXZ  = dataTypes.ReadNextByte(packetData);
                                blockY      = (ushort)dataTypes.ReadNextByte(packetData);
                                blockIdMeta = (ushort)dataTypes.ReadNextVarInt(packetData);
                            }

                            int   blockX = locationXZ >> 4;
                            int   blockZ = locationXZ & 0x0F;
                            Block block  = new Block(blockIdMeta);
                            handler.GetWorld().SetBlock(new Location(chunkX, chunkZ, blockX, blockY, blockZ), block);
                        }
                    }
                    break;

                case PacketIncomingType.BlockChange:
                    if (handler.GetTerrainEnabled())
                    {
                        if (protocolversion < MC18Version)
                        {
                            int   blockX    = dataTypes.ReadNextInt(packetData);
                            int   blockY    = dataTypes.ReadNextByte(packetData);
                            int   blockZ    = dataTypes.ReadNextInt(packetData);
                            short blockId   = (short)dataTypes.ReadNextVarInt(packetData);
                            byte  blockMeta = dataTypes.ReadNextByte(packetData);
                            handler.GetWorld().SetBlock(new Location(blockX, blockY, blockZ), new Block(blockId, blockMeta));
                        }
                        else
                        {
                            handler.GetWorld().SetBlock(dataTypes.ReadNextLocation(packetData), new Block((ushort)dataTypes.ReadNextVarInt(packetData)));
                        }
                    }
                    break;

                case PacketIncomingType.MapChunkBulk:
                    if (protocolversion < MC19Version && handler.GetTerrainEnabled())
                    {
                        int         chunkCount;
                        bool        hasSkyLight;
                        List <byte> chunkData = packetData;

                        //Read global fields
                        if (protocolversion < MC18Version)
                        {
                            chunkCount = dataTypes.ReadNextShort(packetData);
                            int compressedDataSize = dataTypes.ReadNextInt(packetData);
                            hasSkyLight = dataTypes.ReadNextBool(packetData);
                            byte[] compressed   = dataTypes.ReadData(compressedDataSize, packetData);
                            byte[] decompressed = ZlibUtils.Decompress(compressed);
                            chunkData = new List <byte>(decompressed);
                        }
                        else
                        {
                            hasSkyLight = dataTypes.ReadNextBool(packetData);
                            chunkCount  = dataTypes.ReadNextVarInt(packetData);
                        }

                        //Read chunk records
                        int[]    chunkXs    = new int[chunkCount];
                        int[]    chunkZs    = new int[chunkCount];
                        ushort[] chunkMasks = new ushort[chunkCount];
                        ushort[] addBitmaps = new ushort[chunkCount];
                        for (int chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
                        {
                            chunkXs[chunkColumnNo]    = dataTypes.ReadNextInt(packetData);
                            chunkZs[chunkColumnNo]    = dataTypes.ReadNextInt(packetData);
                            chunkMasks[chunkColumnNo] = dataTypes.ReadNextUShort(packetData);
                            addBitmaps[chunkColumnNo] = protocolversion < MC18Version
                                    ? dataTypes.ReadNextUShort(packetData)
                                    : (ushort)0;
                        }

                        //Process chunk records
                        for (int chunkColumnNo = 0; chunkColumnNo < chunkCount; chunkColumnNo++)
                        {
                            pTerrain.ProcessChunkColumnData(chunkXs[chunkColumnNo], chunkZs[chunkColumnNo], chunkMasks[chunkColumnNo], addBitmaps[chunkColumnNo], hasSkyLight, true, currentDimension, chunkData);
                        }
                    }
                    break;

                case PacketIncomingType.UnloadChunk:
                    if (protocolversion >= MC19Version && handler.GetTerrainEnabled())
                    {
                        int chunkX = dataTypes.ReadNextInt(packetData);
                        int chunkZ = dataTypes.ReadNextInt(packetData);
                        handler.GetWorld()[chunkX, chunkZ] = null;
                    }
                    break;

                case PacketIncomingType.PlayerListUpdate:
                    if (protocolversion >= MC18Version)
                    {
                        int action     = dataTypes.ReadNextVarInt(packetData);
                        int numActions = dataTypes.ReadNextVarInt(packetData);
                        for (int i = 0; i < numActions; i++)
                        {
                            Guid uuid = dataTypes.ReadNextUUID(packetData);
                            switch (action)
                            {
                            case 0x00:         //Player Join
                                string name    = dataTypes.ReadNextString(packetData);
                                int    propNum = dataTypes.ReadNextVarInt(packetData);
                                for (int p = 0; p < propNum; p++)
                                {
                                    string key = dataTypes.ReadNextString(packetData);
                                    string val = dataTypes.ReadNextString(packetData);
                                    if (dataTypes.ReadNextBool(packetData))
                                    {
                                        dataTypes.ReadNextString(packetData);
                                    }
                                }
                                dataTypes.ReadNextVarInt(packetData);
                                dataTypes.ReadNextVarInt(packetData);
                                if (dataTypes.ReadNextBool(packetData))
                                {
                                    dataTypes.ReadNextString(packetData);
                                }
                                handler.OnPlayerJoin(uuid, name);
                                break;

                            case 0x01:         //Update gamemode
                            case 0x02:         //Update latency
                                dataTypes.ReadNextVarInt(packetData);
                                break;

                            case 0x03:         //Update display name
                                if (dataTypes.ReadNextBool(packetData))
                                {
                                    dataTypes.ReadNextString(packetData);
                                }
                                break;

                            case 0x04:         //Player Leave
                                handler.OnPlayerLeave(uuid);
                                break;

                            default:
                                //Unknown player list item type
                                break;
                            }
                        }
                    }
                    else     //MC 1.7.X does not provide UUID in tab-list updates
                    {
                        string name     = dataTypes.ReadNextString(packetData);
                        bool   online   = dataTypes.ReadNextBool(packetData);
                        short  ping     = dataTypes.ReadNextShort(packetData);
                        Guid   FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray());
                        if (online)
                        {
                            handler.OnPlayerJoin(FakeUUID, name);
                        }
                        else
                        {
                            handler.OnPlayerLeave(FakeUUID);
                        }
                    }
                    break;

                case PacketIncomingType.TabCompleteResult:
                    if (protocolversion >= MC113Version)
                    {
                        autocomplete_transaction_id = dataTypes.ReadNextVarInt(packetData);
                        dataTypes.ReadNextVarInt(packetData);     // Start of text to replace
                        dataTypes.ReadNextVarInt(packetData);     // Length of text to replace
                    }

                    int autocomplete_count = dataTypes.ReadNextVarInt(packetData);
                    autocomplete_result.Clear();

                    for (int i = 0; i < autocomplete_count; i++)
                    {
                        autocomplete_result.Add(dataTypes.ReadNextString(packetData));
                        if (protocolversion >= MC113Version)
                        {
                            // Skip optional tooltip for each tab-complete result
                            if (dataTypes.ReadNextBool(packetData))
                            {
                                dataTypes.ReadNextString(packetData);
                            }
                        }
                    }

                    autocomplete_received = true;
                    break;

                case PacketIncomingType.PluginMessage:
                    String channel = dataTypes.ReadNextString(packetData);
                    // Length is unneeded as the whole remaining packetData is the entire payload of the packet.
                    if (protocolversion < MC18Version)
                    {
                        pForge.ReadNextVarShort(packetData);
                    }
                    handler.OnPluginChannelMessage(channel, packetData.ToArray());
                    return(pForge.HandlePluginMessage(channel, packetData, ref currentDimension));

                case PacketIncomingType.KickPacket:
                    handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick, ChatParser.ParseText(dataTypes.ReadNextString(packetData)));
                    return(false);

                case PacketIncomingType.NetworkCompressionTreshold:
                    if (protocolversion >= MC18Version && protocolversion < MC19Version)
                    {
                        compression_treshold = dataTypes.ReadNextVarInt(packetData);
                    }
                    break;

                case PacketIncomingType.ResourcePackSend:
                    string url  = dataTypes.ReadNextString(packetData);
                    string hash = dataTypes.ReadNextString(packetData);
                    //Send back "accepted" and "successfully loaded" responses for plugins making use of resource pack mandatory
                    byte[] responseHeader = new byte[0];
                    if (protocolversion < MC110Version)     //MC 1.10 does not include resource pack hash in responses
                    {
                        responseHeader = dataTypes.ConcatBytes(dataTypes.GetVarInt(hash.Length), Encoding.UTF8.GetBytes(hash));
                    }
                    SendPacket(PacketOutgoingType.ResourcePackStatus, dataTypes.ConcatBytes(responseHeader, dataTypes.GetVarInt(3)));     //Accepted pack
                    SendPacket(PacketOutgoingType.ResourcePackStatus, dataTypes.ConcatBytes(responseHeader, dataTypes.GetVarInt(0)));     //Successfully loaded
                    break;

                default:
                    return(false); //Ignored packet
                }
                return(true);      //Packet processed
            }
            catch (Exception innerException)
            {
                throw new System.IO.InvalidDataException(
                          String.Format("Failed to process incoming packet of type {0}. (PacketID: {1}, Protocol: {2}, LoginPhase: {3}, InnerException: {4}).",
                                        Protocol18PacketTypes.GetPacketIncomingType(packetID, protocolversion),
                                        packetID,
                                        protocolversion,
                                        login_phase,
                                        innerException.GetType()),
                          innerException);
            }
        }
Beispiel #3
0
        public bool HandlePacket(PacketIncomingType packetType, List <byte> packetData)
        {
            if (protocolversion >= (int)McVersion.V18)
            {
                int action     = dataTypes.ReadNextVarInt(packetData);
                int numActions = dataTypes.ReadNextVarInt(packetData);
                for (int i = 0; i < numActions; i++)
                {
                    Guid uuid = dataTypes.ReadNextUUID(packetData);
                    switch (action)
                    {
                    case 0x00:     //Player Join
                        string name    = dataTypes.ReadNextString(packetData);
                        int    propNum = dataTypes.ReadNextVarInt(packetData);
                        for (int p = 0; p < propNum; p++)
                        {
                            string key = dataTypes.ReadNextString(packetData);
                            string val = dataTypes.ReadNextString(packetData);
                            if (dataTypes.ReadNextBool(packetData))
                            {
                                dataTypes.ReadNextString(packetData);
                            }
                        }
                        dataTypes.ReadNextVarInt(packetData);
                        dataTypes.ReadNextVarInt(packetData);
                        if (dataTypes.ReadNextBool(packetData))
                        {
                            dataTypes.ReadNextString(packetData);
                        }
                        handler.OnPlayerJoin(uuid, name);
                        break;

                    case 0x01:     //Update gamemode
                    case 0x02:     //Update latency
                        dataTypes.ReadNextVarInt(packetData);
                        break;

                    case 0x03:     //Update display name
                        if (dataTypes.ReadNextBool(packetData))
                        {
                            dataTypes.ReadNextString(packetData);
                        }
                        break;

                    case 0x04:     //Player Leave
                        handler.OnPlayerLeave(uuid);
                        break;

                    default:
                        //Unknown player list item type
                        break;
                    }
                }
            }
            else //MC 1.7.X does not provide UUID in tab-list updates
            {
                string name     = dataTypes.ReadNextString(packetData);
                bool   online   = dataTypes.ReadNextBool(packetData);
                short  ping     = dataTypes.ReadNextShort(packetData);
                Guid   FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray());
                if (online)
                {
                    handler.OnPlayerJoin(FakeUUID, name);
                }
                else
                {
                    handler.OnPlayerLeave(FakeUUID);
                }
            }
            return(true);
        }
        /// <summary>
        /// Read and data from the network. Should be called on a separate thread.
        /// </summary>
        /// <returns></returns>

        private bool Update()
        {
            handler.OnUpdate();
            if (c.Client == null || !c.Connected)
            {
                return(false);
            }
            int id = 0, size = 0;

            try
            {
                while (c.Client.Available > 0)
                {
                    size = readNextVarInt(); //Packet size
                    id   = readNextVarInt(); //Packet ID

                    switch (id)
                    {
                    case 0x00:
                        byte[] keepalive = new byte[4] {
                            0, 0, 0, 0
                        };
                        Receive(keepalive, 0, 4, SocketFlags.None);
                        byte[] keepalive_packet = concatBytes(getVarInt(0x00), keepalive);
                        byte[] keepalive_tosend = concatBytes(getVarInt(keepalive_packet.Length), keepalive_packet);
                        Send(keepalive_tosend);
                        break;

                    case 0x02:
                        handler.OnTextReceived(ChatParser.ParseText(readNextString()));
                        break;

                    case 0x38:
                        string name     = readNextString();
                        bool   online   = readNextBool();
                        short  ping     = readNextShort();
                        Guid   FakeUUID = new Guid(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(name)).Take(16).ToArray());
                        if (online)
                        {
                            handler.OnPlayerJoin(FakeUUID, name);
                        }
                        else
                        {
                            handler.OnPlayerLeave(FakeUUID);
                        }
                        break;

                    case 0x3A:
                        int    autocomplete_count = readNextVarInt();
                        string tab_list           = "";
                        for (int i = 0; i < autocomplete_count; i++)
                        {
                            autocomplete_result = readNextString();
                            if (autocomplete_result != "")
                            {
                                tab_list = tab_list + autocomplete_result + " ";
                            }
                        }
                        autocomplete_received = true;
                        tab_list = tab_list.Trim();
                        if (tab_list.Length > 0)
                        {
                            ConsoleIO.WriteLineFormatted("§8" + tab_list, false);
                        }
                        break;

                    case 0x40:
                        handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick, ChatParser.ParseText(readNextString()));
                        return(false);

                    default:
                        readData(size - getVarInt(id).Length);     //Skip packet
                        break;
                    }
                }
            }
            catch (SocketException) { return(false); }
            return(true);
        }
Beispiel #5
0
        /// <summary>
        /// Handle the given packet
        /// </summary>
        /// <param name="packetID">Packet ID</param>
        /// <param name="packetData">Packet contents</param>
        /// <returns>TRUE if the packet was processed, FALSE if ignored or unknown</returns>

        private bool handlePacket(int packetID, byte[] packetData)
        {
            if (login_phase)
            {
                switch (packetID) //Packet IDs are different while logging in
                {
                case 0x03:
                    compression_treshold = readNextVarInt(ref packetData);
                    break;

                default:
                    return(false);    //Ignored packet
                }
            }
            else //Regular in-game packets
            {
                switch (packetID)
                {
                case 0x00:     //Keep-Alive
                    SendPacket(0x00, getVarInt(readNextVarInt(ref packetData)));
                    break;

                case 0x02:     //Chat message
                    handler.OnTextReceived(ChatParser.ParseText(readNextString(ref packetData)));
                    break;

                case 0x38:     //Player List update
                    int  action     = readNextVarInt(ref packetData);
                    int  numActions = readNextVarInt(ref packetData);
                    Guid uuid       = readNextUUID(ref packetData);
                    switch (action)
                    {
                    case 0x00:         //Player Join
                        string name = readNextString(ref packetData);
                        handler.OnPlayerJoin(uuid, name);
                        break;

                    case 0x04:         //Player Leave
                        handler.OnPlayerLeave(uuid);
                        break;

                    default:
                        //Unknown player list item type
                        break;
                    }
                    break;

                case 0x3A:     //Tab-Complete Result
                    int    autocomplete_count = readNextVarInt(ref packetData);
                    string tab_list           = "";
                    for (int i = 0; i < autocomplete_count; i++)
                    {
                        autocomplete_result = readNextString(ref packetData);
                        if (autocomplete_result != "")
                        {
                            tab_list = tab_list + autocomplete_result + " ";
                        }
                    }
                    autocomplete_received = true;
                    tab_list = tab_list.Trim();
                    if (tab_list.Length > 0)
                    {
                        ConsoleIO.WriteLineFormatted("§8" + tab_list, false);
                    }
                    break;

                case 0x40:     //Kick Packet
                    handler.OnConnectionLost(ChatBot.DisconnectReason.InGameKick, ChatParser.ParseText(readNextString(ref packetData)));
                    return(false);

                case 0x46:     //Network Compression Treshold Info
                    compression_treshold = readNextVarInt(ref packetData);
                    break;

                default:
                    return(false);    //Ignored packet
                }
            }
            return(true); //Packet processed
        }