Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2025-02-14 19:32:17 +01:00
Code Issues Projects Releases Wiki Activity

chore: delete all old metadata classes for now, may return compatibility later

Browse Source
This commit is contained in:
mworzala 2024-04-11 12:49:57 -04:00 committed by Matt Worzala
parent 6300d7660c
commit 65e04d0a94
35 changed files with 48 additions and 1657 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/net/minestom/server/MinecraftServer.java
View File

@ -44,8 +44,8 @@ public final class MinecraftServer {
public static final ComponentLogger LOGGER = ComponentLogger.logger(MinecraftServer.class);
public static final String VERSION_NAME = "24w14a";
public static final int PROTOCOL_VERSION = 1073742008;
public static final String VERSION_NAME = "1.20.5-pre1";
public static final int PROTOCOL_VERSION = 1073742009;
// Threads
public static final String THREAD_NAME_BENCHMARK = "Ms-Benchmark";

6
src/main/java/net/minestom/server/item/component/ItemComponent.java → src/main/java/net/minestom/server/item/ItemComponent.java
View File

@ -1,9 +1,9 @@
package net.minestom.server.item.component;
package net.minestom.server.item;
import net.kyori.adventure.nbt.BinaryTag;
import net.kyori.adventure.text.Component;
import net.minestom.server.color.Color;
import net.minestom.server.item.ItemStack;
import net.minestom.server.item.component.*;
import net.minestom.server.network.NetworkBuffer;
import net.minestom.server.registry.StaticProtocolObject;
import net.minestom.server.utils.NamespaceID;
@ -13,7 +13,7 @@ import org.jetbrains.annotations.Nullable;
import java.util.List;
import static net.minestom.server.item.component.ItemComponentImpl.declare;
import static net.minestom.server.item.ItemComponentImpl.declare;
public sealed interface ItemComponent<T> extends StaticProtocolObject permits ItemComponentImpl {
// Note that even non-networked components are declared here as they still contribute to the component ID counter.

2
src/main/java/net/minestom/server/item/component/ItemComponentImpl.java → src/main/java/net/minestom/server/item/ItemComponentImpl.java
View File

@ -1,4 +1,4 @@
package net.minestom.server.item.component;
package net.minestom.server.item;
import net.kyori.adventure.nbt.BinaryTag;
import net.minestom.server.network.NetworkBuffer;

5
src/main/java/net/minestom/server/item/component/ItemComponentMap.java → src/main/java/net/minestom/server/item/ItemComponentMap.java
View File

@ -1,6 +1,5 @@
package net.minestom.server.item.component;
package net.minestom.server.item;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@ -19,8 +18,6 @@ public interface ItemComponentMap {
return value != null ? value : defaultValue;
}
@NotNull CompoundBinaryTag asCompound();
interface Builder {
<T> @NotNull Builder set(@NotNull ItemComponent<T> component, @NotNull T value);

21
src/main/java/net/minestom/server/item/component/ItemComponentPatch.java → src/main/java/net/minestom/server/item/ItemComponentPatch.java
View File

@ -1,28 +1,19 @@
package net.minestom.server.item.component;
package net.minestom.server.item;
import net.minestom.server.network.NetworkBuffer;
import net.minestom.server.utils.nbt.BinaryTagSerializer;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
public interface ItemComponentPatch extends ItemComponentMap {
static ItemComponentPatch EMPTY = new ItemComponentPatch() {
@Override public boolean has(@NotNull ItemComponent<?> component) {
return false;
}
@Override public <T> @Nullable T get(@NotNull ItemComponent<T> component) {
return null;
}
}; //todo
public sealed interface ItemComponentPatch extends ItemComponentMap permits ItemComponentPatchImpl {
@NotNull NetworkBuffer.Type<ItemComponentPatch> NETWORK_TYPE = null;
@NotNull BinaryTagSerializer<ItemComponentPatch> NBT_TYPE = null;
<T> @NotNull ItemComponentPatch with(@NotNull ItemComponent<T> component, T value);
@NotNull ItemComponentPatch without(@NotNull ItemComponent<?> component);
@NotNull Builder builder();
interface Builder extends ItemComponentMap {
@Contract(value = "_, _ -> this", pure = true)

4
src/main/java/net/minestom/server/item/ItemComponentPatchImpl.java Normal file
View File

@ -0,0 +1,4 @@
package net.minestom.server.item;
final class ItemComponentPatchImpl implements ItemComponentPatch {
}

21
src/main/java/net/minestom/server/item/ItemHideFlag.java
View File

@ -1,21 +0,0 @@
package net.minestom.server.item;
/**
* Represents a hide flag which can be applied to an {@link ItemStack} using {@link ItemMeta.Builder#hideFlag(int)}.
*/
@Deprecated
public enum ItemHideFlag {
HIDE_ENCHANTS,
HIDE_ATTRIBUTES,
HIDE_UNBREAKABLE,
HIDE_DESTROYS,
HIDE_PLACED_ON,
HIDE_POTION_EFFECTS,
HIDE_DYE;
private final int bitFieldPart = 1 << this.ordinal();
public int getBitFieldPart() {
return bitFieldPart;
}
}

166
src/main/java/net/minestom/server/item/ItemMeta.java
View File

@ -1,166 +0,0 @@
package net.minestom.server.item;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.kyori.adventure.text.Component;
import net.minestom.server.instance.block.Block;
import net.minestom.server.item.attribute.ItemAttribute;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagReadable;
import net.minestom.server.tag.Taggable;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.util.*;
import java.util.function.Consumer;
@Deprecated
public sealed interface ItemMeta extends TagReadable permits ItemMetaImpl {
@NotNull ItemComponentPatch components();
@Override
<T> @UnknownNullability T getTag(@NotNull Tag<T> tag);
@Contract(value = "_, -> new", pure = true)
@NotNull ItemMeta with(@NotNull Consumer<@NotNull Builder> builderConsumer);
@NotNull CompoundBinaryTag toNBT();
@NotNull String toSNBT();
@Contract(pure = true)
int getDamage();
@Contract(pure = true)
boolean isUnbreakable();
@Contract(pure = true)
int getHideFlag();
@Contract(pure = true)
@Nullable Component getDisplayName();
@Contract(pure = true)
@NotNull List<@NotNull Component> getLore();
@Contract(pure = true)
@NotNull Map<Enchantment, Short> getEnchantmentMap();
@Contract(pure = true)
@NotNull List<@NotNull ItemAttribute> getAttributes();
@Contract(pure = true)
int getCustomModelData();
@Contract(pure = true)
@NotNull Set<@NotNull String> getCanDestroy();
@Contract(pure = true)
boolean canDestroy(@NotNull Block block);
@Contract(pure = true)
@NotNull Set<@NotNull String> getCanPlaceOn();
@Contract(pure = true)
boolean canPlaceOn(@NotNull Block block);
@Deprecated
sealed interface Builder extends Taggable
permits ItemMetaImpl.Builder, ItemMetaView.Builder {
@NotNull ItemMeta build();
@NotNull ItemComponentPatch.Builder components();
default <T> @NotNull Builder set(@NotNull Tag<T> tag, @Nullable T value) {
setTag(tag, value);
return this;
}
@Contract("_ -> this")
default @NotNull Builder damage(int damage) {
return set(ItemTags.DAMAGE, damage);
}
@Contract("_ -> this")
default @NotNull Builder unbreakable(boolean unbreakable) {
return set(ItemTags.UNBREAKABLE, unbreakable);
}
@Contract("_ -> this")
default @NotNull Builder hideFlag(int hideFlag) {
return set(ItemTags.HIDE_FLAGS, hideFlag);
}
@Contract("_ -> this")
default @NotNull Builder hideFlag(@NotNull ItemHideFlag... hideFlags) {
int result = 0;
for (ItemHideFlag hideFlag : hideFlags) result |= hideFlag.getBitFieldPart();
return hideFlag(result);
}
@Contract("_ -> this")
default @NotNull Builder displayName(@Nullable Component displayName) {
return set(ItemTags.NAME, displayName);
}
@Contract("_ -> this")
default @NotNull Builder lore(@NotNull List<? extends Component> lore) {
return set(ItemTags.LORE, lore.isEmpty() ? null : List.class.cast(lore));
}
@Contract("_ -> this")
default @NotNull Builder lore(Component... lore) {
return lore(Arrays.asList(lore));
}
@Contract("_ -> this")
default @NotNull Builder enchantments(@NotNull Map<Enchantment, Short> enchantments) {
return set(ItemTags.ENCHANTMENTS, Map.copyOf(enchantments));
}
@Contract("_, _ -> this")
default @NotNull Builder enchantment(@NotNull Enchantment enchantment, short level) {
var enchantments = new HashMap<>(getTag(ItemTags.ENCHANTMENTS));
enchantments.put(enchantment, level);
return enchantments(enchantments);
}
@Contract("-> this")
default @NotNull Builder clearEnchantment() {
return enchantments(Map.of());
}
@Contract("_ -> this")
default @NotNull Builder attributes(@NotNull List<@NotNull ItemAttribute> attributes) {
return set(ItemTags.ATTRIBUTES, attributes.isEmpty() ? null : attributes);
}
@Contract("_ -> this")
default @NotNull Builder customModelData(int customModelData) {
return set(ItemTags.CUSTOM_MODEL_DATA, customModelData);
}
@Contract("_ -> this")
default @NotNull Builder canPlaceOn(@NotNull Set<@NotNull Block> blocks) {
return set(ItemTags.CAN_PLACE_ON, blocks.stream().map(StaticProtocolObject::name).toList());
}
@Contract("_ -> this")
default @NotNull Builder canPlaceOn(@NotNull Block... blocks) {
return canPlaceOn(Set.of(blocks));
}
@Contract("_ -> this")
default @NotNull Builder canDestroy(@NotNull Set<@NotNull Block> blocks) {
return set(ItemTags.CAN_DESTROY, blocks.stream().map(StaticProtocolObject::name).toList());
}
@Contract("_ -> this")
default @NotNull Builder canDestroy(@NotNull Block... blocks) {
return canDestroy(Set.of(blocks));
}
}
}

234
src/main/java/net/minestom/server/item/ItemMetaImpl.java
View File

@ -1,234 +0,0 @@
package net.minestom.server.item;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.kyori.adventure.nbt.TagStringIO;
import net.kyori.adventure.text.Component;
import net.minestom.server.instance.block.Block;
import net.minestom.server.item.attribute.ItemAttribute;
import net.minestom.server.item.component.*;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagHandler;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.io.IOException;
import java.util.*;
import java.util.function.Consumer;
@Deprecated
record ItemMetaImpl(ItemComponentPatch components) implements ItemMeta {
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Override
public @NotNull ItemMeta with(@NotNull Consumer<ItemMeta.@NotNull Builder> builderConsumer) {
Builder builder = new Builder(components.builder());
builderConsumer.accept(builder);
return builder.build();
}
@Override
public @NotNull CompoundBinaryTag toNBT() {
return components.asCompound();
}
@Override
public @NotNull String toSNBT() {
try {
return TagStringIO.get().asString(toNBT());
} catch (IOException e) {
throw new RuntimeException("Failed to convert to SNBT", e);
}
}
@Override
public int getDamage() {
return components.get(ItemComponent.DAMAGE, 0);
}
@Override
public boolean isUnbreakable() {
return components.has(ItemComponent.UNBREAKABLE);
}
@Override
public int getHideFlag() {
return 0;
}
@Override
public @Nullable Component getDisplayName() {
return components.get(ItemComponent.CUSTOM_NAME);
}
@Override
public @NotNull List<@NotNull Component> getLore() {
return components.get(ItemComponent.LORE, List.of());
}
@Override
public @NotNull Map<Enchantment, Short> getEnchantmentMap() {
EnchantmentList enchantments = components.get(ItemComponent.ENCHANTMENTS);
if (enchantments == null) return Map.of();
Map<Enchantment, Short> map = new HashMap<>(enchantments.enchantments().size());
for (Map.Entry<Enchantment, Integer> entry : enchantments.enchantments().entrySet()) {
map.put(entry.getKey(), entry.getValue().shortValue());
}
return map;
}
@Override
public @NotNull List<@NotNull ItemAttribute> getAttributes() {
//todo
}
@Override
public int getCustomModelData() {
return components.get(ItemComponent.CUSTOM_MODEL_DATA, 0);
}
@Override
public @NotNull Set<@NotNull String> getCanDestroy() {
//todo
}
@Override
public boolean canDestroy(@NotNull Block block) {
//todo
}
@Override
public @NotNull Set<@NotNull String> getCanPlaceOn() {
//todo
}
@Override
public boolean canPlaceOn(@NotNull Block block) {
//todo
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ItemMetaImpl itemMeta)) return false;
return components.equals(itemMeta.components);
}
@Override
public int hashCode() {
return Objects.hash(components);
}
@Override
public String toString() {
return toSNBT();
}
static final class Builder implements ItemMeta.Builder {
private final ItemComponentPatch.Builder components;
private TagHandler tagHandler = null;
Builder(ItemComponentPatch.Builder components) {
this.components = components;
}
@Override
public ItemMeta.@NotNull Builder damage(int damage) {
components.set(ItemComponent.DAMAGE, damage);
return this;
}
@Override
public ItemMeta.@NotNull Builder unbreakable(boolean unbreakable) {
if (unbreakable) {
components.set(ItemComponent.UNBREAKABLE, new Unbreakable(
components.get(ItemComponent.UNBREAKABLE, Unbreakable.DEFAULT).showInTooltip()));
} else {
components.remove(ItemComponent.UNBREAKABLE);
}
return this;
}
@Override
public ItemMeta.@NotNull Builder hideFlag(int hideFlag) {
return this; //todo
}
@Override
public ItemMeta.@NotNull Builder displayName(@Nullable Component displayName) {
if (displayName == null) {
components.remove(ItemComponent.CUSTOM_NAME);
} else {
components.set(ItemComponent.CUSTOM_NAME, displayName);
}
return this;
}
@Override
public ItemMeta.@NotNull Builder lore(@NotNull List<? extends Component> lore) {
components.set(ItemComponent.LORE, new ArrayList<>(lore));
return this;
}
@Override
public ItemMeta.@NotNull Builder enchantments(@NotNull Map<Enchantment, Short> enchantments) {
EnchantmentList existing = components.get(ItemComponent.ENCHANTMENTS, EnchantmentList.EMPTY);
Map<Enchantment, Integer> map = new HashMap<>(enchantments.size());
for (Map.Entry<Enchantment, Short> entry : enchantments.entrySet()) {
map.put(entry.getKey(), (int) entry.getValue());
}
components.set(ItemComponent.ENCHANTMENTS, new EnchantmentList(map, existing.showInTooltip()));
return this;
}
@Override
public ItemMeta.@NotNull Builder enchantment(@NotNull Enchantment enchantment, short level) {
components.set(ItemComponent.ENCHANTMENTS, components.get(ItemComponent.ENCHANTMENTS, EnchantmentList.EMPTY)
.with(enchantment, level));
return this;
}
@Override
public ItemMeta.@NotNull Builder attributes(@NotNull List<@NotNull ItemAttribute> attributes) {
return this; //todo
}
@Override
public ItemMeta.@NotNull Builder customModelData(int customModelData) {
components.set(ItemComponent.CUSTOM_MODEL_DATA, customModelData);
return this;
}
@Override
public ItemMeta.@NotNull Builder canPlaceOn(@NotNull Set<@NotNull Block> blocks) {
//todo
return this;
}
@Override
public ItemMeta.@NotNull Builder canDestroy(@NotNull Set<@NotNull Block> blocks) {
//todo
return this;
}
@Override
public @NotNull TagHandler tagHandler() {
this.tagHandler = TagHandler.fromCompound(components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).nbt());
return tagHandler;
}
@Override
public @NotNull ItemMetaImpl build() {
if (tagHandler != null) {
// If tagHandler was called then a tag was probably changed so update custom data.
components.set(ItemComponent.CUSTOM_DATA, new CustomData(tagHandler.asCompound()));
}
return new ItemMetaImpl(components.build());
}
}
}

15
src/main/java/net/minestom/server/item/ItemMetaView.java
View File

@ -1,15 +0,0 @@
package net.minestom.server.item;
import net.minestom.server.tag.TagReadable;
import org.jetbrains.annotations.NotNull;
@Deprecated
public interface ItemMetaView<T extends ItemMetaView.Builder> extends TagReadable {
@Deprecated
non-sealed interface Builder extends ItemMeta.Builder {
default @NotNull ItemMeta build() {
return new ItemMetaImpl(components().build());
}
}
}

37
src/main/java/net/minestom/server/item/ItemMetaViewImpl.java
View File

@ -1,37 +0,0 @@
package net.minestom.server.item;
import net.minestom.server.item.component.ItemComponentPatch;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
@Deprecated
final class ItemMetaViewImpl {
static <V extends ItemMetaView.Builder, T extends ItemMetaView<V>> Class<V> viewType(Class<T> metaClass) {
final Type type = metaClass.getGenericInterfaces()[0];
return (Class<V>) ((ParameterizedType) type).getActualTypeArguments()[0];
}
static <T extends ItemMetaView<?>> T construct(Class<T> metaClass, ItemComponentPatch components) {
try {
final Constructor<T> cons = metaClass.getDeclaredConstructor(ItemComponentPatch.class);
return cons.newInstance(components);
} catch (NoSuchMethodException | InvocationTargetException | InstantiationException |
IllegalAccessException e) {
throw new RuntimeException(e);
}
}
static <V extends ItemMetaView.Builder, T extends ItemMetaView<V>> V constructBuilder(Class<T> metaClass, ItemComponentPatch.Builder components) {
final Class<V> clazz = viewType(metaClass);
try {
final Constructor<V> cons = clazz.getDeclaredConstructor(ItemComponentPatch.Builder.class);
return cons.newInstance(components);
} catch (NoSuchMethodException | InvocationTargetException | InstantiationException |
IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}

88
src/main/java/net/minestom/server/item/ItemSerializers.java
View File

@ -1,88 +0,0 @@
package net.minestom.server.item;
import net.minestom.server.entity.attribute.Attribute;
import net.minestom.server.entity.attribute.AttributeOperation;
import net.minestom.server.item.attribute.AttributeSlot;
import net.minestom.server.item.attribute.ItemAttribute;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagReadable;
import net.minestom.server.tag.TagSerializer;
import net.minestom.server.tag.TagWritable;
import org.jetbrains.annotations.ApiStatus;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Locale;
import java.util.UUID;
@Deprecated
@ApiStatus.Internal
public final class ItemSerializers {
public static final TagSerializer<EnchantmentEntry> ENCHANTMENT_SERIALIZER = new TagSerializer<>() {
static final Tag<Short> LEVEL = Tag.Short("lvl");
static final Tag<String> ID = Tag.String("id");
@Override
public @Nullable EnchantmentEntry read(@NotNull TagReadable reader) {
final String id = reader.getTag(ID);
final Short level = reader.getTag(LEVEL);
if (id == null || level == null) return null;
final Enchantment enchantment = Enchantment.fromNamespaceId(id);
return new EnchantmentEntry(enchantment, level);
}
@Override
public void write(@NotNull TagWritable writer, @NotNull EnchantmentEntry value) {
writer.setTag(ID, value.enchantment.name());
writer.setTag(LEVEL, value.level);
}
};
public record EnchantmentEntry(Enchantment enchantment, short level) {
}
static final TagSerializer<ItemAttribute> ATTRIBUTE_SERIALIZER = new TagSerializer<>() {
static final Tag<UUID> ID = Tag.UUID("UUID");
static final Tag<Double> AMOUNT = Tag.Double("Amount");
static final Tag<String> SLOT = Tag.String("Slot").defaultValue("mainhand");
static final Tag<String> ATTRIBUTE_NAME = Tag.String("AttributeName");
static final Tag<Integer> OPERATION = Tag.Integer("Operation");
static final Tag<String> NAME = Tag.String("Name");
@Override
public @Nullable ItemAttribute read(@NotNull TagReadable reader) {
final UUID uuid = reader.getTag(ID);
final double amount = reader.getTag(AMOUNT);
final String slot = reader.getTag(SLOT);
final String attributeName = reader.getTag(ATTRIBUTE_NAME);
final int operation = reader.getTag(OPERATION);
final String name = reader.getTag(NAME);
final Attribute attribute = Attribute.fromNamespaceId(attributeName.toLowerCase(Locale.ROOT));
// Wrong attribute name, stop here
if (attribute == null) return null;
final AttributeOperation attributeOperation = AttributeOperation.fromId(operation);
// Wrong attribute operation, stop here
if (attributeOperation == null) return null;
// Find slot, default to the main hand if the nbt tag is invalid
AttributeSlot attributeSlot;
try {
attributeSlot = AttributeSlot.valueOf(slot.toUpperCase());
} catch (IllegalArgumentException e) {
attributeSlot = AttributeSlot.MAINHAND;
}
return new ItemAttribute(uuid, name, attribute, attributeOperation, amount, attributeSlot);
}
@Override
public void write(@NotNull TagWritable writer, @NotNull ItemAttribute value) {
writer.setTag(ID, value.uuid());
writer.setTag(AMOUNT, value.amount());
writer.setTag(SLOT, value.slot().name().toLowerCase(Locale.ROOT));
writer.setTag(ATTRIBUTE_NAME, value.attribute().name());
writer.setTag(OPERATION, value.operation().getId());
writer.setTag(NAME, value.name());
}
};
}

143
src/main/java/net/minestom/server/item/ItemStack.java
View File

@ -1,23 +1,20 @@
package net.minestom.server.item;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.kyori.adventure.nbt.api.BinaryTagHolder;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.event.HoverEvent;
import net.kyori.adventure.text.event.HoverEventSource;
import net.minestom.server.adventure.MinestomAdventure;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.inventory.ContainerInventory;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagHandler;
import net.minestom.server.tag.TagReadable;
import net.minestom.server.tag.TagWritable;
import org.jetbrains.annotations.*;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.io.IOException;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.IntUnaryOperator;
import java.util.function.UnaryOperator;
@ -30,6 +27,7 @@ import java.util.function.UnaryOperator;
*/
public sealed interface ItemStack extends TagReadable, ItemComponentMap, HoverEventSource<HoverEvent.ShowItem>
permits ItemStackImpl {
/**
* Constant AIR item. Should be used instead of 'null'.
*/
@ -50,19 +48,6 @@ public sealed interface ItemStack extends TagReadable, ItemComponentMap, HoverEv
return of(material, 1);
}
@Deprecated(forRemoval = true)
@Contract(value = "_, _, _ -> new", pure = true)
static @NotNull ItemStack fromNBT(@NotNull Material material, @Nullable CompoundBinaryTag nbtCompound, int amount) {
if (nbtCompound == null) return of(material, amount);
return builder(material).amount(amount).meta(nbtCompound).build();
}
@Deprecated(forRemoval = true)
@Contract(value = "_, _ -> new", pure = true)
static @NotNull ItemStack fromNBT(@NotNull Material material, @Nullable CompoundBinaryTag nbtCompound) {
return fromNBT(material, nbtCompound, 1);
}
/**
* Converts this item to an NBT tag containing the id (material), count (amount), and tag (meta).
*
@ -135,78 +120,16 @@ public sealed interface ItemStack extends TagReadable, ItemComponentMap, HoverEv
*/
@NotNull CompoundBinaryTag toItemNBT();
// BEGIN DEPRECATED PRE-COMPONENT METHODS
@Deprecated(forRemoval = true)
@Contract(pure = true)
@NotNull ItemMeta meta();
@Deprecated(forRemoval = true)
@Contract(pure = true)
@ApiStatus.Experimental
<T extends ItemMetaView<?>> @NotNull T meta(@NotNull Class<T> metaClass);
@Deprecated(forRemoval = true)
@Contract(value = "_, _ -> new", pure = true)
@ApiStatus.Experimental
<V extends ItemMetaView.Builder, T extends ItemMetaView<V>> @NotNull ItemStack withMeta(@NotNull Class<T> metaType,
@NotNull Consumer<V> consumer);
@Deprecated(forRemoval = true)
@Contract(value = "_ -> new", pure = true)
@NotNull ItemStack withMeta(@NotNull Consumer<ItemMeta.@NotNull Builder> consumer);
@Deprecated(forRemoval = true)
@Contract(pure = true)
default @Nullable Component getDisplayName() {
return meta().getDisplayName();
}
@Deprecated(forRemoval = true)
@Contract(pure = true)
default @NotNull List<@NotNull Component> getLore() {
return meta().getLore();
}
@Deprecated(forRemoval = true)
@Contract(value = "_ -> new", pure = true)
@NotNull ItemStack withMeta(@NotNull ItemMeta meta);
@Deprecated(forRemoval = true)
@Contract(value = "_, -> new", pure = true)
default @NotNull ItemStack withDisplayName(@Nullable Component displayName) {
return withMeta(builder -> builder.displayName(displayName));
}
@Deprecated(forRemoval = true)
@Contract(value = "_, -> new", pure = true)
default @NotNull ItemStack withDisplayName(@NotNull UnaryOperator<@Nullable Component> componentUnaryOperator) {
return withDisplayName(componentUnaryOperator.apply(getDisplayName()));
}
@Deprecated(forRemoval = true)
@Contract(value = "_, -> new", pure = true)
default @NotNull ItemStack withLore(@NotNull List<? extends Component> lore) {
return withMeta(builder -> builder.lore(lore));
}
@Deprecated(forRemoval = true)
@Contract(value = "_, -> new", pure = true)
default @NotNull ItemStack withLore(@NotNull UnaryOperator<@NotNull List<@NotNull Component>> loreUnaryOperator) {
return withLore(loreUnaryOperator.apply(getLore()));
}
// END DEPRECATED PRE-COMPONENT METHODS
@Override
default @NotNull HoverEvent<HoverEvent.ShowItem> asHoverEvent(@NotNull UnaryOperator<HoverEvent.ShowItem> op) {
try {
final BinaryTagHolder tagHolder = BinaryTagHolder.encode(meta().toNBT(), MinestomAdventure.NBT_CODEC);
return HoverEvent.showItem(op.apply(HoverEvent.ShowItem.showItem(material(), amount(), tagHolder)));
} catch (IOException e) {
//todo(matt): revisit,
throw new RuntimeException(e);
}
//todo
// try {
// final BinaryTagHolder tagHolder = BinaryTagHolder.encode(meta().toNBT(), MinestomAdventure.NBT_CODEC);
// return HoverEvent.showItem(op.apply(HoverEvent.ShowItem.showItem(material(), amount(), tagHolder)));
// } catch (IOException e) {
// //todo(matt): revisit,
// throw new RuntimeException(e);
// }
}
sealed interface Builder extends TagWritable
@ -230,45 +153,5 @@ public sealed interface ItemStack extends TagReadable, ItemComponentMap, HoverEv
@Contract(value = "-> new", pure = true)
@NotNull ItemStack build();
// BEGIN DEPRECATED PRE-COMPONENT METHODS
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
@NotNull Builder meta(@NotNull TagHandler tagHandler);
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
@NotNull Builder meta(@NotNull CompoundBinaryTag compound);
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
@NotNull Builder meta(@NotNull ItemMeta itemMeta);
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
@NotNull Builder meta(@NotNull Consumer<ItemMeta.@NotNull Builder> consumer);
@Deprecated(forRemoval = true)
@Contract(value = "_, _ -> this")
<V extends ItemMetaView.Builder, T extends ItemMetaView<V>> @NotNull Builder meta(@NotNull Class<T> metaType,
@NotNull Consumer<@NotNull V> itemMetaConsumer);
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
default @NotNull Builder displayName(@Nullable Component displayName) {
return meta(builder -> builder.displayName(displayName));
}
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
default @NotNull Builder lore(@NotNull List<? extends Component> lore) {
return meta(builder -> builder.lore(lore));
}
@Deprecated(forRemoval = true)
@Contract(value = "_ -> this")
default @NotNull Builder lore(Component... lore) {
return meta(builder -> builder.lore(lore));
}
}
}

70
src/main/java/net/minestom/server/item/ItemStackImpl.java
View File

@ -2,10 +2,7 @@ package net.minestom.server.item;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagHandler;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@ -20,7 +17,7 @@ record ItemStackImpl(Material material, int amount, ItemComponentPatch component
}
static ItemStack create(Material material, int amount) {
return create(material, amount, ItemComponentPatch.EMPTY);
return create(material, amount, ItemComponentPatch.builder(material).build());
}
@Override
@ -85,34 +82,7 @@ record ItemStackImpl(Material material, int amount, ItemComponentPatch component
@Contract(value = "-> new", pure = true)
private @NotNull ItemStack.Builder builder() {
return new Builder(material, amount, new ItemMetaImpl.Builder(meta.tagHandler().copy()));
}
// BEGIN DEPRECATED PRE-COMPONENT METHODS
@Override public @NotNull ItemMeta meta() {
return new ItemMetaImpl(components);
}
@Override
public <T extends ItemMetaView<?>> @NotNull T meta(@NotNull Class<T> metaClass) {
return ItemMetaViewImpl.construct(metaClass, meta);
}
@Override
public @NotNull <V extends ItemMetaView.Builder, T extends ItemMetaView<V>> ItemStack withMeta(@NotNull Class<T> metaType,
@NotNull Consumer<V> consumer) {
return builder().meta(metaType, consumer).build();
}
@Override
public @NotNull ItemStack withMeta(@NotNull Consumer<ItemMeta.@NotNull Builder> consumer) {
return builder().meta(consumer).build();
}
@Override
public @NotNull ItemStack withMeta(@NotNull ItemMeta meta) {
return new ItemStackImpl(material, amount, (ItemMetaImpl) meta);
return new Builder(material, amount, components.builder());
}
static final class Builder implements ItemStack.Builder {
@ -126,6 +96,12 @@ record ItemStackImpl(Material material, int amount, ItemComponentPatch component
this.components = components;
}
Builder(Material material, int amount) {
this.material = material;
this.amount = amount;
this.components = ItemComponentPatch.builder(material);
}
@Override
public ItemStack.@NotNull Builder amount(int amount) {
this.amount = amount;
@ -154,35 +130,5 @@ record ItemStackImpl(Material material, int amount, ItemComponentPatch component
return ItemStackImpl.create(material, amount, components.build());
}
@Override
public ItemStack.@NotNull Builder meta(@NotNull TagHandler tagHandler) {
return meta(tagHandler.asCompound());
}
@Override
public ItemStack.@NotNull Builder meta(@NotNull CompoundBinaryTag compound) {
components.set(ItemComponent.CUSTOM_DATA, new CustomData(compound));
return this;
}
@Override
public ItemStack.@NotNull Builder meta(@NotNull ItemMeta itemMeta) {
this.components = itemMeta.components().builder();
return this;
}
@Override
public ItemStack.@NotNull Builder meta(@NotNull Consumer<ItemMeta.Builder> consumer) {
consumer.accept(new ItemMetaImpl.Builder(components));
return this;
}
@Override
public <V extends ItemMetaView.Builder, T extends ItemMetaView<V>> ItemStack.@NotNull Builder meta(@NotNull Class<T> metaType,
@NotNull Consumer<@NotNull V> itemMetaConsumer) {
V view = ItemMetaViewImpl.constructBuilder(metaType, components);
itemMetaConsumer.accept(view);
return this;
}
}
}

2
src/main/java/net/minestom/server/item/Material.java
View File

@ -1,8 +1,6 @@
package net.minestom.server.item;
import net.minestom.server.instance.block.Block;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.registry.Registry;
import net.minestom.server.registry.StaticProtocolObject;
import net.minestom.server.utils.NamespaceID;

4
src/main/java/net/minestom/server/item/component/CustomData.java
View File

@ -11,7 +11,7 @@ import org.jetbrains.annotations.UnknownNullability;
public record CustomData(@NotNull CompoundBinaryTag nbt) implements TagReadable {
public static final CustomData EMPTY = new CustomData(CompoundBinaryTag.empty());
static final NetworkBuffer.Type<CustomData> NETWORK_TYPE = new NetworkBuffer.Type<>() {
public static final NetworkBuffer.Type<CustomData> NETWORK_TYPE = new NetworkBuffer.Type<>() {
@Override
public void write(@NotNull NetworkBuffer buffer, CustomData value) {
buffer.write(NetworkBuffer.NBT, value.nbt);
@ -23,7 +23,7 @@ public record CustomData(@NotNull CompoundBinaryTag nbt) implements TagReadable
}
};
static final BinaryTagSerializer<CustomData> NBT_TYPE = BinaryTagSerializer.COMPOUND.map(CustomData::new, CustomData::nbt);
public static final BinaryTagSerializer<CustomData> NBT_TYPE = BinaryTagSerializer.COMPOUND.map(CustomData::new, CustomData::nbt);
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {

4
src/main/java/net/minestom/server/item/component/EnchantmentList.java
View File

@ -14,7 +14,7 @@ import java.util.Map;
public record EnchantmentList(@NotNull Map<Enchantment, Integer> enchantments, boolean showInTooltip) {
public static final EnchantmentList EMPTY = new EnchantmentList(Map.of(), true);
static NetworkBuffer.Type<EnchantmentList> NETWORK_TYPE = new NetworkBuffer.Type<>() {
public static NetworkBuffer.Type<EnchantmentList> NETWORK_TYPE = new NetworkBuffer.Type<>() {
@Override
public void write(@NotNull NetworkBuffer buffer, @NotNull EnchantmentList value) {
buffer.write(NetworkBuffer.VAR_INT, value.enchantments.size());
@ -40,7 +40,7 @@ public record EnchantmentList(@NotNull Map<Enchantment, Integer> enchantments, b
}
};
static BinaryTagSerializer<EnchantmentList> NBT_TYPE = BinaryTagSerializer.COMPOUND.map(
public static BinaryTagSerializer<EnchantmentList> NBT_TYPE = BinaryTagSerializer.COMPOUND.map(
tag -> {
// We have two variants of the enchantment list, one with {levels: {...}, show_in_tooltip: boolean} and one with {...}.
CompoundBinaryTag levels = tag.keySet().contains("levels") ? tag.getCompound("levels") : tag;

4
src/main/java/net/minestom/server/item/component/ItemRarity.java
View File

@ -17,7 +17,7 @@ public enum ItemRarity {
private static final ItemRarity[] VALUES = values();
static final NetworkBuffer.Type<ItemRarity> NETWORK_TYPE = new NetworkBuffer.Type<ItemRarity>() {
public static final NetworkBuffer.Type<ItemRarity> NETWORK_TYPE = new NetworkBuffer.Type<ItemRarity>() {
@Override
public void write(@NotNull NetworkBuffer buffer, ItemRarity value) {
buffer.writeEnum(ItemRarity.class, value);
@ -29,7 +29,7 @@ public enum ItemRarity {
}
};
static final BinaryTagSerializer<ItemRarity> NBT_TYPE = new BinaryTagSerializer<>() {
public static final BinaryTagSerializer<ItemRarity> NBT_TYPE = new BinaryTagSerializer<>() {
@Override
public @NotNull BinaryTag write(@NotNull ItemRarity value) {
return IntBinaryTag.intBinaryTag(value.ordinal());

2
src/main/java/net/minestom/server/item/component/MapDecorations.java
View File

@ -13,7 +13,7 @@ public record MapDecorations(@NotNull Map<String, Entry> decorations) {
public record Entry(@NotNull String type, double x, double z, float rotation) {
}
static final BinaryTagSerializer<MapDecorations> NBT_TYPE = BinaryTagSerializer.COMPOUND.map(
public static final BinaryTagSerializer<MapDecorations> NBT_TYPE = BinaryTagSerializer.COMPOUND.map(
tag -> {
Map<String, Entry> map = new HashMap<>(tag.size());
for (Map.Entry<String, ? extends BinaryTag> entry : tag) {

70
src/main/java/net/minestom/server/item/firework/FireworkEffect.java
View File

@ -1,70 +0,0 @@
package net.minestom.server.item.firework;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.minestom.server.color.Color;
import net.minestom.server.item.component.FireworkExplosion;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.List;
@Deprecated
public record FireworkEffect(boolean flicker, boolean trail,
@NotNull FireworkEffectType type,
@NotNull List<Color> colors,
@NotNull List<Color> fadeColors) {
public FireworkEffect {
colors = List.copyOf(colors);
fadeColors = List.copyOf(fadeColors);
}
public FireworkEffect(@NotNull FireworkExplosion explosion) {
this(explosion.hasTwinkle(), explosion.hasTrail(),
FireworkEffectType.fromExplosionShape(explosion.shape()),
explosion.colors(), explosion.fadeColors());
}
/**
* Retrieves a firework effect from the given {@code compound}.
*
* @param compound The NBT connection, which should be a fireworks effect.
* @return A new created firework effect.
*/
public static @NotNull FireworkEffect fromCompound(@NotNull CompoundBinaryTag compound) {
List<Color> primaryColor = new ArrayList<>();
List<Color> secondaryColor = new ArrayList<>();
for (int rgb : compound.getIntArray("Colors"))
primaryColor.add(new Color(rgb));
for (int rgb : compound.getIntArray("FadeColors"))
secondaryColor.add(new Color(rgb));
boolean flicker = compound.getBoolean("Flicker");
boolean trail = compound.getBoolean("Trail");
FireworkEffectType type = FireworkEffectType.byId(compound.getByte("Type"));
return new FireworkEffect(flicker, trail, type, primaryColor, secondaryColor);
}
/**
* Retrieves the {@link FireworkEffect} as a {@link CompoundBinaryTag}.
*
* @return The firework effect as a nbt compound.
*/
public @NotNull CompoundBinaryTag asCompound() {
return CompoundBinaryTag.builder()
.putBoolean("Flicker", flicker)
.putBoolean("Trail", trail)
.putByte("Type", (byte) type.getType())
.putIntArray("Colors", colors.stream().mapToInt(Color::asRGB).toArray())
.putIntArray("FadeColors", fadeColors.stream().mapToInt(Color::asRGB).toArray())
.build();
}
public @NotNull FireworkExplosion toExplosion() {
return new FireworkExplosion(
type.toExplosionShape(),
colors, fadeColors,
trail, flicker);
}
}

72
src/main/java/net/minestom/server/item/firework/FireworkEffectType.java
View File

@ -1,72 +0,0 @@
package net.minestom.server.item.firework;
import it.unimi.dsi.fastutil.bytes.Byte2ObjectMap;
import it.unimi.dsi.fastutil.bytes.Byte2ObjectOpenHashMap;
import net.minestom.server.item.component.FireworkExplosion;
import org.jetbrains.annotations.NotNull;
/**
* An enumeration that representing all available firework types.
*/
@Deprecated
public enum FireworkEffectType {
SMALL_BALL((byte) 0),
LARGE_BALL((byte) 1),
STAR_SHAPED((byte) 2),
CREEPER_SHAPED((byte) 3),
BURST((byte) 4);
private static final Byte2ObjectMap<FireworkEffectType> BY_ID = new Byte2ObjectOpenHashMap<>();
static {
for (FireworkEffectType value : values()) {
BY_ID.put(value.type, value);
}
}
private final byte type;
FireworkEffectType(byte type) {
this.type = type;
}
/**
* Retrieves a {@link FireworkEffectType} by the given {@code id}.
*
* @param id The identifier of the firework effect type.
* @return A firework effect type or {@code null}.
*/
public static FireworkEffectType byId(byte id) {
return BY_ID.get(id);
}
public static FireworkEffectType fromExplosionShape(@NotNull FireworkExplosion.Shape shape) {
return switch (shape) {
case SMALL_BALL -> SMALL_BALL;
case LARGE_BALL -> LARGE_BALL;
case STAR -> STAR_SHAPED;
case CREEPER -> CREEPER_SHAPED;
case BURST -> BURST;
};
}
/**
* Retrieves the type of the firework effect.
*
* @return The type of the firework effect as a byte.
*/
public byte getType() {
return type;
}
public FireworkExplosion.Shape toExplosionShape() {
return switch (this) {
case SMALL_BALL -> FireworkExplosion.Shape.SMALL_BALL;
case LARGE_BALL -> FireworkExplosion.Shape.LARGE_BALL;
case STAR_SHAPED -> FireworkExplosion.Shape.STAR;
case CREEPER_SHAPED -> FireworkExplosion.Shape.CREEPER;
case BURST -> FireworkExplosion.Shape.BURST;
};
}
}

52
src/main/java/net/minestom/server/item/metadata/BundleMeta.java
View File

@ -1,52 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.ItemStack;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.UnknownNullability;
import java.util.ArrayList;
import java.util.List;
@Deprecated
public record BundleMeta(ItemComponentPatch components) implements ItemMetaView<BundleMeta.Builder> {
public @NotNull List<ItemStack> getItems() {
return components.get(ItemComponent.BUNDLE_CONTENTS, List.of());
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
public Builder items(@NotNull List<ItemStack> items) {
if (items.isEmpty()) {
components.remove(ItemComponent.BUNDLE_CONTENTS);
} else {
components.set(ItemComponent.BUNDLE_CONTENTS, items);
}
return this;
}
public Builder addItem(@NotNull ItemStack item) {
var newList = new ArrayList<>(components.get(ItemComponent.BUNDLE_CONTENTS, List.of()));
newList.add(item);
return items(newList);
}
public Builder removeItem(@NotNull ItemStack item) {
var newList = new ArrayList<>(components.get(ItemComponent.BUNDLE_CONTENTS, List.of()));
newList.remove(item);
return items(newList);
}
}
}

61
src/main/java/net/minestom/server/item/metadata/CompassMeta.java
View File

@ -1,61 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.coordinate.Point;
import net.minestom.server.coordinate.Vec;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.item.component.LodestoneTracker;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
@Deprecated
public record CompassMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<CompassMeta.Builder> {
public boolean isLodestoneTracked() {
LodestoneTracker tracker = components.get(ItemComponent.LODESTONE_TRACKER);
return tracker != null && tracker.tracked();
}
public @Nullable String getLodestoneDimension() {
LodestoneTracker tracker = components.get(ItemComponent.LODESTONE_TRACKER);
return tracker == null ? null : tracker.dimension();
}
public @Nullable Point getLodestonePosition() {
LodestoneTracker tracker = components.get(ItemComponent.LODESTONE_TRACKER);
return tracker == null ? null : tracker.blockPosition();
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(@NotNull ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
// The empty state isnt really valid because the dimension is empty (invalid), but these functions need to set each so its simpler.
private static final LodestoneTracker EMPTY = new LodestoneTracker("", Vec.ZERO, false);
public Builder lodestoneTracked(boolean lodestoneTracked) {
LodestoneTracker tracker = components.get(ItemComponent.LODESTONE_TRACKER, EMPTY);
components.set(ItemComponent.LODESTONE_TRACKER, tracker.withTracked(lodestoneTracked));
return this;
}
public Builder lodestoneDimension(@Nullable String lodestoneDimension) {
LodestoneTracker tracker = components.get(ItemComponent.LODESTONE_TRACKER, EMPTY);
components.set(ItemComponent.LODESTONE_TRACKER, tracker.withDimension(lodestoneDimension));
return this;
}
public Builder lodestonePosition(@Nullable Point lodestonePosition) {
LodestoneTracker tracker = components.get(ItemComponent.LODESTONE_TRACKER, EMPTY);
components.set(ItemComponent.LODESTONE_TRACKER, tracker.withBlockPosition(lodestonePosition));
return this;
}
}
}

54
src/main/java/net/minestom/server/item/metadata/CrossbowMeta.java
View File

@ -1,54 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.ItemStack;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.UnknownNullability;
import java.util.List;
@Deprecated
public record CrossbowMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<CrossbowMeta.Builder> {
public @NotNull List<ItemStack> getProjectiles() {
return components.get(ItemComponent.CHARGED_PROJECTILES, List.of());
}
public boolean isCharged() {
return components.has(ItemComponent.CHARGED_PROJECTILES);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(@NotNull ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
public Builder projectile(@NotNull ItemStack projectile) {
components.set(ItemComponent.CHARGED_PROJECTILES, List.of(projectile));
return this;
}
public Builder projectiles(@NotNull ItemStack projectile1, @NotNull ItemStack projectile2, @NotNull ItemStack projectile3) {
components.set(ItemComponent.CHARGED_PROJECTILES, List.of(projectile1, projectile2, projectile3));
return this;
}
public Builder charged(boolean charged) {
if (charged) {
// Only reset to empty list if we dont have any projectiles yet, as to not overwrite the call to projectiles()
if (!components.has(ItemComponent.CHARGED_PROJECTILES))
components.set(ItemComponent.CHARGED_PROJECTILES, List.of());
} else {
components.remove(ItemComponent.CHARGED_PROJECTILES);
}
return this;
}
}
}

50
src/main/java/net/minestom/server/item/metadata/EnchantedBookMeta.java
View File

@ -1,50 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.item.Enchantment;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.EnchantmentList;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.UnknownNullability;
import java.util.HashMap;
import java.util.Map;
@Deprecated
public record EnchantedBookMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<EnchantedBookMeta.Builder> {
public @NotNull Map<Enchantment, Short> getStoredEnchantmentMap() {
EnchantmentList value = components.get(ItemComponent.STORED_ENCHANTMENTS, EnchantmentList.EMPTY);
Map<Enchantment, Short> map = new HashMap<>();
for (var entry : value.enchantments().entrySet())
map.put(entry.getKey(), entry.getValue().shortValue());
return map;
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(@NotNull ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
public @NotNull Builder enchantments(@NotNull Map<Enchantment, Short> enchantments) {
Map<Enchantment, Integer> map = new HashMap<>();
enchantments.forEach((enchantment, level) -> map.put(enchantment, (int) level));
// Fetch existing to preserve the showInTooltip value.
EnchantmentList existing = components.get(ItemComponent.STORED_ENCHANTMENTS, EnchantmentList.EMPTY);
components.set(ItemComponent.STORED_ENCHANTMENTS, new EnchantmentList(map, existing.showInTooltip()));
return this;
}
public @NotNull Builder enchantment(@NotNull Enchantment enchantment, short level) {
EnchantmentList value = components.get(ItemComponent.STORED_ENCHANTMENTS, EnchantmentList.EMPTY);
components.set(ItemComponent.STORED_ENCHANTMENTS, value.with(enchantment, level));
return this;
}
}
}

35
src/main/java/net/minestom/server/item/metadata/FireworkEffectMeta.java
View File

@ -1,35 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.*;
import net.minestom.server.item.firework.FireworkEffect;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
@Deprecated
public record FireworkEffectMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<FireworkEffectMeta.Builder> {
public @Nullable FireworkEffect getFireworkEffect() {
FireworkExplosion explosion = components.get(ItemComponent.FIREWORK_EXPLOSION);
return explosion == null ? null : new FireworkEffect(explosion);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(@NotNull ItemComponentMap.Builder components) implements ItemMetaView.Builder {
public Builder effect(@Nullable FireworkEffect fireworkEffect) {
if (fireworkEffect == null) {
components.remove(ItemComponent.FIREWORK_EXPLOSION);
} else {
components.set(ItemComponent.FIREWORK_EXPLOSION, fireworkEffect.toExplosion());
}
return this;
}
}
}

49
src/main/java/net/minestom/server/item/metadata/FireworkMeta.java
View File

@ -1,49 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.FireworkList;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.item.firework.FireworkEffect;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.util.List;
@Deprecated
public record FireworkMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<FireworkMeta.Builder> {
public @NotNull List<FireworkEffect> getEffects() {
FireworkList value = components.get(ItemComponent.FIREWORKS);
return value == null ? List.of() : value.explosions().stream().map(FireworkEffect::new).toList();
}
public @Nullable Byte getFlightDuration() {
FireworkList value = components.get(ItemComponent.FIREWORKS);
return value == null ? null : value.flightDuration();
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(@NotNull ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
public Builder effects(List<FireworkEffect> effects) {
FireworkList value = components.get(ItemComponent.FIREWORKS, FireworkList.EMPTY);
components.set(ItemComponent.FIREWORKS, value.withExplosions(effects.stream().map(FireworkEffect::toExplosion).toList()));
return this;
}
public Builder flightDuration(byte flightDuration) {
FireworkList value = components.get(ItemComponent.FIREWORKS, FireworkList.EMPTY);
components.set(ItemComponent.FIREWORKS, value.withFlightDuration(flightDuration));
return this;
}
}
}

40
src/main/java/net/minestom/server/item/metadata/LeatherArmorMeta.java
View File

@ -1,40 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.color.Color;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.DyedItemColor;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
@Deprecated
public record LeatherArmorMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<LeatherArmorMeta.Builder> {
public @Nullable Color getColor() {
DyedItemColor value = components.get(ItemComponent.DYED_COLOR);
return value == null ? null : value.color();
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
@Deprecated
public record Builder(@NotNull ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
public Builder color(@Nullable Color color) {
if (color == null) {
components.remove(ItemComponent.DYED_COLOR);
} else {
DyedItemColor value = components.get(ItemComponent.DYED_COLOR, DyedItemColor.LEATHER);
components.set(ItemComponent.DYED_COLOR, value.withColor(color));
}
return this;
}
}
}

91
src/main/java/net/minestom/server/item/metadata/MapMeta.java
View File

@ -1,91 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.color.Color;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagReadable;
import net.minestom.server.tag.TagSerializer;
import net.minestom.server.tag.TagWritable;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.util.List;
public record MapMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<MapMeta.Builder> {
private static final Tag<Integer> MAP_ID = Tag.Integer("map").defaultValue(0);
private static final Tag<Integer> MAP_SCALE_DIRECTION = Tag.Integer("map_scale_direction").defaultValue(0);
private static final Tag<List<Decoration>> DECORATIONS = Tag.Structure("Decorations", new TagSerializer<Decoration>() {
@Override
public @Nullable Decoration read(@NotNull TagReadable reader) {
final String id = reader.getTag(Tag.String("id"));
final Byte type = reader.getTag(Tag.Byte("type"));
final Byte x = reader.getTag(Tag.Byte("x"));
final Byte z = reader.getTag(Tag.Byte("z"));
final Double rot = reader.getTag(Tag.Double("rot"));
if (id == null || type == null || x == null || z == null || rot == null) return null;
return new Decoration(id, type, x, z, rot);
}
@Override
public void write(@NotNull TagWritable writer, @NotNull Decoration value) {
writer.setTag(Tag.String("id"), value.id);
writer.setTag(Tag.Byte("type"), value.type);
writer.setTag(Tag.Byte("x"), value.x);
writer.setTag(Tag.Byte("z"), value.z);
writer.setTag(Tag.Double("rot"), value.rotation);
}
}).list().defaultValue(List.of());
private static final Tag<Color> MAP_COLOR = Tag.Integer("MapColor").path("display").map(Color::new, Color::asRGB);
public int getMapId() {
return getTag(MAP_ID);
}
public int getMapScaleDirection() {
return getTag(MAP_SCALE_DIRECTION);
}
public List<Decoration> getDecorations() {
return getTag(DECORATIONS);
}
public @NotNull Color getMapColor() {
return getTag(MAP_COLOR);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
public record Builder(@NotNull ItemComponentMap.Builder components) implements ItemMetaView.Builder {
public Builder mapId(int value) {
setTag(MAP_ID, value);
return this;
}
public Builder mapScaleDirection(int value) {
setTag(MAP_SCALE_DIRECTION, value);
return this;
}
public Builder decorations(List<Decoration> value) {
setTag(DECORATIONS, value);
return this;
}
public Builder mapColor(Color value) {
setTag(MAP_COLOR, value);
return this;
}
}
public record Decoration(String id, byte type, byte x, byte z, double rotation) {
}
}

75
src/main/java/net/minestom/server/item/metadata/PlayerHeadMeta.java
View File

@ -1,75 +0,0 @@
package net.minestom.server.item.metadata;
import net.kyori.adventure.nbt.BinaryTag;
import net.kyori.adventure.nbt.BinaryTagTypes;
import net.kyori.adventure.nbt.CompoundBinaryTag;
import net.kyori.adventure.nbt.ListBinaryTag;
import net.minestom.server.entity.PlayerSkin;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagReadable;
import net.minestom.server.tag.TagSerializer;
import net.minestom.server.tag.TagWritable;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
public record PlayerHeadMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<PlayerHeadMeta.Builder> {
public static final Tag<UUID> SKULL_OWNER = Tag.UUID("Id").path("SkullOwner");
public static final Tag<PlayerSkin> SKIN = Tag.Structure("Properties", new TagSerializer<PlayerSkin>() {
private static final Tag<BinaryTag> TEXTURES = Tag.NBT("textures");
@Override
public @Nullable PlayerSkin read(@NotNull TagReadable reader) {
final BinaryTag result = reader.getTag(TEXTURES);
if (!(result instanceof ListBinaryTag textures)) return null;
final CompoundBinaryTag texture = textures.getCompound(0);
final String value = texture.getString("Value");
final String signature = texture.getString("Signature");
return new PlayerSkin(value, signature);
}
@Override
public void write(@NotNull TagWritable writer, @NotNull PlayerSkin playerSkin) {
final String value = Objects.requireNonNullElse(playerSkin.textures(), "");
final String signature = Objects.requireNonNullElse(playerSkin.signature(), "");
writer.setTag(TEXTURES, ListBinaryTag.listBinaryTag(BinaryTagTypes.COMPOUND, List.of(
CompoundBinaryTag.builder().putString("Value", value).putString("Signature", signature).build()
)));
}
}).path("SkullOwner");
public @Nullable UUID getSkullOwner() {
return getTag(SKULL_OWNER);
}
public @Nullable PlayerSkin getPlayerSkin() {
return getTag(SKIN);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
public record Builder(@NotNull ItemComponentMap.Builder components) implements ItemMetaView.Builder {
public Builder skullOwner(@Nullable UUID skullOwner) {
setTag(SKULL_OWNER, skullOwner);
return this;
}
public Builder playerSkin(@Nullable PlayerSkin playerSkin) {
setTag(SKIN, playerSkin);
return this;
}
}
}

85
src/main/java/net/minestom/server/item/metadata/PotionMeta.java
View File

@ -1,85 +0,0 @@
package net.minestom.server.item.metadata;
import net.minestom.server.color.Color;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.potion.CustomPotionEffect;
import net.minestom.server.potion.PotionType;
import net.minestom.server.registry.StaticProtocolObject;
import net.minestom.server.tag.Tag;
import net.minestom.server.tag.TagReadable;
import net.minestom.server.tag.TagSerializer;
import net.minestom.server.tag.TagWritable;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.util.List;
public record PotionMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<PotionMeta.Builder> {
private static final Tag<PotionType> POTION_TYPE = Tag.String("Potion").map(PotionType::fromNamespaceId, StaticProtocolObject::name).defaultValue(PotionType.WATER);
private static final Tag<List<CustomPotionEffect>> CUSTOM_POTION_EFFECTS = Tag.Structure("CustomPotionEffects", new TagSerializer<CustomPotionEffect>() {
@Override
public @Nullable CustomPotionEffect read(@NotNull TagReadable reader) {
final Byte id = reader.getTag(Tag.Byte("Id"));
final Byte amplifier = reader.getTag(Tag.Byte("Amplifier"));
final Integer duration = reader.getTag(Tag.Integer("Duration"));
final Boolean ambient = reader.getTag(Tag.Boolean("Ambient"));
final Boolean showParticles = reader.getTag(Tag.Boolean("ShowParticles"));
final Boolean showIcon = reader.getTag(Tag.Boolean("ShowIcon"));
if (id == null || amplifier == null || duration == null || ambient == null || showParticles == null || showIcon == null) {
return null;
}
return new CustomPotionEffect(id, amplifier, duration, ambient, showParticles, showIcon);
}
@Override
public void write(@NotNull TagWritable writer, @NotNull CustomPotionEffect value) {
writer.setTag(Tag.Byte("Id"), value.id());
writer.setTag(Tag.Byte("Amplifier"), value.amplifier());
writer.setTag(Tag.Integer("Duration"), value.duration());
writer.setTag(Tag.Boolean("Ambient"), value.isAmbient());
writer.setTag(Tag.Boolean("ShowParticles"), value.showParticles());
writer.setTag(Tag.Boolean("ShowIcon"), value.showIcon());
}
}).list().defaultValue(List.of());
private static final Tag<Color> CUSTOM_POTION_COLOR = Tag.Integer("CustomPotionColor").path("display").map(Color::new, Color::asRGB);
public @NotNull PotionType getPotionType() {
return getTag(POTION_TYPE);
}
public @NotNull List<CustomPotionEffect> getCustomPotionEffects() {
return getTag(CUSTOM_POTION_EFFECTS);
}
public @Nullable Color getColor() {
return getTag(CUSTOM_POTION_COLOR);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
public record Builder(@NotNull ItemComponentMap.Builder components) implements ItemMetaView.Builder {
public Builder potionType(@NotNull PotionType potionType) {
setTag(POTION_TYPE, potionType);
return this;
}
public Builder effects(@NotNull List<CustomPotionEffect> customPotionEffects) {
setTag(CUSTOM_POTION_EFFECTS, customPotionEffects);
return this;
}
public Builder color(@NotNull Color color) {
setTag(CUSTOM_POTION_COLOR, color);
return this;
}
}
}

37
src/main/java/net/minestom/server/item/metadata/WritableBookMeta.java
View File

@ -1,37 +0,0 @@
package net.minestom.server.item.metadata;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.UnknownNullability;
import java.util.List;
public record WritableBookMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<WritableBookMeta.Builder> {
private static final Tag<List<Component>> PAGES = Tag.String("pages")
.<Component>map(s -> LegacyComponentSerializer.legacySection().deserialize(s),
textComponent -> LegacyComponentSerializer.legacySection().serialize(textComponent))
.list().defaultValue(List.of());
public @NotNull List<@NotNull Component> getPages() {
return getTag(PAGES);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
public record Builder(@NotNull ItemComponentPatch.Builder components) implements ItemMetaView.Builder {
public Builder pages(@NotNull List<@NotNull Component> pages) {
setTag(PAGES, pages);
return this;
}
}
}

96
src/main/java/net/minestom/server/item/metadata/WrittenBookMeta.java
View File

@ -1,96 +0,0 @@
package net.minestom.server.item.metadata;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import net.minestom.server.item.ItemMetaView;
import net.minestom.server.item.component.CustomData;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.item.component.ItemComponentPatch;
import net.minestom.server.tag.Tag;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.UnknownNullability;
import java.util.Arrays;
import java.util.List;
public record WrittenBookMeta(@NotNull ItemComponentPatch components) implements ItemMetaView<WrittenBookMeta.Builder> {
private static final Tag<Boolean> RESOLVED = Tag.Boolean("resolved").defaultValue(false);
private static final Tag<WrittenBookGeneration> GENERATION = Tag.Integer("resolved").map(integer -> WrittenBookGeneration.values()[integer], Enum::ordinal);
private static final Tag<String> AUTHOR = Tag.String("author");
private static final Tag<String> TITLE = Tag.String("title");
private static final Tag<List<Component>> PAGES = Tag.String("pages")
.map(GsonComponentSerializer.gson()::deserialize, GsonComponentSerializer.gson()::serialize)
.list().defaultValue(List.of());
public boolean isResolved() {
return getTag(RESOLVED);
}
public @Nullable WrittenBookGeneration getGeneration() {
return getTag(GENERATION);
}
public @Nullable String getAuthor() {
return getTag(AUTHOR);
}
public @Nullable String getTitle() {
return getTag(TITLE);
}
public @NotNull List<@NotNull Component> getPages() {
return getTag(PAGES);
}
@Override
public <T> @UnknownNullability T getTag(@NotNull Tag<T> tag) {
return components.get(ItemComponent.CUSTOM_DATA, CustomData.EMPTY).getTag(tag);
}
public enum WrittenBookGeneration {
ORIGINAL, COPY_OF_ORIGINAL, COPY_OF_COPY, TATTERED
}
public record Builder(@NotNull ItemComponentMap.Builder components) implements ItemMetaView.Builder {
public Builder resolved(boolean resolved) {
setTag(RESOLVED, resolved);
return this;
}
public Builder generation(@Nullable WrittenBookGeneration generation) {
setTag(GENERATION, generation);
return this;
}
public Builder author(@Nullable String author) {
setTag(AUTHOR, author);
return this;
}
public Builder author(@Nullable Component author) {
return author(author != null ? LegacyComponentSerializer.legacySection().serialize(author) : null);
}
public Builder title(@Nullable String title) {
setTag(TITLE, title);
return this;
}
public Builder title(@Nullable Component title) {
return title(title != null ? LegacyComponentSerializer.legacySection().serialize(title) : null);
}
public Builder pages(@NotNull List<@NotNull Component> pages) {
setTag(PAGES, pages);
return this;
}
public Builder pages(Component... pages) {
return pages(Arrays.asList(pages));
}
}
}

2
src/main/java/net/minestom/server/network/NetworkBufferTypeImpl.java
View File

@ -8,9 +8,9 @@ import net.minestom.server.adventure.serializer.nbt.NbtComponentSerializer;
import net.minestom.server.color.Color;
import net.minestom.server.coordinate.Point;
import net.minestom.server.coordinate.Vec;
import net.minestom.server.item.ItemComponent;
import net.minestom.server.item.ItemStack;
import net.minestom.server.item.Material;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.network.packet.server.play.data.WorldPos;
import net.minestom.server.particle.Particle;
import net.minestom.server.particle.data.ParticleData;

4
src/main/java/net/minestom/server/registry/Registry.java
View File

@ -10,9 +10,9 @@ import net.minestom.server.collision.CollisionUtils;
import net.minestom.server.collision.Shape;
import net.minestom.server.entity.EntitySpawnType;
import net.minestom.server.instance.block.Block;
import net.minestom.server.item.ItemComponent;
import net.minestom.server.item.ItemComponentMap;
import net.minestom.server.item.Material;
import net.minestom.server.item.component.ItemComponent;
import net.minestom.server.item.component.ItemComponentMap;
import net.minestom.server.utils.NamespaceID;
import net.minestom.server.utils.collection.ObjectArray;
import net.minestom.server.utils.nbt.BinaryTagReader;