Examples with NbtMapBuilder com.nukkitx.nbt.NbtMapBuilder used on opensource projects

Example 26 with NbtMapBuilder

use of com.nukkitx.nbt.NbtMapBuilder in project Geyser by GeyserMC.

the class BeaconInventoryTranslator method updateProperty.

@Override
public void updateProperty(GeyserSession session, Inventory inventory, int key, int value) {
    // FIXME?: Beacon graphics look weird after inputting an item. This might be a Bedrock bug, since it resets to nothing
    // on BDS
    BeaconContainer beaconContainer = (BeaconContainer) inventory;
    switch(key) {
        case 0:
            // Power - beacon doesn't use this, and uses the block position instead
            break;
        case 1:
            beaconContainer.setPrimaryId(value == -1 ? 0 : value);
            break;
        case 2:
            beaconContainer.setSecondaryId(value == -1 ? 0 : value);
            break;
    }
    // Send a block entity data packet update to the fake beacon inventory
    Vector3i position = inventory.getHolderPosition();
    NbtMapBuilder builder = NbtMap.builder().putInt("x", position.getX()).putInt("y", position.getY()).putInt("z", position.getZ()).putString("CustomName", inventory.getTitle()).putString("id", "Beacon").putInt("primary", beaconContainer.getPrimaryId()).putInt("secondary", beaconContainer.getSecondaryId());
    BlockEntityDataPacket packet = new BlockEntityDataPacket();
    packet.setBlockPosition(position);
    packet.setData(builder.build());
    session.sendUpstreamPacket(packet);
}

Example 27 with NbtMapBuilder

use of com.nukkitx.nbt.NbtMapBuilder in project Geyser by GeyserMC.

the class DoubleChestInventoryTranslator method prepareInventory.

@Override
public void prepareInventory(GeyserSession session, Inventory inventory) {
    // See BlockInventoryHolder - same concept there except we're also dealing with a specific block state
    if (session.getLastInteractionPlayerPosition().equals(session.getPlayerEntity().getPosition())) {
        int javaBlockId = session.getGeyser().getWorldManager().getBlockAt(session, session.getLastInteractionBlockPosition());
        String[] javaBlockString = BlockRegistries.JAVA_IDENTIFIERS.get().getOrDefault(javaBlockId, "minecraft:air").split("\\[");
        if (javaBlockString.length > 1 && (javaBlockString[0].equals("minecraft:chest") || javaBlockString[0].equals("minecraft:trapped_chest")) && !javaBlockString[1].contains("type=single")) {
            inventory.setHolderPosition(session.getLastInteractionBlockPosition());
            ((Container) inventory).setUsingRealBlock(true, javaBlockString[0]);
            NbtMapBuilder tag = NbtMap.builder().putString("id", "Chest").putInt("x", session.getLastInteractionBlockPosition().getX()).putInt("y", session.getLastInteractionBlockPosition().getY()).putInt("z", session.getLastInteractionBlockPosition().getZ()).putString("CustomName", inventory.getTitle()).putString("id", "Chest");
            DoubleChestValue chestValue = BlockStateValues.getDoubleChestValues().get(javaBlockId);
            DoubleChestBlockEntityTranslator.translateChestValue(tag, chestValue, session.getLastInteractionBlockPosition().getX(), session.getLastInteractionBlockPosition().getZ());
            BlockEntityDataPacket dataPacket = new BlockEntityDataPacket();
            dataPacket.setData(tag.build());
            dataPacket.setBlockPosition(session.getLastInteractionBlockPosition());
            session.sendUpstreamPacket(dataPacket);
            return;
        }
    }
    Vector3i position = session.getPlayerEntity().getPosition().toInt().add(Vector3i.UP);
    Vector3i pairPosition = position.add(Vector3i.UNIT_X);
    int bedrockBlockId = session.getBlockMappings().getBedrockBlockId(defaultJavaBlockState);
    UpdateBlockPacket blockPacket = new UpdateBlockPacket();
    blockPacket.setDataLayer(0);
    blockPacket.setBlockPosition(position);
    blockPacket.setRuntimeId(bedrockBlockId);
    blockPacket.getFlags().addAll(UpdateBlockPacket.FLAG_ALL_PRIORITY);
    session.sendUpstreamPacket(blockPacket);
    NbtMap tag = NbtMap.builder().putString("id", "Chest").putInt("x", position.getX()).putInt("y", position.getY()).putInt("z", position.getZ()).putInt("pairx", pairPosition.getX()).putInt("pairz", pairPosition.getZ()).putString("CustomName", inventory.getTitle()).build();
    BlockEntityDataPacket dataPacket = new BlockEntityDataPacket();
    dataPacket.setData(tag);
    dataPacket.setBlockPosition(position);
    session.sendUpstreamPacket(dataPacket);
    blockPacket = new UpdateBlockPacket();
    blockPacket.setDataLayer(0);
    blockPacket.setBlockPosition(pairPosition);
    blockPacket.setRuntimeId(bedrockBlockId);
    blockPacket.getFlags().addAll(UpdateBlockPacket.FLAG_ALL_PRIORITY);
    session.sendUpstreamPacket(blockPacket);
    tag = NbtMap.builder().putString("id", "Chest").putInt("x", pairPosition.getX()).putInt("y", pairPosition.getY()).putInt("z", pairPosition.getZ()).putInt("pairx", position.getX()).putInt("pairz", position.getZ()).putString("CustomName", inventory.getTitle()).build();
    dataPacket = new BlockEntityDataPacket();
    dataPacket.setData(tag);
    dataPacket.setBlockPosition(pairPosition);
    session.sendUpstreamPacket(dataPacket);
    inventory.setHolderPosition(position);
}

