finish port to 1.21 and port the new compat system

gradle.properties

@@ -14,11 +14,11 @@ minecraft_version=1.21-rc1
 # The Minecraft version range can use any release version of Minecraft as bounds.
 # Snapshots, pre-releases, and release candidates are not guaranteed to sort properly
 # as they do not follow standard versioning conventions.
-minecraft_version_range=[1.21,1.22)
+minecraft_version_range=[1.21-rc1,1.22)
 # The Neo version must agree with the Minecraft version to get a valid artifact
 neo_version=21.0.0-alpha.1.21-rc1.20240612.183440
 # The Neo version range can use any version of Neo as bounds
-neo_version_range=[21.0,)
+neo_version_range=[21.0.0-alpha.1.21-rc1.20240612.183440,)
 # The loader version range can only use the major version of FML as bounds
 loader_version_range=[2,)
 

src/main/java/com/leclowndu93150/duradisplay/Main.java

@@ -1,22 +1,31 @@
 package com.leclowndu93150.duradisplay;
 
 import com.leclowndu93150.duradisplay.api.CustomDisplayItem;
+import com.leclowndu93150.duradisplay.compat.BuiltinCompat;
+import com.leclowndu93150.duradisplay.renderer.DuraDisplay;
 import com.mojang.serialization.Codec;
 import net.minecraft.SharedConstants;
 import net.minecraft.core.component.DataComponentType;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.world.item.BundleItem;
 import net.minecraft.world.item.Item;
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.ModList;
 import net.neoforged.fml.common.EventBusSubscriber;
 import net.neoforged.fml.common.Mod;
+import net.neoforged.neoforge.capabilities.Capabilities;
 import net.neoforged.neoforge.client.event.RegisterItemDecorationsEvent;
+import net.neoforged.neoforge.energy.IEnergyStorage;
 import net.neoforged.neoforge.registries.DeferredRegister;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
