Examples with PlayerListEntry com.github.dirtpowered.dirtmv.data.protocol.objects.tablist.PlayerListEntry used on opensource projects

Example 1 with PlayerListEntry

use of com.github.dirtpowered.dirtmv.data.protocol.objects.tablist.PlayerListEntry in project DirtMultiversion by DirtPowered.

the class ProtocolRelease47To5 method registerTranslators.

@Override
public void registerTranslators() {
    // status ping
    addTranslator(0x00, ProtocolState.STATUS, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            String json = data.read(Type.V1_7_STRING, 0);
            ServerPing serverPing = DirtMultiVersion.GSON.fromJson(json, ServerPing.class);
            ServerPing.Version versionObj = new ServerPing.Version();
            versionObj.setName("1.8.x");
            versionObj.setProtocol(47);
            serverPing.setVersion(versionObj);
            return PacketUtil.createPacket(0x00, new TypeHolder[] { set(Type.V1_7_STRING, serverPing.toString()) });
        }
    });
    // keep alive
    addTranslator(0x00, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x00, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)) });
        }
    });
    // join game
    addTranslator(0x01, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x01, new TypeHolder[] { data.read(0), data.read(1), data.read(2), data.read(3), data.read(4), data.read(5), set(Type.BOOLEAN, false) });
        }
    });
    // login success
    addTranslator(0x02, ProtocolState.LOGIN, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @SneakyThrows
        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            String username = data.read(Type.STRING, 1);
            // block connection thread until profile is fetched
            UUID uuid = GameProfileFetcher.getProfile(username).get().getId();
            String uniqueId = uuid.toString();
            session.getUserData().setUniqueId(uuid);
            // set compression
            enableCompression(session);
            return PacketUtil.createPacket(0x02, new TypeHolder[] { set(Type.V1_7_STRING, uniqueId), set(Type.V1_7_STRING, username) });
        }
    });
    // spawn position
    addTranslator(0x05, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 0);
            int y = data.read(Type.INT, 1);
            int z = data.read(Type.INT, 2);
            return PacketUtil.createPacket(0x05, new TypeHolder[] { set(Type.LONG, toBlockPosition(x, y, z)) });
        }
    });
    // update health
    addTranslator(0x06, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x06, new TypeHolder[] { data.read(0), set(Type.VAR_INT, (int) data.read(Type.SHORT, 1)), data.read(2) });
        }
    });
    // chat
    addTranslator(0x02, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x02, new TypeHolder[] { data.read(0), set(Type.BYTE, (byte) 0) });
        }
    });
    // chunk data
    addTranslator(0x21, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            V1_2Chunk chunk = data.read(Type.V1_3_CHUNK, 0);
            int chunkX = chunk.getChunkX();
            int chunkZ = chunk.getChunkZ();
            short bitmap = chunk.getPrimaryBitmap();
            boolean groundUp = chunk.isGroundUp();
            if (groundUp && bitmap == 0) {
                V1_8Chunk emptyChunk = new V1_8Chunk(chunkX, chunkZ, true, bitmap, new byte[0]);
                ProtocolStorage storage = session.getStorage();
                PortalFrameCache portalFrameCache = storage.get(PortalFrameCache.class);
                portalFrameCache.removeChunk(chunkX, chunkZ);
                return PacketUtil.createPacket(0x21, new TypeHolder[] { new TypeHolder<>(Type.V1_8R_CHUNK, emptyChunk) });
            }
            V1_3ToV1_8ChunkTranslator chunkTransformer;
            if (chunk.getStorage() != null) {
                // use existing chunk storage (pre 1.2 servers)
                chunkTransformer = new V1_3ToV1_8ChunkTranslator(session, chunk.getStorage(), groundUp, bitmap);
            } else {
                ProtocolStorage storage = session.getStorage();
                boolean skyLight = true;
                if (storage.hasObject(DimensionTracker.class)) {
                    DimensionTracker tracker = storage.get(DimensionTracker.class);
                    skyLight = tracker.getDimension() == 0;
                }
                chunkTransformer = new V1_3ToV1_8ChunkTranslator(session, chunk.getUncompressedData(), bitmap, skyLight, groundUp);
            }
            V1_8Chunk newChunk = new V1_8Chunk(chunkX, chunkZ, groundUp, bitmap, chunkTransformer.getChunkData());
            return PacketUtil.createPacket(0x21, new TypeHolder[] { new TypeHolder<>(Type.V1_8R_CHUNK, newChunk) });
        }
    });
    // chunk bulk
    addTranslator(0x26, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            V1_3_4ChunkBulk oldChunkBulk = data.read(Type.V1_4CHUNK_BULK, 0);
            int[] x = oldChunkBulk.getColumnX();
            int[] z = oldChunkBulk.getColumnZ();
            int columnAmount = oldChunkBulk.getChunks().length;
            V1_3ToV1_8ChunkTranslator[] bulks = new V1_3ToV1_8ChunkTranslator[columnAmount];
            for (int i = 0; i < columnAmount; i++) {
                bulks[i] = new V1_3ToV1_8ChunkTranslator(session, oldChunkBulk.getChunks()[i], oldChunkBulk.getPrimaryBitmaps()[i], oldChunkBulk.isSkylight(), true);
            }
            V1_8ChunkBulk.Chunk[] chunks = new V1_8ChunkBulk.Chunk[columnAmount];
            for (int i = 0; i < columnAmount; i++) {
                chunks[i] = new V1_8ChunkBulk.Chunk();
                chunks[i].setData(bulks[i].getChunkData());
                chunks[i].setDataSize(oldChunkBulk.getPrimaryBitmaps()[i]);
            }
            V1_8ChunkBulk chunkBulk = new V1_8ChunkBulk(oldChunkBulk.isSkylight(), x, z, chunks);
            return PacketUtil.createPacket(0x26, new TypeHolder[] { set(Type.V1_8R_CHUNK_BULK, chunkBulk) });
        }
    });
    // multi block change
    addTranslator(0x22, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            V1_2MultiBlockArray blockArray = data.read(Type.V1_2MULTIBLOCK_ARRAY, 2);
            DataInput dis = new DataInputStream(new ByteArrayInputStream(blockArray.getData()));
            BlockChangeRecord[] blockChangeRecords = new BlockChangeRecord[blockArray.getRecordCount()];
            for (int i = 0; i < blockArray.getRecordCount(); i++) {
                try {
                    short pos = dis.readShort();
                    short packedBlock = dis.readShort();
                    int blockId = packedBlock >> 4;
                    int blockData = packedBlock & 15;
                    if (DataFixers.shouldCache(blockId)) {
                        ProtocolStorage storage = session.getStorage();
                        PortalFrameCache portalFrameCache = storage.get(PortalFrameCache.class);
                        int x = pos >> 12 & 15;
                        int y = pos & 255;
                        int z = pos >> 8 & 15;
                        int chunkX = data.read(Type.INT, 0);
                        int chunkZ = data.read(Type.INT, 1);
                        int xPos = x + (chunkX << 4);
                        int zPos = z + (chunkZ << 4);
                        portalFrameCache.setBlockAt(chunkX, chunkZ, xPos, y, zPos, blockId);
                        blockData = DataFixers.getCorrectedDataFor(portalFrameCache, xPos, y, zPos, blockId, blockData);
                    } else {
                        blockData = DataFixers.fixInvalidData(blockId, blockData);
                    }
                    blockChangeRecords[i] = new BlockChangeRecord(pos, (short) (blockId & 4095) << 4 | blockData & 15);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return PacketUtil.createPacket(0x22, new TypeHolder[] { data.read(0), data.read(1), set(Type.V1_8R_MULTIBLOCK_ARRAY, blockChangeRecords) });
        }
    });
    // block change
    addTranslator(0x23, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 0);
            short y = data.read(Type.UNSIGNED_BYTE, 1);
            int z = data.read(Type.INT, 2);
            int blockId = data.read(Type.VAR_INT, 3);
            int blockData = data.read(Type.UNSIGNED_BYTE, 4);
            if (DataFixers.shouldCache(blockId)) {
                ProtocolStorage storage = session.getStorage();
                PortalFrameCache portalFrameCache = storage.get(PortalFrameCache.class);
                portalFrameCache.setBlockAt(x >> 4, z >> 4, x, y, z, blockId);
                blockData = DataFixers.getCorrectedDataFor(portalFrameCache, x, y, z, blockId, blockData);
            } else {
                blockData = DataFixers.fixInvalidData(blockId, blockData);
            }
            return PacketUtil.createPacket(0x23, new TypeHolder[] { set(Type.LONG, toBlockPosition(x, y, z)), set(Type.VAR_INT, blockId << 4 | blockData & 15) });
        }
    });
    // block action
    addTranslator(0x24, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 0);
            short y = data.read(Type.SHORT, 1);
            int z = data.read(Type.INT, 2);
            return PacketUtil.createPacket(0x24, new TypeHolder[] { set(Type.LONG, toBlockPosition(x, y, z)), data.read(3), data.read(4), data.read(5) });
        }
    });
    // block break animation
    addTranslator(0x25, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 1);
            int y = data.read(Type.INT, 2);
            int z = data.read(Type.INT, 3);
            return PacketUtil.createPacket(0x25, new TypeHolder[] { data.read(0), set(Type.LONG, toBlockPosition(x, y, z)), data.read(4) });
        }
    });
    // effect
    addTranslator(0x28, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 1);
            byte y = data.read(Type.BYTE, 2);
            int z = data.read(Type.INT, 3);
            int effectType = data.read(Type.INT, 0);
            if (effectType == 2006) {
                double dist = Math.min(0.2F + data.read(Type.INT, 4) / 15.0F, 10.0F);
                if (dist > 2.5D) {
                    dist = 2.5D;
                }
                int i = (int) (150.0D * dist);
                return PacketUtil.createPacket(0x2A, new TypeHolder[] { set(Type.INT, 38), set(Type.BOOLEAN, false), set(Type.FLOAT, (float) x + 0.5f), set(Type.FLOAT, (float) y + 1.0f), set(Type.FLOAT, (float) z + 0.5f), set(Type.FLOAT, 0f), set(Type.FLOAT, 0f), set(Type.FLOAT, 0f), set(Type.FLOAT, 0.15000000596046448f), set(Type.INT, i), // stone
                set(Type.VAR_INT, 1) });
            }
            return PacketUtil.createPacket(0x28, new TypeHolder[] { data.read(0), set(Type.LONG, toBlockPosition(x, y, z)), data.read(4), data.read(5) });
        }
    });
    // update sign
    addTranslator(0x33, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 0);
            short y = data.read(Type.SHORT, 1);
            int z = data.read(Type.INT, 2);
            String[] lines = new String[4];
            for (int i = 0; i < 4; i++) {
                lines[i] = ChatUtils.legacyToJsonString(data.read(Type.V1_7_STRING, 3 + i));
            }
            return PacketUtil.createPacket(0x33, new TypeHolder[] { set(Type.LONG, toBlockPosition(x, y, z)), set(Type.V1_7_STRING, lines[0]), set(Type.V1_7_STRING, lines[1]), set(Type.V1_7_STRING, lines[2]), set(Type.V1_7_STRING, lines[3]) });
        }
    });
    // sign editor
    addTranslator(0x36, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 0);
            int y = data.read(Type.INT, 1);
            int z = data.read(Type.INT, 2);
            return PacketUtil.createPacket(0x36, new TypeHolder[] { set(Type.LONG, toBlockPosition(x, y, z)) });
        }
    });
    // tab list item
    addTranslator(0x38, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            String u = data.read(Type.V1_7_STRING, 0);
            if (u == null) {
                // skip if server is updating ping or something
                return cancel();
            }
            String username = ChatUtils.stripColor(u);
            boolean online = data.read(Type.BOOLEAN, 1);
            UUID uuid = UUID.nameUUIDFromBytes(("fake:" + username).getBytes(Charsets.UTF_8));
            if (username.equals(session.getUserData().getUsername())) {
                uuid = session.getUserData().getUniqueId();
            }
            if (online) {
                TabListEntry tabAddListEntry = new TabListEntry(TabListAction.ADD_PLAYER, new PlayerListEntry[] { new PlayerListEntry(new GameProfile(uuid, username), new Property[0], 0, 0, null) });
                return PacketUtil.createPacket(0x38, new TypeHolder[] { set(Type.TAB_LIST_ENTRY, tabAddListEntry) });
            } else {
                TabListEntry tabRemoveListEntry = new TabListEntry(TabListAction.REMOVE_PLAYER, new PlayerListEntry[] { new PlayerListEntry(new GameProfile(uuid, username)) });
                return PacketUtil.createPacket(0x38, new TypeHolder[] { set(Type.TAB_LIST_ENTRY, tabRemoveListEntry) });
            }
        }
    });
    // set experience
    addTranslator(0x1F, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x1F, new TypeHolder[] { data.read(0), set(Type.VAR_INT, data.read(Type.SHORT, 1).intValue()), set(Type.VAR_INT, data.read(Type.SHORT, 2).intValue()) });
        }
    });
    // use bed
    addTranslator(0x0A, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 1);
            byte y = data.read(Type.BYTE, 2);
            int z = data.read(Type.INT, 3);
            return PacketUtil.createPacket(0x0A, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), set(Type.LONG, toBlockPosition(x, y, z)) });
        }
    });
    // collect item
    addTranslator(0x0D, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x0D, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), set(Type.VAR_INT, data.read(Type.INT, 1)) });
        }
    });
    // custom payload
    addTranslator(0x3F, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @SneakyThrows
        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            String channel = data.read(Type.V1_7_STRING, 0);
            byte[] bytes = data.read(Type.SHORT_BYTE_ARRAY, 1);
            byte[] remappedData;
            NettyOutputWrapper fixedPayload = new NettyOutputWrapper(Unpooled.buffer());
            switch(channel) {
                case "MC|TrList":
                    NettyInputWrapper buf = new NettyInputWrapper(Unpooled.wrappedBuffer(bytes));
                    fixedPayload.writeInt(buf.readInt());
                    int items = buf.readByte();
                    fixedPayload.writeByte(items);
                    for (int i = 0; i < items; i++) {
                        V1_8RProtocol.ITEM.write(set(Type.V1_8R_ITEM, V1_3_1RProtocol.ITEM.read(buf)), fixedPayload);
                        V1_8RProtocol.ITEM.write(set(Type.V1_8R_ITEM, V1_3_1RProtocol.ITEM.read(buf)), fixedPayload);
                        boolean hasAdditionalItem = buf.readBoolean();
                        fixedPayload.writeBoolean(hasAdditionalItem);
                        if (hasAdditionalItem) {
                            V1_8RProtocol.ITEM.write(set(Type.V1_8R_ITEM, V1_3_1RProtocol.ITEM.read(buf)), fixedPayload);
                        }
                        fixedPayload.writeBoolean(buf.readBoolean());
                        fixedPayload.writeInt(0);
                        fixedPayload.writeInt(7);
                    }
                    remappedData = fixedPayload.array();
                    break;
                case "MC|RPack":
                    return cancel();
                case "MC|Brand":
                    V1_7_2RProtocol.STRING.write(set(Type.V1_7_STRING, new String(bytes, StandardCharsets.UTF_8)), fixedPayload);
                    remappedData = fixedPayload.array();
                    break;
                default:
                    remappedData = bytes;
                    break;
            }
            return PacketUtil.createPacket(0x3F, new TypeHolder[] { data.read(0), set(Type.READABLE_BYTES, remappedData) });
        }
    });
    // entity attributes
    addTranslator(0x20, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x20, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), set(Type.V1_8_ENTITY_ATTRIBUTES, data.read(Type.V1_7_ENTITY_ATTRIBUTES, 1)) });
        }
    });
    // client packets
    // keep alive
    addTranslator(0x00, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x00, new TypeHolder[] { set(Type.INT, data.read(Type.VAR_INT, 0)) });
        }
    });
    // use entity
    addTranslator(0x02, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            OptionalPosition optPos = data.read(Type.V1_8R_USE_ENTITY_OPTIONAL_POSITION, 1);
            int action = optPos.getAction();
            if (action == 2) {
                return cancel();
            }
            return PacketUtil.createPacket(0x02, new TypeHolder[] { set(Type.INT, data.read(Type.VAR_INT, 0)), set(Type.BYTE, (byte) action) });
        }
    });
    // player digging
    addTranslator(0x07, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            long encodedPosition = data.read(Type.LONG, 1);
            int action = data.read(Type.UNSIGNED_BYTE, 0);
            BlockLocation l = fromBlockPosition(encodedPosition);
            ProtocolStorage storage = session.getStorage();
            if (storage.hasObject(BlockMiningTimeFixer.class) && storage.hasObject(BlockStorage.class)) {
                BlockMiningTimeFixer blockMiningTimeFixer = storage.get(BlockMiningTimeFixer.class);
                BlockStorage blockStorage = storage.get(BlockStorage.class);
                switch(action) {
                    case // start digging
                    0:
                        blockMiningTimeFixer.onBlockStartBreaking(l);
                        break;
                    case // cancel digging
                    1:
                        blockMiningTimeFixer.onBlockCancelBreaking(l);
                        break;
                    case // finish digging
                    2:
                        if (HardnessTable.exist(blockStorage.getBlockAt(l.getX(), l.getY(), l.getZ()))) {
                            return cancel();
                        }
                        break;
                }
            }
            return PacketUtil.createPacket(0x07, new TypeHolder[] { data.read(0), set(Type.INT, l.getX()), set(Type.UNSIGNED_BYTE, (short) l.getY()), set(Type.INT, l.getZ()), set(Type.UNSIGNED_BYTE, data.read(Type.BYTE, 2).shortValue()) });
        }
    });
    // place block
    addTranslator(0x08, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            long encodedPosition = data.read(Type.LONG, 0);
            BlockLocation l = fromBlockPosition(encodedPosition);
            ItemStack itemStack = data.read(Type.V1_8R_ITEM, 2);
            // 1.0+ servers are kicking players when placed block is 0. Should be null
            if (itemStack != null && itemStack.getItemId() == 0)
                itemStack = null;
            if (itemStack != null && itemStack.getItemId() == 387) /* written book */
            {
                PacketData payload = PacketUtil.createPacket(0x3F, new TypeHolder[] { set(Type.V1_7_STRING, "MC|BOpen") });
                session.sendPacket(payload, PacketDirection.TO_CLIENT, getFrom());
            }
            return PacketUtil.createPacket(0x08, new TypeHolder[] { set(Type.INT, l.getX()), set(Type.UNSIGNED_BYTE, (short) l.getY()), set(Type.INT, l.getZ()), data.read(1), set(Type.V1_3R_ITEM, itemStack), data.read(3), data.read(4), data.read(5) });
        }
    });
    // animation
    addTranslator(0x0A, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x0A, new TypeHolder[] { set(Type.INT, 0), set(Type.BYTE, (byte) 1) });
        }
    });
    // entity action
    addTranslator(0x0B, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int action = data.read(Type.VAR_INT, 1);
            return PacketUtil.createPacket(0x0B, new TypeHolder[] { set(Type.INT, data.read(Type.VAR_INT, 0)), set(Type.BYTE, (byte) (action + 1)), set(Type.INT, data.read(Type.VAR_INT, 2)) });
        }
    });
    // update sign
    addTranslator(0x12, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            long encodedPosition = data.read(Type.LONG, 0);
            BlockLocation l = fromBlockPosition(encodedPosition);
            String[] lines = new String[4];
            for (int i = 0; i < 4; i++) {
                String msg = data.read(Type.V1_7_STRING, 1 + i);
                if (msg.startsWith("\"")) {
                    msg = ChatUtils.createChatComponentFromInvalidJson(msg);
                }
                msg = ChatUtils.jsonToLegacy(msg);
                msg = StringUtils.substring(msg, 0, 15);
                lines[i] = msg;
            }
            return PacketUtil.createPacket(0x12, new TypeHolder[] { set(Type.INT, l.getX()), set(Type.SHORT, (short) l.getY()), set(Type.INT, l.getZ()), set(Type.V1_7_STRING, lines[0]), set(Type.V1_7_STRING, lines[1]), set(Type.V1_7_STRING, lines[2]), set(Type.V1_7_STRING, lines[3]) });
        }
    });
    // tab complete
    addTranslator(0x14, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x14, new TypeHolder[] { data.read(0) });
        }
    });
    // client settings
    addTranslator(0x15, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x15, new TypeHolder[] { data.read(0), data.read(1), data.read(2), data.read(3), data.read(4), set(Type.BOOLEAN, false) });
        }
    });
    // custom payload
    addTranslator(0x17, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) throws IOException {
            byte[] bytes = data.read(Type.READABLE_BYTES, 1);
            String channel = data.read(Type.V1_7_STRING, 0);
            if (channel.equals("MC|BEdit") || channel.equals("MC|BSign")) {
                NettyInputWrapper in = new NettyInputWrapper(Unpooled.wrappedBuffer(bytes));
                NettyOutputWrapper out = new NettyOutputWrapper(Unpooled.buffer());
                ItemStack compressedItem = V1_8RProtocol.ITEM.read(in);
                V1_3_1RProtocol.ITEM.write(new TypeHolder<>(Type.V1_3R_ITEM, compressedItem), out);
                bytes = out.array();
            }
            return PacketUtil.createPacket(0x17, new TypeHolder[] { data.read(0), set(Type.SHORT_BYTE_ARRAY, bytes) });
        }
    });
    // player input
    addTranslator(0x0C, ProtocolState.PLAY, PacketDirection.TO_SERVER, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            byte status = data.read(Type.BYTE, 2);
            return PacketUtil.createPacket(0x0C, new TypeHolder[] { data.read(0), data.read(1), set(Type.BOOLEAN, (status & 1) == 1), set(Type.BOOLEAN, (status & 2) == 2) });
        }
    });
    // map data
    addTranslator(0x34, -1, ProtocolState.PLAY, PacketDirection.TO_CLIENT);
    // spawn particle
    addTranslator(0x2A, -1, ProtocolState.PLAY, PacketDirection.TO_CLIENT);
}