Example 28 with NbtMapBuilder

use of com.nukkitx.nbt.NbtMapBuilder in project Geyser by GeyserMC.

the class FireworkEntity method setFireworkItem.

public void setFireworkItem(EntityMetadata<ItemStack, ?> entityMetadata) {
    ItemStack item = entityMetadata.getValue();
    if (item == null) {
        return;
    }
    CompoundTag tag = item.getNbt();
    if (tag == null) {
        return;
    }
    // https://bugs.mojang.com/browse/MCPE-89115
    if (session.getClientData().getDeviceOs() == DeviceOs.XBOX || session.getClientData().getDeviceOs() == DeviceOs.PS4) {
        return;
    }
    CompoundTag fireworks = tag.get("Fireworks");
    if (fireworks == null) {
        // Thank you Mineplex very cool
        return;
    }
    NbtMapBuilder fireworksBuilder = NbtMap.builder();
    if (fireworks.get("Flight") != null) {
        fireworksBuilder.putByte("Flight", MathUtils.getNbtByte(fireworks.get("Flight").getValue()));
    }
    List<NbtMap> explosions = new ArrayList<>();
    if (fireworks.get("Explosions") != null) {
        for (Tag effect : ((ListTag) fireworks.get("Explosions")).getValue()) {
            CompoundTag effectData = (CompoundTag) effect;
            NbtMapBuilder effectBuilder = NbtMap.builder();
            if (effectData.get("Type") != null) {
                effectBuilder.putByte("FireworkType", MathUtils.getNbtByte(effectData.get("Type").getValue()));
            }
            if (effectData.get("Colors") != null) {
                int[] oldColors = (int[]) effectData.get("Colors").getValue();
                byte[] colors = new byte[oldColors.length];
                int i = 0;
                for (int color : oldColors) {
                    colors[i++] = FireworkColor.fromJavaRGB(color);
                }
                effectBuilder.putByteArray("FireworkColor", colors);
            }
            if (effectData.get("FadeColors") != null) {
                int[] oldColors = (int[]) effectData.get("FadeColors").getValue();
                byte[] colors = new byte[oldColors.length];
                int i = 0;
                for (int color : oldColors) {
                    colors[i++] = FireworkColor.fromJavaRGB(color);
                }
                effectBuilder.putByteArray("FireworkFade", colors);
            }
            if (effectData.get("Trail") != null) {
                effectBuilder.putByte("FireworkTrail", MathUtils.getNbtByte(effectData.get("Trail").getValue()));
            }
            if (effectData.get("Flicker") != null) {
                effectBuilder.putByte("FireworkFlicker", MathUtils.getNbtByte(effectData.get("Flicker").getValue()));
            }
            explosions.add(effectBuilder.build());
        }
    }
    fireworksBuilder.putList("Explosions", NbtType.COMPOUND, explosions);
    NbtMapBuilder builder = NbtMap.builder();
    builder.put("Fireworks", fireworksBuilder.build());
    dirtyMetadata.put(EntityData.DISPLAY_ITEM, builder.build());
}