@@ -26,22 +35,79 @@
 public class Main {
  // Define mod id in a common place for everything to reference
  public static final String MODID = "duradisplay";
-
  public static Logger LOGGER = LogManager.getLogger(MODID);
 
+ public static final List<BuiltinCompat.CompatSupplier> BUILTIN_COMPATS = new ArrayList<>();
+
  private static final DeferredRegister<DataComponentType<?>> DATA_COMPONENTS = DeferredRegister.create(BuiltInRegistries.DATA_COMPONENT_TYPE, MODID);
  protected static Supplier<DataComponentType<Integer>> TEST_DATA;
 
- public Main(IEventBus modEventbus) {
+ public Main(IEventBus modEventBus) {
  // Only register items if running in-dev
  if (SharedConstants.IS_RUNNING_IN_IDE) {
  DeferredRegister<Item> ITEMS = DeferredRegister.create(BuiltInRegistries.ITEM, MODID);
+ ITEMS.register("test_item", TestItem::new);
+ ITEMS.register(modEventBus);
+ DATA_COMPONENTS.register(modEventBus);
  TEST_DATA = registerDataComponentType("test_data",
  builder -> builder.persistent(Codec.INT).networkSynchronized(ByteBufCodecs.INT));
- ITEMS.register("test_item", TestItem::new);
- ITEMS.register(modEventbus);
- DATA_COMPONENTS.register(modEventbus);
  }
+ registerCompats();
+ }
+
+ private static void registerCompats() {
+ // NOTE: The order this is registered in determines its priority
+ // Custom
+ registerCompat(itemStack -> {
+ if (itemStack.getItem() instanceof CustomDisplayItem item) {
+ return new BuiltinCompat(item.getPercentage(itemStack), item.getColor(itemStack), item.shouldDisplay(itemStack));
+ }
+ return null;
+ });
+ // Energy
+ registerCompat(itemStack -> {
+ @Nullable IEnergyStorage energyStorage = itemStack.getCapability(Capabilities.EnergyStorage.ITEM);
+ if (energyStorage != null) {
+ return new BuiltinCompat(
+ ((double) energyStorage.getEnergyStored() / (double) energyStorage.getMaxEnergyStored()) * 100D,
+ itemStack.getItem().getBarColor(itemStack),
+ itemStack.isBarVisible()
+ );
+ }
+ return null;
+ });
+ // Damage
+ registerCompat(itemStack -> {
+ if (itemStack.isDamageableItem()) {
+ int damage = itemStack.getDamageValue();
+ int maxDamage = itemStack.getMaxDamage();
+ double durabilityPercentage = ((double) (maxDamage - damage) / (double) maxDamage) * 100D;
+ return new BuiltinCompat(durabilityPercentage, itemStack.getBarColor(), itemStack.isBarVisible());
+ }
+ return null;
+ });
+ /*
+ // Hardcore torches
+ registerCompat(itemStack -> {
+ if (ModList.get().isLoaded("hardcore_torches")) {
+ HTCompat compat = HTCompat.from(itemStack);
+ return compat == null ? null : compat.registerCompat();
+ }
+ return null;
+ });
+ */
+ // Bundle
+ registerCompat(itemStack -> {
+ if (itemStack.getItem() instanceof BundleItem) {
+ double percentage = BundleItem.getFullnessDisplay(itemStack) * 100D;
+ return new BuiltinCompat(percentage, itemStack.getBarColor(), itemStack.isBarVisible());
+ }
+ return null;
+ });
+ }
+
+ private static void registerCompat(BuiltinCompat.CompatSupplier supplier) {
+ BUILTIN_COMPATS.add(supplier);
  }
 
  public static <T> Supplier<DataComponentType<T>> registerDataComponentType(String name, UnaryOperator<DataComponentType.Builder<T>> builderOperator) {
@@ -53,22 +119,8 @@ public static class ClientEvents {
  @SubscribeEvent
  public static void onRegisterItemDecorations(final RegisterItemDecorationsEvent event) {
  for (Item item : BuiltInRegistries.ITEM) {
- if (item instanceof CustomDisplayItem customDisplayItem) {
- // Item has custom display behavior, so we pass the
- // customDisplayItem to the duradisplay
-
- // LOGGER.info("Found custom display item: "+item);
-
- event.register(item, new DuraDisplay(customDisplayItem, DuraDisplay.DisplayType.CUSTOM));
- } else if (item.getDefaultInstance().isDamageableItem()) {
- // Item has durability, so we pass null and therefore use
- // builtin behavior
- event.register(item, new DuraDisplay(null, DuraDisplay.DisplayType.DURABILITY));
- } else {
- // Item has energy or is a regular item, so we pass null and therefore use
- // builtin behavior
- event.register(item, new DuraDisplay(null, DuraDisplay.DisplayType.ENERGY));
- }
+ System.out.println("Registering the item decoration");
+ event.register(item, new DuraDisplay());
  }
  }
  }

src/main/java/com/leclowndu93150/duradisplay/compat/BuiltinCompat.java

@@ -0,0 +1,13 @@
+package com.leclowndu93150.duradisplay.compat;
+
+import net.minecraft.world.item.ItemStack;
+
+import javax.annotation.Nullable;
+
+public record BuiltinCompat(double percentage, int color, boolean active) {
+ @FunctionalInterface
+ public interface CompatSupplier {
+ @Nullable
+ BuiltinCompat compat(ItemStack itemStack);
+ }
+}

src/main/java/com/leclowndu93150/duradisplay/renderer/DuraDisplay.java

@@ -0,0 +1,76 @@
+package com.leclowndu93150.duradisplay.renderer;
+
+import com.leclowndu93150.duradisplay.api.CustomDisplayItem;
+import com.leclowndu93150.duradisplay.compat.BuiltinCompat;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.world.item.ItemStack;
+import net.neoforged.neoforge.capabilities.Capabilities;
+import net.neoforged.neoforge.client.IItemDecorator;
+import net.neoforged.neoforge.energy.IEnergyStorage;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nullable;
+
+import static com.leclowndu93150.duradisplay.Main.BUILTIN_COMPATS;
+
+public record DuraDisplay() implements IItemDecorator {
+ @Override
+ public boolean render(GuiGraphics guiGraphics, Font font, ItemStack stack, int xPosition, int yPosition) {
+ if (!stack.isEmpty() && stack.isBarVisible()) {
+ // TODO: Port keybinds to 1.21
+ //if (KeyBind.ForgeClient.modEnabled) {
+ for (BuiltinCompat.CompatSupplier supplier : BUILTIN_COMPATS) {
+ BuiltinCompat compat = supplier.compat(stack);
+ if (compat != null && compat.active()) {
+ double percentage = compat.percentage();
+ renderText(guiGraphics, font, String.format("%.0f%%", percentage), xPosition, yPosition, compat.color());
+ return true;
+ }
+ }
+ //}
+
+ renderItemBar(stack, xPosition, yPosition, guiGraphics);
+ }
+ return true;
+ }
+
+ private void renderText(GuiGraphics guiGraphics, Font font, String text, int xPosition, int yPosition, int color) {
+ PoseStack poseStack = guiGraphics.pose();
+ int stringWidth = font.width(text);
+ int x = ((xPosition + 8) * 2 + 1 + stringWidth / 2 - stringWidth);
+ int y = (yPosition * 2) + 22;
+ poseStack.pushPose();
+ poseStack.scale(0.5F, 0.5F, 0.5F);
+ poseStack.translate(0.0D, 0.0D, 500.0D);
+ MultiBufferSource.BufferSource buffer = Minecraft.getInstance().renderBuffers().bufferSource();
+ font.drawInBatch(
+ text,
+ x,
+ y,
+ color,
+ true,
+ poseStack.last().pose(),
+ buffer,
+ Font.DisplayMode.NORMAL,
+ 0,
+ 15728880,
+ font.isBidirectional()
+ );
+ buffer.endBatch();
+ poseStack.popPose();
+ }
+
+ private void renderItemBar(ItemStack stack, int xPosition, int yPosition, GuiGraphics guiGraphics) {
+ int l = stack.getBarWidth();
+ int i = stack.getBarColor();
+ int j = xPosition + 2;
+ int k = yPosition + 13;
+ guiGraphics.fill(RenderType.guiOverlay(), j, k, j + 13, k + 2, -16777216);
+ guiGraphics.fill(RenderType.guiOverlay(), j, k, j + l, k + 1, i | 0xFF000000);
+ }
+}