Example 2 with PlayerListEntry

use of com.github.dirtpowered.dirtmv.data.protocol.objects.tablist.PlayerListEntry in project DirtMultiversion by DirtPowered.

the class TabListEntryDataType method read.

@Override
public TabListEntry read(PacketInput packetInput) throws IOException {
    TabListAction action = TabListAction.fromId(packetInput.readVarInt());
    PlayerListEntry[] entries = new PlayerListEntry[packetInput.readVarInt()];
    for (int i = 0; i < entries.length; i++) {
        UUID uuid = V1_8RProtocol.UUID.read(packetInput);
        String username = V1_7_2RProtocol.STRING.read(packetInput);
        GameProfile profile = action == TabListAction.ADD_PLAYER ? new GameProfile(uuid, username) : new GameProfile(uuid, null);
        PlayerListEntry listEntry = null;
        String displayName = null;
        switch(action) {
            case ADD_PLAYER:
                Property[] properties = new Property[packetInput.readVarInt()];
                for (int j = 0; j < properties.length; j++) {
                    String property = V1_7_2RProtocol.STRING.read(packetInput);
                    String value = V1_7_2RProtocol.STRING.read(packetInput);
                    String signature = null;
                    if (packetInput.readBoolean()) {
                        signature = V1_7_2RProtocol.STRING.read(packetInput);
                    }
                    properties[j] = new Property(property, value, signature);
                }
                int gameMode = packetInput.readVarInt();
                int ping = packetInput.readVarInt();
                if (packetInput.readBoolean()) {
                    displayName = V1_7_2RProtocol.STRING.read(packetInput);
                }
                listEntry = new PlayerListEntry(profile, properties, gameMode, ping, displayName);
                break;
            case UPDATE_GAMEMODE:
                listEntry = new PlayerListEntry(profile, packetInput.readVarInt());
                break;
            case UPDATE_LATENCY:
                listEntry = new PlayerListEntry(profile, packetInput.readVarInt(), true);
                break;
            case UPDATE_DISPLAY_NAME:
                if (packetInput.readBoolean()) {
                    displayName = V1_7_2RProtocol.STRING.read(packetInput);
                }
                listEntry = new PlayerListEntry(profile, displayName);
                break;
            case REMOVE_PLAYER:
                listEntry = new PlayerListEntry(profile);
                break;
        }
        entries[i] = listEntry;
    }
    return new TabListEntry(action, entries);
}

