添加物品更新器

core/src/main/java/net/momirealms/craftengine/core/item/AbstractCustomItem.java

@@ -2,6 +2,7 @@ package net.momirealms.craftengine.core.item;
 
 import net.momirealms.craftengine.core.item.behavior.ItemBehavior;
 import net.momirealms.craftengine.core.item.modifier.ItemDataModifier;
+import net.momirealms.craftengine.core.item.updater.ItemUpdateConfig;
 import net.momirealms.craftengine.core.plugin.context.PlayerOptionalContext;
 import net.momirealms.craftengine.core.plugin.context.event.EventTrigger;
 import net.momirealms.craftengine.core.plugin.context.function.Function;
@@ -24,6 +25,7 @@ public abstract class AbstractCustomItem<I> implements CustomItem<I> {
     protected final List<ItemBehavior> behaviors;
     protected final ItemSettings settings;
     protected final Map<EventTrigger, List<Function<PlayerOptionalContext>>> events;
+    protected final ItemUpdateConfig updater;
 
     @SuppressWarnings("unchecked")
     public AbstractCustomItem(boolean isVanillaItem, UniqueKey id, Key material, Key clientBoundMaterial,
@@ -31,7 +33,8 @@ public abstract class AbstractCustomItem<I> implements CustomItem<I> {
                               List<ItemDataModifier<I>> modifiers,
                               List<ItemDataModifier<I>> clientBoundModifiers,
                               ItemSettings settings,
-                              Map<EventTrigger, List<Function<PlayerOptionalContext>>> events) {
+                              Map<EventTrigger, List<Function<PlayerOptionalContext>>> events,
+                              ItemUpdateConfig updater) {
         this.isVanillaItem = isVanillaItem;
         this.id = id;
         this.material = material;
@@ -43,6 +46,7 @@ public abstract class AbstractCustomItem<I> implements CustomItem<I> {
         this.clientBoundModifiers = clientBoundModifiers.toArray(new ItemDataModifier[0]);
         this.behaviors = List.copyOf(behaviors);
         this.settings = settings;
+        this.updater = updater;
     }
 
     @Override
@@ -52,6 +56,11 @@ public abstract class AbstractCustomItem<I> implements CustomItem<I> {
         }
     }
 
+    @Override
+    public Optional<ItemUpdateConfig> updater() {
+        return Optional.ofNullable(this.updater);
+    }
+
     @Override
     public Key id() {
         return this.id.key();

core/src/main/java/net/momirealms/craftengine/core/item/AbstractItemManager.java

@@ -6,6 +6,10 @@ import net.momirealms.craftengine.core.item.behavior.ItemBehavior;
 import net.momirealms.craftengine.core.item.behavior.ItemBehaviors;
 import net.momirealms.craftengine.core.item.equipment.*;
 import net.momirealms.craftengine.core.item.modifier.*;
+import net.momirealms.craftengine.core.item.updater.ItemUpdateConfig;
+import net.momirealms.craftengine.core.item.updater.ItemUpdateResult;
+import net.momirealms.craftengine.core.item.updater.ItemUpdater;
+import net.momirealms.craftengine.core.item.updater.ItemUpdaters;
 import net.momirealms.craftengine.core.pack.AbstractPackManager;
 import net.momirealms.craftengine.core.pack.LoadingSequence;
 import net.momirealms.craftengine.core.pack.Pack;
@@ -30,6 +34,7 @@ import org.incendo.cloud.type.Either;
 import java.nio.file.Path;
 import java.util.*;
 import java.util.function.Consumer;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 public abstract class AbstractItemManager<I> extends AbstractModelGenerator implements ItemManager<I> {
@@ -144,6 +149,19 @@ public abstract class AbstractItemManager<I> extends AbstractModelGenerator impl
         return Optional.ofNullable(this.customItemsByPath.get(path));
     }
 
+    @Override
+    public ItemUpdateResult updateItem(Item<I> item, Supplier<ItemBuildContext> contextSupplier) {
+        Optional<CustomItem<I>> optionalCustomItem = item.getCustomItem();
+        if (optionalCustomItem.isPresent()) {
+            CustomItem<I> customItem = optionalCustomItem.get();
+            Optional<ItemUpdateConfig> updater = customItem.updater();
+            if (updater.isPresent()) {
+                return updater.get().update(item, contextSupplier);
+            }
+        }
+        return new ItemUpdateResult(item, false, false);
+    }
+
     @Override
     public boolean addCustomItem(CustomItem<I> customItem) {
         Key id = customItem.id();
@@ -417,6 +435,25 @@ public abstract class AbstractItemManager<I> extends AbstractModelGenerator impl
                 behaviors = Collections.emptyList();
             }
 
+            // 如果有物品更新器
+            if (section.containsKey("updater")) {
+                Map<String, Object> updater = ResourceConfigUtils.getAsMap(section.get("updater"), "updater");
+                List<ItemUpdateConfig.Version> versions = new ArrayList<>(2);
+                for (Map.Entry<String, Object> entry : updater.entrySet()) {
+                    try {
+                        int version = Integer.parseInt(entry.getKey());
+                        versions.add(new ItemUpdateConfig.Version(
+                                version,
+                                ResourceConfigUtils.parseConfigAsList(entry.getValue(), map -> ItemUpdaters.fromMap(id, map)).toArray(new ItemUpdater[0])
+                        ));
+                    } catch (NumberFormatException ignored) {
+                    }
+                }
+                ItemUpdateConfig config = new ItemUpdateConfig(versions);
+                itemBuilder.updater(config);
+                itemBuilder.dataModifier(new ItemVersionModifier<>(config.maxVersion()));
+            }
+
             // 构建自定义物品
             CustomItem<I> customItem = itemBuilder
                     .isVanillaItem(isVanillaItem)

core/src/main/java/net/momirealms/craftengine/core/item/CustomItem.java

@@ -2,6 +2,7 @@ package net.momirealms.craftengine.core.item;
 
 import net.momirealms.craftengine.core.item.behavior.ItemBehavior;
 import net.momirealms.craftengine.core.item.modifier.ItemDataModifier;
+import net.momirealms.craftengine.core.item.updater.ItemUpdateConfig;
 import net.momirealms.craftengine.core.plugin.context.PlayerOptionalContext;
 import net.momirealms.craftengine.core.plugin.context.event.EventTrigger;
 import net.momirealms.craftengine.core.plugin.context.function.Function;
@@ -11,6 +12,7 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 public interface CustomItem<I> extends BuildableItem<I> {
 
@@ -32,6 +34,8 @@ public interface CustomItem<I> extends BuildableItem<I> {
 
     ItemSettings settings();
 
+    Optional<ItemUpdateConfig> updater();
+
     default boolean is(Key tag) {
         return settings().tags().contains(tag);
     }
@@ -64,6 +68,8 @@ public interface CustomItem<I> extends BuildableItem<I> {
 
         Builder<I> settings(ItemSettings settings);
 
+        Builder<I> updater(ItemUpdateConfig updater);
+
         Builder<I> events(Map<EventTrigger, List<Function<PlayerOptionalContext>>> events);
 
         CustomItem<I> build();

core/src/main/java/net/momirealms/craftengine/core/item/ItemManager.java

@@ -5,6 +5,7 @@ import net.momirealms.craftengine.core.item.behavior.ItemBehavior;
 import net.momirealms.craftengine.core.item.equipment.Equipment;
 import net.momirealms.craftengine.core.item.recipe.DatapackRecipeResult;
 import net.momirealms.craftengine.core.item.recipe.UniqueIdItem;
+import net.momirealms.craftengine.core.item.updater.ItemUpdateResult;
 import net.momirealms.craftengine.core.pack.model.LegacyOverridesModel;
 import net.momirealms.craftengine.core.pack.model.ModernItemModel;
 import net.momirealms.craftengine.core.pack.model.generation.ModelGenerator;
@@ -18,6 +19,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
+import java.util.function.Supplier;
 
 public interface ItemManager<T> extends Manageable, ModelGenerator {
 
@@ -114,4 +116,6 @@ public interface ItemManager<T> extends Manageable, ModelGenerator {
     Item<T> applyTrim(Item<T> base, Item<T> addition, Item<T> template, Key pattern);
 
     Item<T> build(DatapackRecipeResult result);
+
+    ItemUpdateResult updateItem(Item<T> item, Supplier<ItemBuildContext> contextSupplier);
 }

core/src/main/java/net/momirealms/craftengine/core/item/modifier/ArgumentsModifier.java

@@ -37,7 +37,7 @@ public class ArgumentsModifier<I> implements ItemDataModifier<I> {
     @Override
     public Item<I> apply(Item<I> item, ItemBuildContext context) {
         if (VersionHelper.isOrAbove1_20_5()) {
-            CompoundTag customData = (CompoundTag) Optional.ofNullable(item.getSparrowNBTComponent(ComponentKeys.CUSTOM_DATA)).orElse(new CompoundTag());
+            CompoundTag customData = (CompoundTag) Optional.ofNullable(item.getSparrowNBTComponent(ComponentKeys.CUSTOM_DATA)).orElseGet(CompoundTag::new);
             CompoundTag argumentTag = new CompoundTag();
             for (Map.Entry<String, TextProvider> entry : this.arguments.entrySet()) {
                 argumentTag.put(entry.getKey(), new StringTag(entry.getValue().get(context)));

core/src/main/java/net/momirealms/craftengine/core/item/modifier/ItemDataModifiers.java

@@ -31,6 +31,7 @@ public final class ItemDataModifiers {
     public static final Key ATTRIBUTE_MODIFIERS = Key.of("craftengine:attribute-modifiers");
     public static final Key ATTRIBUTES = Key.of("craftengine:attributes");
     public static final Key ARGUMENTS = Key.of("craftengine:arguments");
+    public static final Key VERSION = Key.of("craftengine:version");
     public static final Key ITEM_NAME = Key.of("craftengine:item-name");
     public static final Key OVERWRITABLE_ITEM_NAME = Key.of("craftengine:overwritable-item-name");
     public static final Key JUKEBOX_PLAYABLE = Key.of("craftengine:jukebox-playable");

core/src/main/java/net/momirealms/craftengine/core/item/modifier/ItemVersionModifier.java

@@ -0,0 +1,40 @@
+package net.momirealms.craftengine.core.item.modifier;
+
+import net.momirealms.craftengine.core.item.ComponentKeys;
+import net.momirealms.craftengine.core.item.Item;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.VersionHelper;
+import net.momirealms.sparrow.nbt.CompoundTag;
+
+import java.util.Optional;
+
+public class ItemVersionModifier<I> implements ItemDataModifier<I> {
+    public static final String VERSION_TAG = "craftengine:version";
+    private final int version;
+
+    public ItemVersionModifier(int version) {
+        this.version = version;
+    }
+
+    public int version() {
+        return this.version;
+    }
+
+    @Override
+    public Key type() {
+        return ItemDataModifiers.VERSION;
+    }
+
+    @Override
+    public Item<I> apply(Item<I> item, ItemBuildContext context) {
+        if (VersionHelper.isOrAbove1_20_5()) {
+            CompoundTag customData = (CompoundTag) Optional.ofNullable(item.getSparrowNBTComponent(ComponentKeys.CUSTOM_DATA)).orElseGet(CompoundTag::new);
+            customData.putInt(VERSION_TAG, this.version);
+            item.setNBTComponent(ComponentKeys.CUSTOM_DATA, customData);
+        } else {
+            item.setTag(this.version, VERSION_TAG);
+        }
+        return item;
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/ItemUpdateConfig.java

@@ -0,0 +1,67 @@
+package net.momirealms.craftengine.core.item.updater;
+
+import net.momirealms.craftengine.core.item.Item;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+import net.momirealms.craftengine.core.item.modifier.ItemVersionModifier;
+import net.momirealms.sparrow.nbt.NumericTag;
+import net.momirealms.sparrow.nbt.Tag;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class ItemUpdateConfig {
+    private final List<Version> versions;
+    private final int maxVersion;
+
+    public ItemUpdateConfig(List<Version> versions) {
+        this.versions = new ArrayList<>(versions);
+        this.versions.sort(Version::compareTo);
+        int maxVersion = 0;
+        for (Version version : versions) {
+            maxVersion = Math.max(maxVersion, version.version);
+        }
+        this.maxVersion = maxVersion;
+    }
+
+    public int maxVersion() {
+        return maxVersion;
+    }
+
+    public ItemUpdateResult update(Item<?> item, Supplier<ItemBuildContext> context) {
+        Tag versionTag = item.getTag(ItemVersionModifier.VERSION_TAG);
+        int currentVersion = 0;
+        if (versionTag instanceof NumericTag numericTag) {
+            currentVersion = numericTag.getAsInt();
+        }
+        if (currentVersion >= this.maxVersion) {
+            return new ItemUpdateResult(item, false, false);
+        }
+        ItemBuildContext buildContext = context.get();
+        Item<?> orginalItem = item;
+        for (Version version : this.versions) {
+            if (currentVersion < version.version) {
+                item = version.apply(item, buildContext);
+            }
+        }
+        item.setTag(this.maxVersion, ItemVersionModifier.VERSION_TAG);
+        return new ItemUpdateResult(item, orginalItem != item, true);
+    }
+
+    public record Version(int version, ItemUpdater<?>[] updaters) implements Comparable<Version> {
+
+        @SuppressWarnings("unchecked")
+        public <T> Item<T> apply(Item<T> item, ItemBuildContext context) {
+            for (ItemUpdater<T> updater : (ItemUpdater<T>[]) updaters) {
+                item = updater.update(item, context);
+            }
+            return item;
+        }
+
+        @Override
+        public int compareTo(@NotNull ItemUpdateConfig.Version o) {
+            return Integer.compare(this.version, o.version);
+        }
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/ItemUpdateResult.java

@@ -0,0 +1,6 @@
+package net.momirealms.craftengine.core.item.updater;
+
+import net.momirealms.craftengine.core.item.Item;
+
+public record ItemUpdateResult(Item<?> finalItem, boolean replaced, boolean updated) {
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/ItemUpdater.java

@@ -0,0 +1,9 @@
+package net.momirealms.craftengine.core.item.updater;
+
+import net.momirealms.craftengine.core.item.Item;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+
+public interface ItemUpdater<I> {
+
+    Item<I> update(Item<I> item, ItemBuildContext context);
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/ItemUpdaterType.java

@@ -0,0 +1,10 @@
+package net.momirealms.craftengine.core.item.updater;
+
+import net.momirealms.craftengine.core.util.Key;
+
+import java.util.Map;
+
+public interface ItemUpdaterType<I> {
+
+    ItemUpdater<I> create(Key item, Map<String, Object> args);
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/ItemUpdaters.java

@@ -0,0 +1,42 @@
+package net.momirealms.craftengine.core.item.updater;
+
+import net.momirealms.craftengine.core.item.updater.impl.ApplyDataOperation;
+import net.momirealms.craftengine.core.item.updater.impl.ResetOperation;
+import net.momirealms.craftengine.core.item.updater.impl.TransmuteOperation;
+import net.momirealms.craftengine.core.plugin.locale.LocalizedResourceConfigException;
+import net.momirealms.craftengine.core.registry.BuiltInRegistries;
+import net.momirealms.craftengine.core.registry.Registries;
+import net.momirealms.craftengine.core.registry.WritableRegistry;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+import net.momirealms.craftengine.core.util.ResourceKey;
+
+import java.util.Map;
+
+@SuppressWarnings("unchecked")
+public class ItemUpdaters {
+    public static final Key APPLY_DATA = Key.of("craftengine:apply_data");
+    public static final Key TRANSMUTE = Key.of("craftengine:transmute");
+    public static final Key RESET = Key.of("craftengine:reset");
+
+    static {
+        register(APPLY_DATA, ApplyDataOperation.TYPE);
+        register(TRANSMUTE, TransmuteOperation.TYPE);
+        register(RESET, ResetOperation.TYPE);
+    }
+
+    public static void register(Key id, ItemUpdaterType<?> type) {
+        WritableRegistry<ItemUpdaterType<?>> registry = (WritableRegistry<ItemUpdaterType<?>>) BuiltInRegistries.ITEM_UPDATER_TYPE;
+        registry.register(ResourceKey.create(Registries.ITEM_UPDATER_TYPE.location(), id), type);
+    }
+
+    public static <I> ItemUpdater<I> fromMap(Key item, Map<String, Object> map) {
+        String type = ResourceConfigUtils.requireNonEmptyStringOrThrow(map.get("type"), "warning.config.item.updater.missing_type");
+        Key key = Key.withDefaultNamespace(type, Key.DEFAULT_NAMESPACE);
+        ItemUpdaterType<I> updaterType = (ItemUpdaterType<I>) BuiltInRegistries.ITEM_UPDATER_TYPE.getValue(key);
+        if (updaterType == null) {
+            throw new LocalizedResourceConfigException("warning.config.item.updater.invalid_type", type);
+        }
+        return updaterType.create(item, map);
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/impl/ApplyDataOperation.java

@@ -0,0 +1,49 @@
+package net.momirealms.craftengine.core.item.updater.impl;
+
+import net.momirealms.craftengine.core.item.Item;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+import net.momirealms.craftengine.core.item.modifier.ItemDataModifier;
+import net.momirealms.craftengine.core.item.updater.ItemUpdater;
+import net.momirealms.craftengine.core.item.updater.ItemUpdaterType;
+import net.momirealms.craftengine.core.registry.BuiltInRegistries;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class ApplyDataOperation<I> implements ItemUpdater<I> {
+    public static final Type<?> TYPE = new Type<>();
+    private final List<ItemDataModifier<I>> modifiers;
+
+    public ApplyDataOperation(List<ItemDataModifier<I>> modifiers) {
+        this.modifiers = modifiers;
+    }
+
+    @Override
+    public Item<I> update(Item<I> item, ItemBuildContext context) {
+        if (this.modifiers != null) {
+            for (ItemDataModifier<I> modifier : this.modifiers) {
+                modifier.apply(item, context);
+            }
+        }
+        return item;
+    }
+
+    public static class Type<I> implements ItemUpdaterType<I> {
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public ItemUpdater<I> create(Key item, Map<String, Object> args) {
+            List<ItemDataModifier<I>> modifiers = new ArrayList<>();
+            Map<String, Object> data = ResourceConfigUtils.getAsMap(args.get("data"), "data");
+            for (Map.Entry<String, Object> entry : data.entrySet()) {
+                Optional.ofNullable(BuiltInRegistries.ITEM_DATA_MODIFIER_FACTORY.getValue(Key.withDefaultNamespace(entry.getKey(), Key.DEFAULT_NAMESPACE)))
+                        .ifPresent(factory -> modifiers.add((ItemDataModifier<I>) factory.create(entry.getValue())));
+            }
+            return new ApplyDataOperation<>(modifiers);
+        }
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/impl/ResetOperation.java

@@ -0,0 +1,63 @@
+package net.momirealms.craftengine.core.item.updater.impl;
+
+import net.momirealms.craftengine.core.item.CustomItem;
+import net.momirealms.craftengine.core.item.Item;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+import net.momirealms.craftengine.core.item.ItemManager;
+import net.momirealms.craftengine.core.item.updater.ItemUpdater;
+import net.momirealms.craftengine.core.item.updater.ItemUpdaterType;
+import net.momirealms.craftengine.core.plugin.CraftEngine;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.LazyReference;
+import net.momirealms.craftengine.core.util.MiscUtils;
+import net.momirealms.craftengine.core.util.VersionHelper;
+
+import java.util.List;
+import java.util.Map;
+
+public class ResetOperation<I> implements ItemUpdater<I> {
+    public static final Type<?> TYPE = new Type<>();
+    private final LazyReference<CustomItem<I>> item;
+    private final List<Key> componentsToKeep;
+    private final List<String[]> tagsToKeep;
+
+    public ResetOperation(LazyReference<CustomItem<I>> item, List<Key> componentsToKeep, List<String[]> tagsToKeep) {
+        this.componentsToKeep = componentsToKeep;
+        this.tagsToKeep = tagsToKeep;
+        this.item = item;
+    }
+
+    @Override
+    public Item<I> update(Item<I> item, ItemBuildContext context) {
+        Item<I> newItem = this.item.get().buildItem(context);
+        if (VersionHelper.COMPONENT_RELEASE) {
+            for (Key component : this.componentsToKeep) {
+                if (item.hasComponent(component)) {
+                    newItem.setExactComponent(component, item.getExactComponent(component));
+                }
+            }
+        } else {
+            for (String[] nbt : this.tagsToKeep) {
+                if (item.hasTag((Object[]) nbt)) {
+                    newItem.setTag(item.getTag((Object[]) nbt), (Object[]) nbt);
+                }
+            }
+        }
+        return newItem;
+    }
+
+    public static class Type<I> implements ItemUpdaterType<I> {
+
+        @Override
+        public ItemUpdater<I> create(Key item, Map<String, Object> args) {
+            return new ResetOperation<>(
+                    LazyReference.lazyReference(() -> {
+                        ItemManager<I> itemManager = CraftEngine.instance().itemManager();
+                        return itemManager.getCustomItem(item).orElseThrow();
+                    }),
+                    MiscUtils.getAsStringList(args.get("keep-components")).stream().map(Key::of).toList(),
+                    MiscUtils.getAsStringList(args.get("keep-tags")).stream().map(tag -> tag.split("\\.")).toList()
+            );
+        }
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/item/updater/impl/TransmuteOperation.java

@@ -0,0 +1,32 @@
+package net.momirealms.craftengine.core.item.updater.impl;
+
+import net.momirealms.craftengine.core.item.Item;
+import net.momirealms.craftengine.core.item.ItemBuildContext;
+import net.momirealms.craftengine.core.item.updater.ItemUpdater;
+import net.momirealms.craftengine.core.item.updater.ItemUpdaterType;
+import net.momirealms.craftengine.core.util.Key;
+import net.momirealms.craftengine.core.util.ResourceConfigUtils;
+
+import java.util.Map;
+
+public class TransmuteOperation<I> implements ItemUpdater<I> {
+    public static final Type<?> TYPE = new Type<>();
+    private final Key newMaterial;
+
+    public TransmuteOperation(Key newMaterial) {
+        this.newMaterial = newMaterial;
+    }
+
+    @Override
+    public Item<I> update(Item<I> item, ItemBuildContext context) {
+        return item.transmuteCopy(this.newMaterial, item.count());
+    }
+
+    public static class Type<I> implements ItemUpdaterType<I> {
+
+        @Override
+        public ItemUpdater<I> create(Key item, Map<String, Object> args) {
+            return new TransmuteOperation<>(Key.of(ResourceConfigUtils.requireNonEmptyStringOrThrow(args.get("material"), "warning.config.item.updater.transmute.missing_material")));
+        }
+    }
+}

core/src/main/java/net/momirealms/craftengine/core/plugin/config/Config.java

@@ -151,6 +151,10 @@ public class Config {
 
     protected boolean item$client_bound_model;
     protected boolean item$non_italic_tag;
+    protected boolean item$update_triggers$attack;
+    protected boolean item$update_triggers$click_in_inventory;
+    protected boolean item$update_triggers$drop;
+    protected boolean item$update_triggers$pick_up;
 
     protected String equipment$sacrificed_vanilla_armor$type;
     protected Key equipment$sacrificed_vanilla_armor$asset_id;
@@ -359,6 +363,10 @@ public class Config {
         // item
         item$client_bound_model = config.getBoolean("item.client-bound-model", false);
         item$non_italic_tag = config.getBoolean("item.non-italic-tag", false);
+        item$update_triggers$attack = config.getBoolean("item.update-triggers.attack", false);
+        item$update_triggers$click_in_inventory = config.getBoolean("item.update-triggers.click-in-inventory", false);
+        item$update_triggers$drop = config.getBoolean("item.update-triggers.drop", false);
+        item$update_triggers$pick_up = config.getBoolean("item.update-triggers.pick-up", false);
 
         // block
         block$sound_system$enable = config.getBoolean("block.sound-system.enable", true);
@@ -835,6 +843,22 @@ public class Config {
         return instance.recipe$ingredient_sources;
     }
 
+    public static boolean triggerUpdateAttack() {
+        return instance.item$update_triggers$attack;
+    }
+
+    public static boolean triggerUpdateClick() {
+        return instance.item$update_triggers$click_in_inventory;
+    }
+
+    public static boolean triggerUpdatePickUp() {
+        return instance.item$update_triggers$pick_up;
+    }
+
+    public static boolean triggerUpdateDrop() {
+        return instance.item$update_triggers$drop;
+    }
+
     public void setObf(boolean enable) {
         this.resource_pack$protection$obfuscation$enable = enable;
     }

core/src/main/java/net/momirealms/craftengine/core/registry/BuiltInRegistries.java

@@ -14,6 +14,7 @@ import net.momirealms.craftengine.core.item.recipe.network.legacy.LegacyRecipe;
 import net.momirealms.craftengine.core.item.recipe.network.modern.display.RecipeDisplay;
 import net.momirealms.craftengine.core.item.recipe.network.modern.display.slot.SlotDisplay;
 import net.momirealms.craftengine.core.item.recipe.result.PostProcessor;
+import net.momirealms.craftengine.core.item.updater.ItemUpdaterType;
 import net.momirealms.craftengine.core.loot.LootContext;
 import net.momirealms.craftengine.core.loot.entry.LootEntryContainerFactory;
 import net.momirealms.craftengine.core.loot.function.ApplyBonusCountFunction;
@@ -79,6 +80,7 @@ public class BuiltInRegistries {
     public static final Registry<RecipeDisplay.Type> RECIPE_DISPLAY_TYPE = createConstantBoundRegistry(Registries.RECIPE_DISPLAY_TYPE);
     public static final Registry<LegacyRecipe.Type> LEGACY_RECIPE_TYPE = createConstantBoundRegistry(Registries.LEGACY_RECIPE_TYPE);
     public static final Registry<PostProcessor.Type<?>> RECIPE_POST_PROCESSOR_TYPE = createConstantBoundRegistry(Registries.RECIPE_POST_PROCESSOR_TYPE);
+    public static final Registry<ItemUpdaterType<?>> ITEM_UPDATER_TYPE = createConstantBoundRegistry(Registries.ITEM_UPDATER_TYPE);
 
     private static <T> Registry<T> createConstantBoundRegistry(ResourceKey<? extends Registry<T>> key) {
         return new ConstantBoundRegistry<>(key);

core/src/main/java/net/momirealms/craftengine/core/registry/Registries.java

@@ -14,6 +14,7 @@ import net.momirealms.craftengine.core.item.recipe.network.legacy.LegacyRecipe;
 import net.momirealms.craftengine.core.item.recipe.network.modern.display.RecipeDisplay;
 import net.momirealms.craftengine.core.item.recipe.network.modern.display.slot.SlotDisplay;
 import net.momirealms.craftengine.core.item.recipe.result.PostProcessor;
+import net.momirealms.craftengine.core.item.updater.ItemUpdaterType;
 import net.momirealms.craftengine.core.loot.LootContext;
 import net.momirealms.craftengine.core.loot.entry.LootEntryContainerFactory;
 import net.momirealms.craftengine.core.loot.function.ApplyBonusCountFunction;
@@ -81,4 +82,5 @@ public class Registries {
     public static final ResourceKey<Registry<RecipeDisplay.Type>> RECIPE_DISPLAY_TYPE = ResourceKey.create(ROOT_REGISTRY, Key.withDefaultNamespace("recipe_display_type"));
     public static final ResourceKey<Registry<LegacyRecipe.Type>> LEGACY_RECIPE_TYPE = ResourceKey.create(ROOT_REGISTRY, Key.withDefaultNamespace("legacy_recipe_type"));
     public static final ResourceKey<Registry<PostProcessor.Type<?>>> RECIPE_POST_PROCESSOR_TYPE = ResourceKey.create(ROOT_REGISTRY, Key.withDefaultNamespace("recipe_post_processor_type"));
+    public static final ResourceKey<Registry<ItemUpdaterType<?>>> ITEM_UPDATER_TYPE = ResourceKey.create(ROOT_REGISTRY, Key.withDefaultNamespace("item_updater_type"));
 }

core/src/main/java/net/momirealms/craftengine/core/world/chunk/SingularPalette.java

@@ -18,7 +18,7 @@ public class SingularPalette<T> implements Palette<T> {
         this.idList = idList;
         this.listener = listener;
         if (!entries.isEmpty()) {
-            this.entry = entries.get(0);
+            this.entry = entries.getFirst();
         }
     }