Example 29 with NbtMapBuilder

use of com.nukkitx.nbt.NbtMapBuilder in project Geyser by GeyserMC.

the class ItemRegistryPopulator method populate.

public static void populate() {
    GeyserBootstrap bootstrap = GeyserImpl.getInstance().getBootstrap();
    TypeReference<Map<String, GeyserMappingItem>> mappingItemsType = new TypeReference<>() {
    };
    Map<String, GeyserMappingItem> items;
    try (InputStream stream = bootstrap.getResource("mappings/items.json")) {
        // Load item mappings from Java Edition to Bedrock Edition
        items = GeyserImpl.JSON_MAPPER.readValue(stream, mappingItemsType);
    } catch (Exception e) {
        throw new AssertionError("Unable to load Java runtime item IDs", e);
    }
    // We can reduce some operations as Java information is the same across all palette versions
    boolean firstMappingsPass = true;
    Int2IntMap dyeColors = new FixedInt2IntMap();
    /* Load item palette */
    for (Map.Entry<String, PaletteVersion> palette : PALETTE_VERSIONS.entrySet()) {
        TypeReference<List<PaletteItem>> paletteEntriesType = new TypeReference<>() {
        };
        // Used to get the Bedrock namespaced ID (in instances where there are small differences)
        Object2IntMap<String> bedrockIdentifierToId = new Object2IntOpenHashMap<>();
        bedrockIdentifierToId.defaultReturnValue(Short.MIN_VALUE);
        List<String> itemNames = new ArrayList<>();
        List<PaletteItem> itemEntries;
        try (InputStream stream = bootstrap.getResource(String.format("bedrock/runtime_item_states.%s.json", palette.getKey()))) {
            itemEntries = GeyserImpl.JSON_MAPPER.readValue(stream, paletteEntriesType);
        } catch (Exception e) {
            throw new AssertionError("Unable to load Bedrock runtime item IDs", e);
        }
        Map<String, StartGamePacket.ItemEntry> entries = new Object2ObjectOpenHashMap<>();
        for (PaletteItem entry : itemEntries) {
            entries.put(entry.getName(), new StartGamePacket.ItemEntry(entry.getName(), (short) entry.getId()));
            bedrockIdentifierToId.put(entry.getName(), entry.getId());
        }
        Object2IntMap<String> bedrockBlockIdOverrides = new Object2IntOpenHashMap<>();
        Object2IntMap<String> blacklistedIdentifiers = new Object2IntOpenHashMap<>();
        // Load creative items
        // We load this before item mappings to get overridden block runtime ID mappings
        JsonNode creativeItemEntries;
        try (InputStream stream = bootstrap.getResource(String.format("bedrock/creative_items.%s.json", palette.getKey()))) {
            creativeItemEntries = GeyserImpl.JSON_MAPPER.readTree(stream).get("items");
        } catch (Exception e) {
            throw new AssertionError("Unable to load creative items", e);
        }
        IntList boats = new IntArrayList();
        IntList buckets = new IntArrayList();
        IntList spawnEggs = new IntArrayList();
        List<ItemData> carpets = new ObjectArrayList<>();
        Int2ObjectMap<ItemMapping> mappings = new Int2ObjectOpenHashMap<>();
        // Temporary mapping to create stored items
        Map<String, ItemMapping> identifierToMapping = new Object2ObjectOpenHashMap<>();
        int netId = 1;
        List<ItemData> creativeItems = new ArrayList<>();
        for (JsonNode itemNode : creativeItemEntries) {
            int count = 1;
            int damage = 0;
            int blockRuntimeId = 0;
            NbtMap tag = null;
            JsonNode damageNode = itemNode.get("damage");
            if (damageNode != null) {
                damage = damageNode.asInt();
            }
            JsonNode countNode = itemNode.get("count");
            if (countNode != null) {
                count = countNode.asInt();
            }
            JsonNode blockRuntimeIdNode = itemNode.get("blockRuntimeId");
            if (blockRuntimeIdNode != null) {
                blockRuntimeId = blockRuntimeIdNode.asInt();
            }
            JsonNode nbtNode = itemNode.get("nbt_b64");
            if (nbtNode != null) {
                byte[] bytes = Base64.getDecoder().decode(nbtNode.asText());
                ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
                try {
                    tag = (NbtMap) NbtUtils.createReaderLE(bais).readTag();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            String identifier = itemNode.get("id").textValue();
            if (identifier.equals("minecraft:debug_stick")) {
                // Just shows an empty texture; either way it doesn't exist in the creative menu on Java
                continue;
            }
            StartGamePacket.ItemEntry entry = entries.get(identifier);
            int id = -1;
            if (entry != null) {
                id = entry.getId();
            }
            if (id == -1) {
                throw new RuntimeException("Unable to find matching Bedrock item for " + identifier);
            }
            creativeItems.add(ItemData.builder().id(id).damage(damage).count(count).blockRuntimeId(blockRuntimeId).tag(tag).netId(netId++).build());
            if (blockRuntimeId != 0) {
                // Add override for item mapping, unless it already exists... then we know multiple states can exist
                if (!blacklistedIdentifiers.containsKey(identifier)) {
                    if (bedrockBlockIdOverrides.containsKey(identifier)) {
                        bedrockBlockIdOverrides.removeInt(identifier);
                        // Save this as a blacklist, but also as knowledge of what the block state name should be
                        blacklistedIdentifiers.put(identifier, blockRuntimeId);
                    } else {
                        // Unless there's multiple possibilities for this one state, let this be
                        bedrockBlockIdOverrides.put(identifier, blockRuntimeId);
                    }
                }
            }
        }
        BlockMappings blockMappings = BlockRegistries.BLOCKS.forVersion(palette.getValue().protocolVersion());
        int itemIndex = 0;
        int javaFurnaceMinecartId = 0;
        boolean usingFurnaceMinecart = GeyserImpl.getInstance().getConfig().isAddNonBedrockItems();
        Set<String> javaOnlyItems = new ObjectOpenHashSet<>();
        Collections.addAll(javaOnlyItems, "minecraft:spectral_arrow", "minecraft:debug_stick", "minecraft:knowledge_book", "minecraft:tipped_arrow", "minecraft:trader_llama_spawn_egg", "minecraft:bundle");
        if (!usingFurnaceMinecart) {
            javaOnlyItems.add("minecraft:furnace_minecart");
        }
        // Java-only items for this version
        javaOnlyItems.addAll(palette.getValue().additionalTranslatedItems().keySet());
        for (Map.Entry<String, GeyserMappingItem> entry : items.entrySet()) {
            String javaIdentifier = entry.getKey().intern();
            GeyserMappingItem mappingItem;
            String replacementItem = palette.getValue().additionalTranslatedItems().get(javaIdentifier);
            if (replacementItem != null) {
                mappingItem = items.get(replacementItem);
            } else {
                // This items has a mapping specifically for this version of the game
                mappingItem = entry.getValue();
            }
            String bedrockIdentifier;
            if (javaIdentifier.equals("minecraft:music_disc_otherside") && palette.getValue().protocolVersion() <= Bedrock_v471.V471_CODEC.getProtocolVersion()) {
                bedrockIdentifier = "minecraft:music_disc_pigstep";
            } else if (javaIdentifier.equals("minecraft:globe_banner_pattern") && palette.getValue().protocolVersion() < Bedrock_v486.V486_CODEC.getProtocolVersion()) {
                bedrockIdentifier = "minecraft:banner_pattern";
            } else {
                bedrockIdentifier = mappingItem.getBedrockIdentifier();
            }
            if (usingFurnaceMinecart && javaIdentifier.equals("minecraft:furnace_minecart")) {
                javaFurnaceMinecartId = itemIndex;
                itemIndex++;
                continue;
            }
            int bedrockId = bedrockIdentifierToId.getInt(bedrockIdentifier);
            if (bedrockId == Short.MIN_VALUE) {
                throw new RuntimeException("Missing Bedrock ID in mappings: " + bedrockIdentifier);
            }
            int stackSize = mappingItem.getStackSize();
            int bedrockBlockId = -1;
            Integer firstBlockRuntimeId = entry.getValue().getFirstBlockRuntimeId();
            if (firstBlockRuntimeId != null) {
                int blockIdOverride = bedrockBlockIdOverrides.getOrDefault(bedrockIdentifier, -1);
                if (blockIdOverride != -1) {
                    // Straight from BDS is our best chance of getting an item that doesn't run into issues
                    bedrockBlockId = blockIdOverride;
                } else {
                    // Try to get an example block runtime ID from the creative contents packet, for Bedrock identifier obtaining
                    int aValidBedrockBlockId = blacklistedIdentifiers.getOrDefault(bedrockIdentifier, -1);
                    if (aValidBedrockBlockId == -1) {
                        // Fallback
                        bedrockBlockId = blockMappings.getBedrockBlockId(firstBlockRuntimeId);
                    } else {
                        // As of 1.16.220, every item requires a block runtime ID attached to it.
                        // This is mostly for identifying different blocks with the same item ID - wool, slabs, some walls.
                        // However, in order for some visuals and crafting to work, we need to send the first matching block state
                        // as indexed by Bedrock's block palette
                        // There are exceptions! But, ideally, the block ID override should take care of those.
                        NbtMapBuilder requiredBlockStatesBuilder = NbtMap.builder();
                        String correctBedrockIdentifier = blockMappings.getBedrockBlockStates().get(aValidBedrockBlockId).getString("name");
                        boolean firstPass = true;
                        // Block states are all grouped together. In the mappings, we store the first block runtime ID in order,
                        // and the last, if relevant. We then iterate over all those values and get their Bedrock equivalents
                        Integer lastBlockRuntimeId = entry.getValue().getLastBlockRuntimeId() == null ? firstBlockRuntimeId : entry.getValue().getLastBlockRuntimeId();
                        for (int i = firstBlockRuntimeId; i <= lastBlockRuntimeId; i++) {
                            int bedrockBlockRuntimeId = blockMappings.getBedrockBlockId(i);
                            NbtMap blockTag = blockMappings.getBedrockBlockStates().get(bedrockBlockRuntimeId);
                            String bedrockName = blockTag.getString("name");
                            if (!bedrockName.equals(correctBedrockIdentifier)) {
                                continue;
                            }
                            NbtMap states = blockTag.getCompound("states");
                            if (firstPass) {
                                firstPass = false;
                                if (states.size() == 0) {
                                    // No need to iterate and find all block states - this is the one, as there can't be any others
                                    bedrockBlockId = bedrockBlockRuntimeId;
                                    break;
                                }
                                requiredBlockStatesBuilder.putAll(states);
                                continue;
                            }
                            for (Map.Entry<String, Object> nbtEntry : states.entrySet()) {
                                Object value = requiredBlockStatesBuilder.get(nbtEntry.getKey());
                                if (value != null && !nbtEntry.getValue().equals(value)) {
                                    // Null means this value has already been removed/deemed as unneeded
                                    // This state can change between different block states, and therefore is not required
                                    // to build a successful block state of this
                                    requiredBlockStatesBuilder.remove(nbtEntry.getKey());
                                }
                            }
                            if (requiredBlockStatesBuilder.size() == 0) {
                                // (States that are important include color for glass)
                                break;
                            }
                        }
                        NbtMap requiredBlockStates = requiredBlockStatesBuilder.build();
                        if (bedrockBlockId == -1) {
                            int i = -1;
                            // in it's "preferred" block state - I.E. the first matching block state in the list
                            for (NbtMap blockTag : blockMappings.getBedrockBlockStates()) {
                                i++;
                                if (blockTag.getString("name").equals(correctBedrockIdentifier)) {
                                    NbtMap states = blockTag.getCompound("states");
                                    boolean valid = true;
                                    for (Map.Entry<String, Object> nbtEntry : requiredBlockStates.entrySet()) {
                                        if (!states.get(nbtEntry.getKey()).equals(nbtEntry.getValue())) {
                                            // A required block state doesn't match - this one is not valid
                                            valid = false;
                                            break;
                                        }
                                    }
                                    if (valid) {
                                        bedrockBlockId = i;
                                        break;
                                    }
                                }
                            }
                            if (bedrockBlockId == -1) {
                                throw new RuntimeException("Could not find a block match for " + entry.getKey());
                            }
                        }
                        // That way, creative items work correctly for these blocks
                        for (int j = 0; j < creativeItems.size(); j++) {
                            ItemData itemData = creativeItems.get(j);
                            if (itemData.getId() == bedrockId) {
                                if (itemData.getDamage() != 0) {
                                    break;
                                }
                                NbtMap states = blockMappings.getBedrockBlockStates().get(itemData.getBlockRuntimeId()).getCompound("states");
                                boolean valid = true;
                                for (Map.Entry<String, Object> nbtEntry : requiredBlockStates.entrySet()) {
                                    if (!states.get(nbtEntry.getKey()).equals(nbtEntry.getValue())) {
                                        // A required block state doesn't match - this one is not valid
                                        valid = false;
                                        break;
                                    }
                                }
                                if (valid) {
                                    creativeItems.set(j, itemData.toBuilder().blockRuntimeId(bedrockBlockId).build());
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            ItemMapping.ItemMappingBuilder mappingBuilder = ItemMapping.builder().javaIdentifier(javaIdentifier).javaId(itemIndex).bedrockIdentifier(bedrockIdentifier.intern()).bedrockId(bedrockId).bedrockData(mappingItem.getBedrockData()).bedrockBlockId(bedrockBlockId).stackSize(stackSize).maxDamage(mappingItem.getMaxDamage()).hasSuspiciousStewEffect(mappingItem.isHasSuspiciousStewEffect());
            if (mappingItem.getRepairMaterials() != null) {
                mappingBuilder = mappingBuilder.repairMaterials(new ObjectOpenHashSet<>(mappingItem.getRepairMaterials()));
            }
            if (mappingItem.getToolType() != null) {
                if (mappingItem.getToolTier() != null) {
                    mappingBuilder = mappingBuilder.toolType(mappingItem.getToolType().intern()).toolTier(mappingItem.getToolTier().intern());
                } else {
                    mappingBuilder = mappingBuilder.toolType(mappingItem.getToolType().intern()).toolTier("");
                }
            }
            if (javaOnlyItems.contains(javaIdentifier)) {
                // These items don't exist on Bedrock, so set up a variable that indicates they should have custom names
                mappingBuilder = mappingBuilder.translationString((bedrockBlockId != -1 ? "block." : "item.") + entry.getKey().replace(":", "."));
                GeyserImpl.getInstance().getLogger().debug("Adding " + entry.getKey() + " as an item that needs to be translated.");
            }
            ItemMapping mapping = mappingBuilder.build();
            if (javaIdentifier.contains("boat")) {
                boats.add(bedrockId);
            } else if (javaIdentifier.contains("bucket") && !javaIdentifier.contains("milk")) {
                buckets.add(bedrockId);
            } else if (javaIdentifier.contains("_carpet") && !javaIdentifier.contains("moss")) {
                // This should be the numerical order Java sends as an integer value for llamas
                carpets.add(ItemData.builder().id(mapping.getBedrockId()).damage(mapping.getBedrockData()).count(1).blockRuntimeId(mapping.getBedrockBlockId()).build());
            } else if (javaIdentifier.startsWith("minecraft:music_disc_")) {
                // The Java record level event uses the item ID as the "key" to play the record
                Registries.RECORDS.register(itemIndex, SoundEvent.valueOf("RECORD_" + javaIdentifier.replace("minecraft:music_disc_", "").toUpperCase(Locale.ENGLISH)));
            } else if (javaIdentifier.endsWith("_spawn_egg")) {
                spawnEggs.add(mapping.getBedrockId());
            }
            mappings.put(itemIndex, mapping);
            identifierToMapping.put(javaIdentifier, mapping);
            itemNames.add(javaIdentifier);
            if (firstMappingsPass && mappingItem.getDyeColor() != -1) {
                dyeColors.put(itemIndex, mappingItem.getDyeColor());
            }
            itemIndex++;
        }
        itemNames.add("minecraft:furnace_minecart");
        int lodestoneCompassId = entries.get("minecraft:lodestone_compass").getId();
        if (lodestoneCompassId == 0) {
            throw new RuntimeException("Lodestone compass not found in item palette!");
        }
        // Add the lodestone compass since it doesn't exist on java but we need it for item conversion
        ItemMapping lodestoneEntry = ItemMapping.builder().javaIdentifier("minecraft:lodestone_compass").bedrockIdentifier("minecraft:lodestone_compass").javaId(itemIndex).bedrockId(lodestoneCompassId).bedrockData(0).bedrockBlockId(-1).stackSize(1).build();
        mappings.put(itemIndex, lodestoneEntry);
        identifierToMapping.put(lodestoneEntry.getJavaIdentifier(), lodestoneEntry);
        ComponentItemData furnaceMinecartData = null;
        if (usingFurnaceMinecart) {
            // Add the furnace minecart as a custom item
            int furnaceMinecartId = mappings.size() + 1;
            entries.put("geysermc:furnace_minecart", new StartGamePacket.ItemEntry("geysermc:furnace_minecart", (short) furnaceMinecartId, true));
            mappings.put(javaFurnaceMinecartId, ItemMapping.builder().javaIdentifier("minecraft:furnace_minecart").bedrockIdentifier("geysermc:furnace_minecart").javaId(javaFurnaceMinecartId).bedrockId(furnaceMinecartId).bedrockData(0).bedrockBlockId(-1).stackSize(1).build());
            creativeItems.add(ItemData.builder().netId(netId).id(furnaceMinecartId).count(1).build());
            NbtMapBuilder builder = NbtMap.builder();
            builder.putString("name", "geysermc:furnace_minecart").putInt("id", furnaceMinecartId);
            NbtMapBuilder itemProperties = NbtMap.builder();
            NbtMapBuilder componentBuilder = NbtMap.builder();
            // Conveniently, as of 1.16.200, the furnace minecart has a texture AND translation string already.
            itemProperties.putCompound("minecraft:icon", NbtMap.builder().putString("texture", "minecart_furnace").putString("frame", "0.000000").putInt("frame_version", 1).putString("legacy_id", "").build());
            componentBuilder.putCompound("minecraft:display_name", NbtMap.builder().putString("value", "item.minecartFurnace.name").build());
            // Indicate that the arm animation should play on rails
            List<NbtMap> useOnTag = Collections.singletonList(NbtMap.builder().putString("tags", "q.any_tag('rail')").build());
            componentBuilder.putCompound("minecraft:entity_placer", NbtMap.builder().putList("dispense_on", NbtType.COMPOUND, useOnTag).putString("entity", "minecraft:minecart").putList("use_on", NbtType.COMPOUND, useOnTag).build());
            // We always want to allow offhand usage when we can - matches Java Edition
            itemProperties.putBoolean("allow_off_hand", true);
            itemProperties.putBoolean("hand_equipped", false);
            itemProperties.putInt("max_stack_size", 1);
            itemProperties.putString("creative_group", "itemGroup.name.minecart");
            // 4 - "Items"
            itemProperties.putInt("creative_category", 4);
            componentBuilder.putCompound("item_properties", itemProperties.build());
            builder.putCompound("components", componentBuilder.build());
            furnaceMinecartData = new ComponentItemData("geysermc:furnace_minecart", builder.build());
        }
        ItemMappings itemMappings = ItemMappings.builder().items(mappings).creativeItems(creativeItems.toArray(new ItemData[0])).itemEntries(new ArrayList<>(entries.values())).itemNames(itemNames.toArray(new String[0])).storedItems(new StoredItemMappings(identifierToMapping)).javaOnlyItems(javaOnlyItems).bucketIds(buckets).boatIds(boats).spawnEggIds(spawnEggs).carpets(carpets).furnaceMinecartData(furnaceMinecartData).build();
        Registries.ITEMS.register(palette.getValue().protocolVersion(), itemMappings);
        firstMappingsPass = false;
    }
    ItemUtils.setDyeColors(dyeColors);
}

Example 30 with NbtMapBuilder

use of com.nukkitx.nbt.NbtMapBuilder in project Geyser by GeyserMC.

the class GeyserWorldManager method getLecternDataAt.

@Override
public NbtMap getLecternDataAt(GeyserSession session, int x, int y, int z, boolean isChunkLoad) {
    // Without direct server access, we can't get lectern information on-the-fly.
    // I should have set this up so it's only called when there is a book in the block state. - Camotoy
    NbtMapBuilder lecternTag = LecternInventoryTranslator.getBaseLecternTag(x, y, z, 1);
    lecternTag.putCompound("book", NbtMap.builder().putByte("Count", (byte) 1).putShort("Damage", (short) 0).putString("Name", "minecraft:written_book").putCompound("tag", NbtMap.builder().putString("photoname", "").putString("text", "").build()).build());
    // I'm surprisingly glad this exists - it forces Bedrock to stop reading immediately. Usually.
    lecternTag.putInt("page", -1);
    return lecternTag.build();
}