Example 3 with PlayerListEntry

use of com.github.dirtpowered.dirtmv.data.protocol.objects.tablist.PlayerListEntry in project DirtMultiversion by DirtPowered.

the class TabListEntryDataType method write.

@Override
public void write(TypeHolder typeHolder, PacketOutput packetOutput) throws IOException {
    TabListEntry tabListEntry = (TabListEntry) typeHolder.getObject();
    TabListAction action = tabListEntry.getAction();
    packetOutput.writeVarInt(action.getAction());
    PlayerListEntry[] entries = tabListEntry.getEntries();
    packetOutput.writeVarInt(entries.length);
    for (PlayerListEntry entry : entries) {
        V1_8RProtocol.UUID.write(new TypeHolder(Type.UUID, entry.getProfile().getId()), packetOutput);
        switch(action) {
            case ADD_PLAYER:
                V1_7_2RProtocol.STRING.write(new TypeHolder(Type.V1_7_STRING, entry.getProfile().getName()), packetOutput);
                packetOutput.writeVarInt(entry.getProperties().length);
                for (Property property : entry.getProperties()) {
                    V1_7_2RProtocol.STRING.write(new TypeHolder(Type.V1_7_STRING, property.getName()), packetOutput);
                    V1_7_2RProtocol.STRING.write(new TypeHolder(Type.V1_7_STRING, property.getValue()), packetOutput);
                    packetOutput.writeBoolean(property.hasSignature());
                    if (property.hasSignature()) {
                        V1_7_2RProtocol.STRING.write(new TypeHolder(Type.V1_7_STRING, property.getSignature()), packetOutput);
                    }
                }
                packetOutput.writeVarInt(entry.getGameMode());
                packetOutput.writeVarInt(entry.getPing());
                packetOutput.writeBoolean(entry.getDisplayName() != null);
                if (entry.getDisplayName() != null) {
                    V1_7_2RProtocol.STRING.write(new TypeHolder(Type.V1_7_STRING, entry.getDisplayName()), packetOutput);
                }
                break;
            case UPDATE_GAMEMODE:
                packetOutput.writeVarInt(entry.getGameMode());
                break;
            case UPDATE_LATENCY:
                packetOutput.writeVarInt(entry.getPing());
                break;
            case UPDATE_DISPLAY_NAME:
                packetOutput.writeBoolean(entry.getDisplayName() != null);
                if (entry.getDisplayName() != null) {
                    V1_7_2RProtocol.STRING.write(new TypeHolder(Type.V1_7_STRING, entry.getDisplayName()), packetOutput);
                }
                break;
            case REMOVE_PLAYER:
                break;
        }
    }
}

Example 4 with PlayerListEntry

use of com.github.dirtpowered.dirtmv.data.protocol.objects.tablist.PlayerListEntry in project DirtMultiversion by DirtPowered.

the class EntityPackets method registerTranslators.

@Override
public void registerTranslators() {
    // spawn mob
    addTranslator(0x0F, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            ProtocolStorage storage = session.getStorage();
            EntityType entityType = EntityType.fromEntityTypeId(data.read(Type.BYTE, 1));
            if (storage.hasObject(V1_7EntityTracker.class)) {
                V1_7EntityTracker tracker = storage.get(V1_7EntityTracker.class);
                int entityId = data.read(Type.VAR_INT, 0);
                tracker.addEntity(entityId, entityType);
            }
            WatchableObject[] oldMeta = data.read(Type.V1_7R_METADATA, 11);
            WatchableObject[] newMeta = metadataTransformer.transformMetadata(entityType, oldMeta);
            return PacketUtil.createPacket(0x0F, new TypeHolder[] { data.read(0), data.read(1), data.read(2), data.read(3), data.read(4), data.read(5), data.read(6), data.read(7), data.read(8), data.read(9), data.read(10), set(Type.V1_8R_METADATA, newMeta) });
        }
    });
    // entity metadata
    addTranslator(0x1C, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            ProtocolStorage storage = session.getStorage();
            SpawnableObject entityObject = null;
            int entityId = data.read(Type.INT, 0);
            if (storage.hasObject(EntityTracker.class)) {
                EntityTracker tracker = storage.get(EntityTracker.class);
                entityObject = tracker.getEntityById(entityId);
            } else if (storage.hasObject(V1_7EntityTracker.class)) {
                V1_7EntityTracker tracker = storage.get(V1_7EntityTracker.class);
                entityObject = tracker.getEntityById(entityId);
            }
            if (entityObject == null)
                return cancel();
            WatchableObject[] oldMeta = data.read(Type.V1_7R_METADATA, 1);
            WatchableObject[] watchableObjects = metadataTransformer.transformMetadata(entityObject, oldMeta);
            for (int i = 0; i < watchableObjects.length; i++) {
                WatchableObject watchableObject = watchableObjects[i];
                if (watchableObject.getType() == MetadataType.ITEM) {
                    ItemStack obj = (ItemStack) watchableObject.getValue();
                    if (obj != null) {
                        obj = InventoryPackets.itemRemapper.replaceItem(obj);
                    }
                    watchableObjects[i] = new WatchableObject(MetadataType.ITEM, watchableObject.getIndex(), obj);
                }
            }
            return PacketUtil.createPacket(0x1C, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), set(Type.V1_8R_METADATA, watchableObjects) });
        }
    });
    // entity velocity
    addTranslator(0x12, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x12, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), data.read(1), data.read(2), data.read(3) });
        }
    });
    // entity destroy
    addTranslator(0x13, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            ProtocolStorage storage = session.getStorage();
            int[] entities = data.read(Type.BYTE_INT_ARRAY, 0);
            if (storage.hasObject(V1_7EntityTracker.class)) {
                for (int entityId : entities) {
                    V1_7EntityTracker tracker = storage.get(V1_7EntityTracker.class);
                    tracker.removeEntity(entityId);
                }
            }
            return PacketUtil.createPacket(0x13, new TypeHolder[] { set(Type.VAR_INT_ARRAY, entities) });
        }
    });
    // spawn player
    addTranslator(0x0C, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @SneakyThrows
        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            ProtocolStorage storage = session.getStorage();
            UUID uniqueId = UUID.fromString(data.read(Type.V1_7_STRING, 1));
            String username = data.read(Type.V1_7_STRING, 2);
            GameProfile profile = GameProfileFetcher.getProfile(username).get();
            if (storage.hasObject(V1_7EntityTracker.class)) {
                V1_7EntityTracker tracker = storage.get(V1_7EntityTracker.class);
                int entityId = data.read(Type.VAR_INT, 0);
                tracker.addEntity(entityId, EntityType.HUMAN);
            }
            WatchableObject[] oldMeta = data.read(Type.V1_7R_METADATA, 10);
            WatchableObject[] newMeta = metadataTransformer.transformMetadata(EntityType.HUMAN, oldMeta);
            // skin layers
            WatchableObject[] layers = new WatchableObject[newMeta.length + 1];
            System.arraycopy(newMeta, 0, layers, 0, newMeta.length);
            layers[newMeta.length] = new WatchableObject(MetadataType.BYTE, 10, (byte) 127);
            newMeta = layers;
            PacketData playerSpawn = PacketUtil.createPacket(0x0C, new TypeHolder[] { data.read(0), set(Type.UUID, profile.getId()), data.read(4), data.read(5), data.read(6), data.read(7), data.read(8), data.read(9), set(Type.V1_8R_METADATA, newMeta) });
            // create fake profile
            // GameProfile profile = new GameProfile(uniqueId, username);
            TabListEntry tabAddListEntry = new TabListEntry(TabListAction.ADD_PLAYER, new PlayerListEntry[] { new PlayerListEntry(profile, new Property[0], 0, 0, null) });
            PacketData tabEntry = PacketUtil.createPacket(0x38, new TypeHolder[] { set(Type.TAB_LIST_ENTRY, tabAddListEntry) });
            // seems that client overwrites old tab packet after sending a new one
            session.sendPacket(tabEntry, PacketDirection.TO_CLIENT, getFrom());
            // send player spawn (right after tablist packet)
            session.sendPacket(playerSpawn, PacketDirection.TO_CLIENT, getFrom());
            new Timer().schedule(new TimerTask() {

                @Override
                public void run() {
                    TabListEntry tabRemoveListEntry = new TabListEntry(TabListAction.REMOVE_PLAYER, new PlayerListEntry[] { new PlayerListEntry(profile, new Property[0], 0, 0, null) });
                    PacketData removeTab = PacketUtil.createPacket(0x38, new TypeHolder[] { set(Type.TAB_LIST_ENTRY, tabRemoveListEntry) });
                    session.sendPacket(removeTab, PacketDirection.TO_CLIENT, getFrom());
                }
            }, 40L);
            return cancel();
        }
    });
    // entity equipment
    addTranslator(0x04, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            ItemStack originalItem = data.read(Type.V1_3R_ITEM, 2);
            if (originalItem != null) {
                originalItem = InventoryPackets.itemRemapper.replaceItem(originalItem);
            }
            return PacketUtil.createPacket(0x04, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), data.read(1), set(Type.V1_8R_ITEM, originalItem) });
        }
    });
    // update tile entity
    addTranslator(0x35, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 0);
            short y = data.read(Type.SHORT, 1);
            int z = data.read(Type.INT, 2);
            return PacketUtil.createPacket(0x35, new TypeHolder[] { set(Type.LONG, ProtocolRelease47To5.toBlockPosition(x, y, z)), data.read(3), set(Type.COMPRESSED_COMPOUND_TAG, data.read(Type.COMPOUND_TAG, 4)) });
        }
    });
    // spawn painting
    addTranslator(0x10, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            int x = data.read(Type.INT, 2);
            int y = data.read(Type.INT, 3);
            int z = data.read(Type.INT, 4);
            int direction = data.read(Type.INT, 5);
            switch(direction) {
                case 0:
                    z += 1;
                    break;
                case 1:
                    x -= 1;
                    break;
                case 2:
                    z -= 1;
                    break;
                case 3:
                    x += 1;
                    break;
            }
            return PacketUtil.createPacket(0x10, new TypeHolder[] { data.read(0), data.read(1), set(Type.LONG, ProtocolRelease47To5.toBlockPosition(x, y, z)), set(Type.BYTE, data.read(Type.INT, 5).byteValue()) });
        }
    });
    // entity effect
    addTranslator(0x1D, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x1D, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), data.read(1), data.read(2), set(Type.VAR_INT, data.read(Type.SHORT, 3).intValue()), set(Type.BOOLEAN, false) });
        }
    });
    // remove entity effect
    addTranslator(0x1E, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            return PacketUtil.createPacket(0x1E, new TypeHolder[] { set(Type.VAR_INT, data.read(Type.INT, 0)), data.read(1) });
        }
    });
    // spawn object
    addTranslator(0x0E, ProtocolState.PLAY, PacketDirection.TO_CLIENT, new PacketTranslator() {

        @Override
        public PacketData translate(ServerSession session, PacketData data) {
            ProtocolStorage storage = session.getStorage();
            int x = data.read(Type.INT, 2);
            int y = data.read(Type.INT, 3);
            int z = data.read(Type.INT, 4);
            byte type = data.read(Type.BYTE, 1);
            byte yaw = data.read(Type.BYTE, 6);
            Motion motionData = data.read(Type.MOTION, 7);
            ObjectType objectType = ObjectType.fromObjectTypeId(type);
            switch(objectType) {
                case ITEM:
                    y -= 4;
                    break;
                case TNT_PRIMED:
                    y -= 16;
                    break;
                case FALLING_OBJECT:
                    int itemId = motionData.getThrowerId();
                    int itemData = motionData.getThrowerId() >> 16;
                    short mX = motionData.getMotionX();
                    short mY = motionData.getMotionY();
                    short mZ = motionData.getMotionZ();
                    y -= 16;
                    motionData = new Motion(itemId | itemData << 12, mX, mY, mZ);
                    break;
                case ITEM_FRAME:
                    int rotation = motionData.getThrowerId();
                    if (rotation == 0) {
                        z += 32;
                        yaw = 0;
                    } else if (rotation == 1) {
                        x -= 32;
                        yaw = 64;
                    } else if (rotation == 2) {
                        z -= 32;
                        yaw = -128;
                    } else if (rotation == 3) {
                        x += 32;
                        yaw = -64;
                    }
                    break;
            }
            if (storage.hasObject(V1_7EntityTracker.class)) {
                V1_7EntityTracker tracker = storage.get(V1_7EntityTracker.class);
                int entityId = data.read(Type.VAR_INT, 0);
                tracker.addEntity(entityId, objectType);
            }
            return PacketUtil.createPacket(0x0E, new TypeHolder[] { data.read(0), set(Type.BYTE, type), set(Type.INT, x), set(Type.INT, y), set(Type.INT, z), data.read(5), set(Type.BYTE, yaw), set(Type.MOTION, motionData) });
        }
    });
}