refactor: deprecated tickCount

.github/workflows/build.yml

@@ -54,7 +54,7 @@ jobs:
         run: ./gradlew --refresh-dependencies createMojmapPaperclipJar
 
       - name: Upload Artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v5
         with:
           name: ${{ env.project_id_b }} CI Artifacts
           path: lophine-server/build/libs/*-paperclip-*-mojmap.jar

gradle.properties

@@ -4,7 +4,7 @@ mcVersion=1.21.8
 release=2
 # 0 for skip release, 1 for pre-release, 2 for release
 
-luminolRef=e5ac67331202037c494ce7381630c6544f54d583
+luminolRef=db9feeb2b0114cff9815b8b16ac3416846985693
 
 org.gradle.configuration-cache=true
 org.gradle.caching=true

lophine-server/minecraft-patches/features/0010-Rewrite-tickCount-support.patch

@@ -1,63 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Helvetica Volubi <suisuroru@blue-millennium.fun>
-Date: Sun, 28 Sep 2025 13:21:30 +0800
-Subject: [PATCH] Rewrite tickCount support
-
-
-diff --git a/io/papermc/paper/threadedregions/TickRegionScheduler.java b/io/papermc/paper/threadedregions/TickRegionScheduler.java
-index b957585cf7cf7f845e20f59c7b355722880f3b4e..9b279d003eb9f780ed2723c98b28d9f4d6e3a281 100644
---- a/io/papermc/paper/threadedregions/TickRegionScheduler.java
-+++ b/io/papermc/paper/threadedregions/TickRegionScheduler.java
-@@ -412,6 +412,8 @@ public final class TickRegionScheduler {
-             }
-             // Luminol end - Add tick command support
- 
-+            MinecraftServer.getServer().handleTickCount(tickCount); // Lophine - reuse tick count
-+
-             if (!this.tryMarkTicking()) {
-                 if (!this.cancelled.get()) {
-                     throw new IllegalStateException("Scheduled region should be acquirable");
-diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index b156b5c635f931a3d4abc0584591f90476d011a6..0c2b7aafa8ddee36d38fabd3561e6f97fce828f9 100644
---- a/net/minecraft/server/MinecraftServer.java
-+++ b/net/minecraft/server/MinecraftServer.java
-@@ -305,6 +305,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
- 
-     // Folia start - regionised ticking
-     public final io.papermc.paper.threadedregions.RegionizedServer regionizedServer = new io.papermc.paper.threadedregions.RegionizedServer();
-+    private int tickCount; // Lophine - reuse tick count
-+    private final ThreadLocal<Integer> lastTickCount = ThreadLocal.withInitial(() -> 0); // Lophine - reuse tick count
- 
-     @Override
-     public <V> CompletableFuture<V> submit(java.util.function.Supplier<V> task) {
-@@ -2227,9 +2229,29 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         return false;
-     }
- 
-+    // Lophine start - reuse tick count
-     public int getTickCount() {
--        throw new UnsupportedOperationException(); // Folia - region threading
-+        return this.tickCount;
-+    }
-+
-+    public boolean checkTickCount(int period) {
-+        return this.checkTickCount(period, this.lastTickCount.get());
-+    }
-+
-+    public boolean checkTickCount(int period, int lastTickCount) {
-+        if (this.tickCount % period == 0) {
-+            return true;
-+        }
-+
-+        int nextPeriodTick = ((lastTickCount / period) + 1) * period;
-+        return nextPeriodTick < this.tickCount;
-+    }
-+
-+    public void handleTickCount(int deltaTicks) {
-+        this.lastTickCount.set(this.getTickCount());
-+        this.tickCount += deltaTicks;
-     }
-+    // Lophine end - reuse tick count
- 
-     public int getSpawnProtectionRadius() {
-         return 16;

lophine-server/minecraft-patches/features/0022-Leaves-Fakeplayer.patch

@@ -33,10 +33,10 @@ index 66ec0424a46dcd49cf44467357d80b1a2d84d3b2..04ae8de63af0a8abe578f14c8ef85fd4
      private DisconnectionDetails disconnectionDetails;
      private boolean encrypted;
 diff --git a/net/minecraft/server/MinecraftServer.java b/net/minecraft/server/MinecraftServer.java
-index 0c2b7aafa8ddee36d38fabd3561e6f97fce828f9..e5fc1969b8af692d785214731b3f8cc47df2aa78 100644
+index b156b5c635f931a3d4abc0584591f90476d011a6..81726e5782d25ff35a2bea8820a62786e46148b1 100644
 --- a/net/minecraft/server/MinecraftServer.java
 +++ b/net/minecraft/server/MinecraftServer.java
-@@ -349,6 +349,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -347,6 +347,8 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      }
      // Folia end - regionised ticking
  
@@ -45,7 +45,7 @@ index 0c2b7aafa8ddee36d38fabd3561e6f97fce828f9..e5fc1969b8af692d785214731b3f8cc4
      public static <S extends MinecraftServer> S spin(Function<Thread, S> threadFunction) {
          ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.init(); // Paper - rewrite data converter system
          AtomicReference<S> atomicReference = new AtomicReference<>();
-@@ -1040,6 +1042,11 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1038,6 +1040,11 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      // Folia end - region threading
  
      public void stopServer() {
@@ -57,7 +57,7 @@ index 0c2b7aafa8ddee36d38fabd3561e6f97fce828f9..e5fc1969b8af692d785214731b3f8cc4
          // Folia start - region threading
          // halt scheduler
          // don't wait, we may be on a scheduler thread
-@@ -1590,7 +1597,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1588,7 +1595,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          int i = this.pauseWhileEmptySeconds() * 20;
          this.removeDisabledPluginsBlockingSleep(); // Paper - API to allow/disallow tick sleeping
          if (false && i > 0) { // Folia - region threading - this is complicated to implement, and even if done correctly is messy
@@ -66,7 +66,7 @@ index 0c2b7aafa8ddee36d38fabd3561e6f97fce828f9..e5fc1969b8af692d785214731b3f8cc4
                  this.emptyTicks++;
              } else {
                  this.emptyTicks = 0;
-@@ -1914,6 +1921,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -1912,6 +1919,7 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
      public void tickConnection() {
          this.getConnection().tick();
@@ -74,7 +74,7 @@ index 0c2b7aafa8ddee36d38fabd3561e6f97fce828f9..e5fc1969b8af692d785214731b3f8cc4
      }
  
      private void synchronizeTime(ServerLevel level) {
-@@ -3005,6 +3013,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+@@ -2983,6 +2991,16 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
          return 0;
      }
  

lophine-server/minecraft-patches/features/0029-Leaves-Wool-Hopper-Counter.patch

@@ -0,0 +1,95 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Helvetica Volubi <suisuroru@blue-millennium.fun>
+Date: Mon, 27 Oct 2025 15:38:29 +0800
+Subject: [PATCH] Leaves: Wool Hopper Counter
+
+Co-authored by: violetc <58360096+s-yh-china@users.noreply.github.com>
+As a part of : Leaves (https://github.com/LeavesMC/Leaves)
+Licensed under: MIT
+
+This patch is Powered by fabric-carpet(https://github.com/gnembon/fabric-carpet)
+
+diff --git a/net/minecraft/world/level/block/entity/HopperBlockEntity.java b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+index 55cbf9b4cc568fb9b418433f597ed6b64e4409b0..8449623a313edbe95941a2e328fe47269015f7fb 100644
+--- a/net/minecraft/world/level/block/entity/HopperBlockEntity.java
++++ b/net/minecraft/world/level/block/entity/HopperBlockEntity.java
+@@ -232,8 +232,30 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+                     flag |= validator.getAsBoolean(); // Paper - note: this is not a validator, it's what adds/sucks in items
+                 }
+ 
++                // Leaves start - Wool hopper counter
++                if (fun.bm.lophine.config.modules.function.WoolHopperCounterConfig.unlimitedSpeed && org.leavesmc.leaves.util.HopperCounter.isEnabled()) {
++                    net.minecraft.world.item.DyeColor woolColor = org.leavesmc.leaves.util.WoolUtils.getWoolColorAtPosition(level, blockEntity.getBlockPos().relative(state.getValue(HopperBlock.FACING)));
++                    if (woolColor != null) {
++                        for (int i = 0; i < Short.MAX_VALUE; i++) {
++                            flag |= suckInItems(level, blockEntity);
++                            if (!flag) {
++                                break;
++                            } else {
++                                woolHopperCounter(level, pos, state, HopperBlockEntity.getContainerAt(level, pos));
++                            }
++                        }
++                    }
++                }
++                // Leaves end - Wool hopper counter
++
+                 if (flag) {
+                     blockEntity.setCooldown(level.spigotConfig.hopperTransfer); // Spigot
++                    // Leaves start - Wool hopper counter
++                    if (fun.bm.lophine.config.modules.function.WoolHopperCounterConfig.unlimitedSpeed && org.leavesmc.leaves.util.HopperCounter.isEnabled() && woolHopperCounter(level, pos, state, HopperBlockEntity.getContainerAt(level, pos))) {
++                        blockEntity.setCooldown(0);
++                        return true;
++                    }
++                    // Leaves end - Wool hopper counter
+                     setChanged(level, pos, state);
+                     // Leaves start - Lithium Sleeping Block Entity
+                     if (me.earthme.luminol.config.modules.optimizations.LeavesSleepingBlockEntityConfig.enabled
+@@ -464,6 +486,13 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+     // Paper end - Perf: Optimize Hoppers
+ 
+     private static boolean ejectItems(Level level, BlockPos pos, HopperBlockEntity blockEntity) {
++        // Leaves start - hopper counter
++        if (org.leavesmc.leaves.util.HopperCounter.isEnabled()) {
++            if (woolHopperCounter(level, pos, level.getBlockState(pos), HopperBlockEntity.getContainerAt(level, pos))) {
++                return true;
++            }
++        }
++        // Leaves end - hopper counter
+         Container attachedContainer = me.earthme.luminol.config.modules.optimizations.LeavesSleepingBlockEntityConfig.enabled ? blockEntity.getInsertInventory(level, pos, blockEntity) : getAttachedContainer(level, pos, blockEntity); // Leaves - Lithium Sleeping Block Entity
+         if (attachedContainer == null) {
+             return false;
+@@ -554,6 +583,26 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+         }
+     }
+ 
++    // Leaves start - hopper counter
++    private static boolean woolHopperCounter(Level level, BlockPos blockPos, BlockState state, @Nullable Container container) {
++        if (container == null) {
++            return false;
++        }
++        net.minecraft.world.item.DyeColor woolColor = org.leavesmc.leaves.util.WoolUtils.getWoolColorAtPosition(level, blockPos.relative(state.getValue(HopperBlock.FACING)));
++        if (woolColor != null) {
++            for (int i = 0; i < container.getContainerSize(); ++i) {
++                if (!container.getItem(i).isEmpty()) {
++                    ItemStack itemstack = container.getItem(i);
++                    org.leavesmc.leaves.util.HopperCounter.getCounter(woolColor).add(level, itemstack);
++                    container.setItem(i, ItemStack.EMPTY);
++                }
++            }
++            return true;
++        }
++        return false;
++    }
++    // Leaves end - hopper counter
++
+     private static int[] getSlots(Container container, Direction direction) {
+         if (container instanceof WorldlyContainer worldlyContainer) {
+             return worldlyContainer.getSlotsForFace(direction);
+@@ -710,6 +759,7 @@ public class HopperBlockEntity extends RandomizableContainerBlockEntity implemen
+     }
+ 
+     public static boolean addItem(Container container, ItemEntity item) {
++        if (fun.bm.lophine.config.modules.function.WoolHopperCounterConfig.unlimitedSpeed && org.leavesmc.leaves.util.HopperCounter.isEnabled() && item.isRemoved()) return false; // Leaves - Wool hopper counter
+         boolean flag = false;
+         // CraftBukkit start
+         if (org.bukkit.event.inventory.InventoryPickupItemEvent.getHandlerList().getRegisteredListeners().length > 0) { // Paper - optimize hoppers

lophine-server/src/main/java/fun/bm/lophine/command/counter/CounterCommand.java

@@ -0,0 +1,41 @@
+package fun.bm.lophine.command.counter;
+
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import fun.bm.lophine.command.counter.sub.DisplayCommand;
+import fun.bm.lophine.command.counter.sub.ResetCommand;
+import fun.bm.lophine.command.counter.sub.ToggleCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.command.RootNode;
+import org.leavesmc.leaves.util.HopperCounter;
+
+public class CounterCommand extends RootNode {
+    private final String PERM_BASE;
+
+    public CounterCommand() {
+        super("counter", "lophine.commands.counter");
+        this.PERM_BASE = "lophine.commands.counter";
+        children(
+                new ToggleCommand(this),
+                new ResetCommand(this),
+                new DisplayCommand(this)
+        );
+    }
+
+    @Override
+    protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
+        context.getSender().sendMessage(Component.join(JoinConfiguration.noSeparators(),
+                Component.text("Hopper Counter: ", NamedTextColor.GRAY),
+                Component.text(HopperCounter.isEnabled(), HopperCounter.isEnabled() ? NamedTextColor.AQUA : NamedTextColor.GRAY)
+        ));
+        return true;
+    }
+
+    public boolean hasPermission(@NotNull CommandSender sender, String... subcommand) {
+        return hasPermission(PERM_BASE, sender, subcommand);
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/CounterSubCommand.java

@@ -0,0 +1,24 @@
+package fun.bm.lophine.command.counter;
+
+import net.minecraft.commands.CommandSourceStack;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.LiteralNode;
+
+public class CounterSubCommand extends LiteralNode {
+    protected final CounterCommand parent;
+
+    protected CounterSubCommand(String name, CounterCommand parent) {
+        super(name);
+        this.parent = parent;
+    }
+
+    @Override
+    public boolean requires(@NotNull CommandSourceStack source) {
+        return hasPermission(source.getSender());
+    }
+
+    protected boolean hasPermission(CommandSender sender) {
+        return parent.hasPermission(sender, this.name);
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/sub/DisplayCommand.java

@@ -0,0 +1,91 @@
+package fun.bm.lophine.command.counter.sub;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import fun.bm.lophine.command.counter.CounterCommand;
+import fun.bm.lophine.command.counter.CounterSubCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.item.DyeColor;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.ArgumentNode;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.util.HopperCounter;
+
+import java.util.concurrent.CompletableFuture;
+
+public class DisplayCommand extends CounterSubCommand {
+    public DisplayCommand(CounterCommand parent) {
+        super("display", parent);
+        children(
+                DyeColorArg::new
+        );
+    }
+
+    public static void displayCounter(CommandContext context, @NotNull HopperCounter counter, boolean realTime) {
+        for (Component component : counter.format(MinecraftServer.getServer(), context.getSource().getLevel(), realTime)) {
+            context.getSender().sendMessage(component);
+        }
+    }
+
+    private static class DyeColorArg extends ArgumentNode<String> {
+        protected DyeColorArg() {
+            super("color", StringArgumentType.string());
+            children(
+                    TimeArg::new
+            );
+        }
+
+        @Override
+        protected boolean execute(@NotNull CommandContext context) {
+            String color0 = context.getArgument(DyeColorArg.class);
+            DyeColor color = DyeColor.byName(color0, null);
+            if (color == null) return true;
+            HopperCounter counter = HopperCounter.getCounter(color);
+            displayCounter(context, counter, false);
+            return true;
+        }
+
+        @Override
+        protected CompletableFuture<Suggestions> getSuggestions(@NotNull CommandContext context, @NotNull SuggestionsBuilder builder) {
+            String path = context.getArgumentOrDefault(DyeColorArg.class, "");
+            for (DyeColor value : DyeColor.values()) {
+                String color = value.getName();
+                if (color.startsWith(path)) {
+                    builder.suggest(color);
+                }
+            }
+            return builder.buildFuture();
+        }
+
+        private static class TimeArg extends ArgumentNode<String> {
+            protected TimeArg() {
+                super("time", StringArgumentType.string());
+            }
+
+            @Override
+            protected boolean execute(@NotNull CommandContext context) {
+                String color0 = context.getArgument(DyeColorArg.class);
+                DyeColor color = DyeColor.byName(color0, null);
+                if (color == null) return true;
+                HopperCounter counter = HopperCounter.getCounter(color);
+                String timeType = context.getArgument(TimeArg.class);
+                switch (timeType) {
+                    case "realtime" -> displayCounter(context, counter, true);
+                    case "gametick" -> displayCounter(context, counter, false);
+                    default ->
+                            context.getSender().sendMessage(Component.text("Invalid time type: " + timeType, NamedTextColor.RED));
+                }
+                return true;
+            }
+
+            protected CompletableFuture<Suggestions> getSuggestions(@NotNull CommandContext context, @NotNull SuggestionsBuilder builder) {
+                builder.suggest("realtime");
+                builder.suggest("gametick");
+                return builder.buildFuture();
+            }
+        }
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/sub/ResetCommand.java

@@ -0,0 +1,75 @@
+package fun.bm.lophine.command.counter.sub;
+
+import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import fun.bm.lophine.command.counter.CounterCommand;
+import fun.bm.lophine.command.counter.CounterSubCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.format.TextColor;
+import net.minecraft.world.item.DyeColor;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.ArgumentNode;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.util.HopperCounter;
+
+import java.util.concurrent.CompletableFuture;
+
+public class ResetCommand extends CounterSubCommand {
+    public ResetCommand(CounterCommand parent) {
+        super("reset", parent);
+        children(
+                DyeColorArg::new
+        );
+    }
+
+    @Override
+    protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
+        HopperCounter.resetAll(context.getSource().getLevel(), false);
+        context.getSender().sendMessage(Component.text("Restarted all counters."));
+        return true;
+    }
+
+    private static class DyeColorArg extends ArgumentNode<String> {
+        protected DyeColorArg() {
+            super("color", StringArgumentType.string());
+        }
+
+        @Override
+        protected boolean execute(@NotNull CommandContext context) {
+            String color0 = context.getArgument(DyeColorArg.class);
+            if (color0.equals("all")) {
+                HopperCounter.resetAll(context.getSource().getLevel(), false);
+                context.getSender().sendMessage(Component.text("Restarted all counters."));
+                return true;
+            }
+            DyeColor color = DyeColor.byName(color0, null);
+            if (color == null) return true;
+            HopperCounter counter = HopperCounter.getCounter(color);
+            counter.reset(context.getSource().getLevel());
+            context.getSender().sendMessage(Component.join(JoinConfiguration.noSeparators(),
+                    Component.text("Restarted "),
+                    Component.text(color.getName(), TextColor.color(color.getTextColor())),
+                    Component.text(" counter.")
+            ));
+            return true;
+        }
+
+        @Override
+        protected CompletableFuture<Suggestions> getSuggestions(@NotNull CommandContext context, @NotNull SuggestionsBuilder builder) {
+            String path = context.getArgumentOrDefault(DyeColorArg.class, "");
+            if ("all".startsWith(path)) {
+                builder.suggest("all");
+            }
+            for (DyeColor value : DyeColor.values()) {
+                String color = value.getName();
+                if (color.startsWith(path)) {
+                    builder.suggest(color);
+                }
+            }
+            return builder.buildFuture();
+        }
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/command/counter/sub/ToggleCommand.java

@@ -0,0 +1,55 @@
+package fun.bm.lophine.command.counter.sub;
+
+import com.mojang.brigadier.arguments.BoolArgumentType;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import fun.bm.lophine.command.counter.CounterCommand;
+import fun.bm.lophine.command.counter.CounterSubCommand;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.jetbrains.annotations.NotNull;
+import org.leavesmc.leaves.command.ArgumentNode;
+import org.leavesmc.leaves.command.CommandContext;
+import org.leavesmc.leaves.util.HopperCounter;
+
+public class ToggleCommand extends CounterSubCommand {
+    public ToggleCommand(CounterCommand parent) {
+        super("toggle", parent);
+        children(
+                BooleanArg::new
+        );
+    }
+
+    @Override
+    protected boolean execute(@NotNull CommandContext context) throws CommandSyntaxException {
+        if (!HopperCounter.isEnabled()) {
+            HopperCounter.setEnabled(true);
+            context.getSender().sendMessage(Component.text("Hopper Counter now is enabled.", NamedTextColor.AQUA));
+        } else {
+            HopperCounter.setEnabled(false);
+            context.getSender().sendMessage(Component.text("Hopper Counter now is disabled.", NamedTextColor.RED));
+        }
+        return true;
+    }
+
+    private static class BooleanArg extends ArgumentNode<Boolean> {
+        protected BooleanArg() {
+            super("enabled", BoolArgumentType.bool());
+        }
+
+        @Override
+        protected boolean execute(@NotNull CommandContext context) {
+            boolean enabled = context.getArgument(BooleanArg.class);
+            if (enabled == HopperCounter.isEnabled()) {
+                context.getSender().sendMessage(Component.text("Hopper Counter is already " + (enabled ? "enabled" : "disabled") + ".", NamedTextColor.GRAY));
+            } else {
+                HopperCounter.setEnabled(enabled);
+                if (enabled) {
+                    context.getSender().sendMessage(Component.text("Hopper Counter now is enabled.", NamedTextColor.AQUA));
+                } else {
+                    context.getSender().sendMessage(Component.text("Hopper Counter now is disabled.", NamedTextColor.RED));
+                }
+            }
+            return true;
+        }
+    }
+}

lophine-server/src/main/java/fun/bm/lophine/config/modules/function/WoolHopperCounterConfig.java

@@ -0,0 +1,28 @@
+package fun.bm.lophine.config.modules.function;
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import fun.bm.lophine.command.counter.CounterCommand;
+import me.earthme.luminol.config.IConfigModule;
+import me.earthme.luminol.config.flags.ConfigClassInfo;
+import me.earthme.luminol.config.flags.ConfigInfo;
+import me.earthme.luminol.enums.EnumConfigCategory;
+import org.bukkit.Bukkit;
+
+@ConfigClassInfo(category = EnumConfigCategory.FUNCTION, name = "wool-hopper-counter")
+public class WoolHopperCounterConfig implements IConfigModule {
+    @ConfigInfo(name = "enabled")
+    public static boolean enabled = false;
+
+    @ConfigInfo(name = "unlimited-speed")
+    public static boolean unlimitedSpeed = false;
+
+    @Override
+    public void onLoaded(CommentedFileConfig configInstance) {
+        if (enabled) new CounterCommand().register();
+    }
+
+    @Override
+    public void onUnloaded(CommentedFileConfig configInstance) {
+        Bukkit.getCommandMap().getKnownCommands().remove("luminol:tpsbar");
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/bot/ServerBot.java

@@ -154,7 +154,7 @@ public class ServerBot extends ServerPlayer {
             this.notSleepTicks++;
         }
 
-        if (FakeplayerConfig.regenAmount > 0.0 && getServer().checkTickCount(20)) {
+        if (FakeplayerConfig.regenAmount > 0.0 && this.tickCount % 20 == 0) {
             float regenAmount = (float) (FakeplayerConfig.regenAmount * 20);
             this.setHealth(Math.min(this.getHealth() + regenAmount, this.getMaxHealth()));
         }

lophine-server/src/main/java/org/leavesmc/leaves/protocol/core/LeavesProtocolManager.java

@@ -24,7 +24,6 @@ import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
 import org.leavesmc.leaves.protocol.core.invoker.*;
 import org.slf4j.Logger;
@@ -66,6 +65,8 @@ public class LeavesProtocolManager {
     private static final List<EmptyInvokerHolder<ProtocolHandler.ReloadServer>> RELOAD_SERVER = new ArrayList<>();
     private static final List<EmptyInvokerHolder<ProtocolHandler.ReloadDataPack>> RELOAD_DATAPACK = new ArrayList<>();
 
+    private static long lastAcceptTime = 0;
+
     @SuppressWarnings("unchecked")
     public static void init() {
         for (Class<?> clazz : getClasses("org.leavesmc.leaves.protocol")) {
@@ -253,8 +254,11 @@ public class LeavesProtocolManager {
     }
 
     public static void handleTick() {
+        long currentTime = System.currentTimeMillis() / 50;
+        if (currentTime == lastAcceptTime) return;
+        lastAcceptTime = currentTime;
         for (var tickerInfo : TICKERS) {
-            if (MinecraftServer.getServer().checkTickCount(tickerInfo.owner().tickerInterval(tickerInfo.handler().tickerId()))) {
+            if (currentTime % tickerInfo.owner().tickerInterval(tickerInfo.handler().tickerId()) == 0) {
                 tickerInfo.invoke();
             }
         }

lophine-server/src/main/java/org/leavesmc/leaves/protocol/jade/util/ItemCollector.java

@@ -72,12 +72,12 @@ public class ItemCollector<T> {
             return null;
         }
         long currentVersion = iterator.getVersion(container);
-        long gameTime = request.getLevel().getServer().getTickCount();
+        long gameTimeReforged = System.currentTimeMillis() / 50;
         if (mergedResult != null && iterator.isFinished()) {
             if (version == currentVersion) {
                 return mergedResult; // content not changed
             }
-            if (lastTimeFinished + 5 > gameTime) {
+            if (lastTimeFinished + 5 > gameTimeReforged) {
                 return mergedResult; // avoid update too frequently
             }
             iterator.reset();
@@ -104,7 +104,7 @@ public class ItemCollector<T> {
             mergedResult = groups;
             lastTimeIsEmpty = mergedResult.getFirst().views.isEmpty();
             version = currentVersion;
-            lastTimeFinished = gameTime;
+            lastTimeFinished = gameTimeReforged;
             items.clear();
         }
         return groups;

lophine-server/src/main/java/org/leavesmc/leaves/protocol/rei/REIServerProtocol.java

@@ -98,13 +98,13 @@ public class REIServerProtocol implements LeavesProtocol {
             new ArrayBlockingQueue<>(1),
             new ThreadPoolExecutor.DiscardOldestPolicy()
     );
-    private static int minecraftRecipeVer = 0;
-    private static int nextReiRecipeVer = -1;
+    private static long minecraftRecipeVer = 0;
+    private static long nextReiRecipeVer = -1;
     private static ImmutableList<CustomPacketPayload> cachedPayloads;
 
     @ProtocolHandler.ReloadDataPack
     public static void onRecipeReload() {
-        minecraftRecipeVer = MinecraftServer.getServer().getTickCount();
+        minecraftRecipeVer = System.currentTimeMillis() / 50;
     }
 
     @Contract("_ -> new")
@@ -138,7 +138,7 @@ public class REIServerProtocol implements LeavesProtocol {
     }
 
     @SuppressWarnings({"unchecked", "rawtypes"})
-    private static void reloadRecipe(int reiRecipeVer) {
+    private static void reloadRecipe(long reiRecipeVer) {
         ImmutableList.Builder<Display> builder = ImmutableList.builder();
         MinecraftServer server = MinecraftServer.getServer();
         RecipeMap recipeMap = server.getRecipeManager().recipes;

lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxHudDataProtocol.java

@@ -61,6 +61,7 @@ public class ServuxHudDataProtocol implements LeavesProtocol {
     private static final Table<DataLogger.Type, ServerPlayer, Tag> DATA = HashBasedTable.create();
 
     public static boolean refreshSpawnMetadata = false;
+    private long lastAcceptTime = 0;
 
     @ProtocolHandler.Init
     private static void initializeLoggers() {
@@ -238,9 +239,12 @@ public class ServuxHudDataProtocol implements LeavesProtocol {
             return;
         }
 
-        MinecraftServer server = MinecraftServer.getServer();
+        long currentTime = System.currentTimeMillis() / 50;
+        if (currentTime == lastAcceptTime) return;
+        lastAcceptTime = currentTime;
 
-        if (server.checkTickCount(ServuxProtocolConfig.hudUpdateInterval)) {
+        if (currentTime % ServuxProtocolConfig.hudUpdateInterval == 0) {
+            MinecraftServer server = MinecraftServer.getServer();
             LOGGERS.forEach((type, logger) -> {
                 if (!isLoggerTypeEnabled(type)) {
                     return;

lophine-server/src/main/java/org/leavesmc/leaves/protocol/servux/ServuxStructuresProtocol.java

@@ -84,7 +84,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
     @ProtocolHandler.Ticker
     public static void tick() {
         MinecraftServer server = MinecraftServer.getServer();
-        int tickCounter = server.getTickCount();
+        long tickCounter = System.currentTimeMillis() / 50;
         retainDistance = server.getPlayerList().getViewDistance() + 2;
         for (ServerPlayer player : players.values()) {
             // TODO DimensionChange
@@ -95,11 +95,11 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
     public static void onStartedWatchingChunk(ServerPlayer player, LevelChunk chunk) {
         MinecraftServer server = player.getServer();
         if (players.containsKey(player.getId()) && server != null) {
-            addChunkTimeoutIfHasReferences(player.getUUID(), chunk, server.getTickCount());
+            addChunkTimeoutIfHasReferences(player.getUUID(), chunk, System.currentTimeMillis() / 50);
         }
     }
 
-    private static void addChunkTimeoutIfHasReferences(final UUID uuid, LevelChunk chunk, final int tickCounter) {
+    private static void addChunkTimeoutIfHasReferences(final UUID uuid, LevelChunk chunk, final long tickCounter) {
         final ChunkPos pos = chunk.getPos();
 
         if (chunkHasStructureReferences(pos.x, pos.z, chunk.getLevel())) {
@@ -135,7 +135,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
 
         MinecraftServer server = MinecraftServer.getServer();
         sendMetaData(player);
-        initialSyncStructures(player, player.moonrise$getViewDistanceHolder().getViewDistances().sendViewDistance() + 2, server.getTickCount());
+        initialSyncStructures(player, player.moonrise$getViewDistanceHolder().getViewDistances().sendViewDistance() + 2, System.currentTimeMillis() / 50);
     }
 
     private static void sendMetaData(ServerPlayer player) {
@@ -149,7 +149,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
         sendPacket(player, new StructuresPayload(StructuresPayloadType.PACKET_S2C_METADATA, tag));
     }
 
-    public static void initialSyncStructures(ServerPlayer player, int chunkRadius, int tickCounter) {
+    public static void initialSyncStructures(ServerPlayer player, int chunkRadius, long tickCounter) {
         UUID uuid = player.getUUID();
         ChunkPos center = player.getLastSectionPos().chunk();
         Map<Structure, LongSet> references = getStructureReferences(player.level(), center, chunkRadius);
@@ -195,7 +195,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
         }
     }
 
-    public static void sendStructures(ServerPlayer player, Map<Structure, LongSet> references, int tickCounter) {
+    public static void sendStructures(ServerPlayer player, Map<Structure, LongSet> references, long tickCounter) {
         ServerLevel world = player.level();
         Map<ChunkPos, StructureStart> starts = getStructureStarts(world, references);
 
@@ -254,7 +254,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
         return starts;
     }
 
-    public static void refreshTrackedChunks(ServerPlayer player, int tickCounter) {
+    public static void refreshTrackedChunks(ServerPlayer player, long tickCounter) {
         UUID uuid = player.getUUID();
         Map<ChunkPos, Timeout> map = timeouts.get(uuid);
 
@@ -263,7 +263,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
         }
     }
 
-    public static void sendAndRefreshExpiredStructures(ServerPlayer player, Map<ChunkPos, Timeout> map, int tickCounter) {
+    public static void sendAndRefreshExpiredStructures(ServerPlayer player, Map<ChunkPos, Timeout> map, long tickCounter) {
         Set<ChunkPos> positionsToUpdate = new HashSet<>();
 
         for (Map.Entry<ChunkPos, Timeout> entry : map.entrySet()) {
@@ -303,7 +303,7 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
         return Math.abs(pos.x - center.x) > retainDistance || Math.abs(pos.z - center.z) > retainDistance;
     }
 
-    public static void addOrRefreshTimeouts(final UUID uuid, final Map<Structure, LongSet> references, final int tickCounter) {
+    public static void addOrRefreshTimeouts(final UUID uuid, final Map<Structure, LongSet> references, final long tickCounter) {
         Map<ChunkPos, Timeout> map = timeouts.computeIfAbsent(uuid, (u) -> new HashMap<>());
 
         for (LongSet chunks : references.values()) {
@@ -402,18 +402,17 @@ public class ServuxStructuresProtocol implements LeavesProtocol {
     }
 
     public static class Timeout {
-        private int lastSync;
+        private long lastSync;
 
-        public Timeout(int currentTick) {
+        public Timeout(long currentTick) {
             this.lastSync = currentTick;
         }
 
-        public boolean needsUpdate(int currentTick, int timeout) {
-            if (timeout == -1 || currentTick - this.lastSync >= timeout) return true;
-            return MinecraftServer.getServer().checkTickCount(timeout);
+        public boolean needsUpdate(int timeout, long currentTick) {
+            return timeout == -1 || currentTick - this.lastSync >= timeout;
         }
 
-        public void setLastSync(int tickCounter) {
+        public void setLastSync(long tickCounter) {
             this.lastSync = tickCounter;
         }
     }

lophine-server/src/main/java/org/leavesmc/leaves/util/HopperCounter.java

@@ -0,0 +1,351 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.util;
+
+import fun.bm.lophine.config.modules.function.WoolHopperCounterConfig;
+import it.unimi.dsi.fastutil.objects.Object2LongLinkedOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2LongMap;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.Style;
+import net.kyori.adventure.text.format.TextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import net.minecraft.core.Holder;
+import net.minecraft.core.Registry;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.context.ContextMap;
+import net.minecraft.world.item.*;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.Recipe;
+import net.minecraft.world.item.crafting.RecipeManager;
+import net.minecraft.world.item.crafting.display.RecipeDisplay;
+import net.minecraft.world.item.crafting.display.SlotDisplayContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.AbstractBannerBlock;
+import net.minecraft.world.level.block.BeaconBeamBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.material.MapColor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+import static java.util.Map.entry;
+
+// Powered by fabric-carpet(https://github.com/gnembon/fabric-carpet)
+
+public class HopperCounter {
+
+    private static boolean enabled = false;
+    private static final Map<DyeColor, HopperCounter> COUNTERS;
+
+    static {
+        EnumMap<DyeColor, HopperCounter> counterMap = new EnumMap<>(DyeColor.class);
+        for (DyeColor color : DyeColor.values()) {
+            counterMap.put(color, new HopperCounter(color));
+        }
+        COUNTERS = Collections.unmodifiableMap(counterMap);
+    }
+
+    public final DyeColor color;
+    private final TextComponent coloredName;
+    private final Object2LongMap<Item> counter = new Object2LongLinkedOpenHashMap<>();
+    private long startTick;
+    private long startMillis;
+
+    private HopperCounter(DyeColor color) {
+        this.startTick = -1;
+        this.color = color;
+        this.coloredName = Component.text(color.getName(), TextColor.color(color.getTextColor()));
+    }
+
+    public void add(Level level, ItemStack stack) {
+        if (startTick < 0) {
+            startTick = level.getGameTime();
+            startMillis = System.currentTimeMillis();
+        }
+        Item item = stack.getItem();
+        counter.put(item, counter.getLong(item) + stack.getCount());
+    }
+
+    public void reset(Level level) {
+        counter.clear();
+        startTick = level.getGameTime();
+        startMillis = System.currentTimeMillis();
+    }
+
+    public static void resetAll(Level level, boolean fresh) {
+        for (HopperCounter counter : COUNTERS.values()) {
+            counter.reset(level);
+            if (fresh) {
+                counter.startTick = -1;
+            }
+        }
+    }
+
+    public List<Component> format(MinecraftServer server, Level level, boolean realTime) {
+        long ticks = Math.max(realTime ? (System.currentTimeMillis() - startMillis) / 50 : level.getGameTime() - startTick, -1);
+
+        if (startTick < 0 || ticks == -1) {
+            return Collections.singletonList(Component.text().append(coloredName, Component.text(" hasn't started counting yet")).build());
+        }
+
+        long total = getTotalItems();
+        if (total <= 0) {
+            return Collections.singletonList(Component.text()
+                    .append(Component.text("No items for "), coloredName)
+                    .append(Component.text(" yet ("), Component.text(String.format("%.2f ", ticks / (20.0 * 60.0)), Style.style(TextDecoration.BOLD)))
+                    .append(Component.text("min"), Component.text(realTime ? " - real time" : ""), Component.text(")"))
+                    .build());
+        }
+
+        List<Component> items = new ArrayList<>();
+        items.add(Component.text()
+                .append(Component.text("Items for "), coloredName, Component.text(" "))
+                .append(Component.text("("), Component.text(String.format("%.2f ", ticks * 1.0 / (20 * 60)), Style.style(TextDecoration.BOLD)))
+                .append(Component.text("min"), Component.text(realTime ? " - real time" : ""), Component.text("), "))
+                .append(Component.text("total: "), Component.text(total, Style.style(TextDecoration.BOLD)), Component.text(", "))
+                .append(Component.text("("), Component.text(String.format("%.1f", total * 1.0 * (20 * 60 * 60) / ticks), Style.style(TextDecoration.BOLD)))
+                .append(Component.text("/h):"))
+                .build());
+
+        items.addAll(counter.object2LongEntrySet().stream().sorted((e, f) -> Long.compare(f.getLongValue(), e.getLongValue())).map(entry -> {
+            Item item = entry.getKey();
+            Component name = Component.translatable(item.getDescriptionId());
+            TextColor textColor = guessColor(server, item);
+
+            if (textColor != null) {
+                name = name.style(name.style().merge(Style.style(textColor)));
+            } else {
+                name = name.style(name.style().merge(Style.style(TextDecoration.ITALIC)));
+            }
+
+            long count = entry.getLongValue();
+            return Component.text()
+                    .append(Component.text("- ", NamedTextColor.GRAY))
+                    .append(name)
+                    .append(Component.text(": ", NamedTextColor.GRAY))
+                    .append(Component.text(count, Style.style(TextDecoration.BOLD)), Component.text(", ", NamedTextColor.GRAY))
+                    .append(Component.text(String.format("%.1f", count * (20.0 * 60.0 * 60.0) / ticks), Style.style(TextDecoration.BOLD)))
+                    .append(Component.text("/h"))
+                    .build();
+        }).toList());
+        return items;
+    }
+
+    private static final Map<Item, Block> DEFAULTS = Map.<Item, Block>ofEntries(
+            entry(Items.DANDELION, Blocks.YELLOW_WOOL),
+            entry(Items.POPPY, Blocks.RED_WOOL),
+            entry(Items.BLUE_ORCHID, Blocks.LIGHT_BLUE_WOOL),
+            entry(Items.ALLIUM, Blocks.MAGENTA_WOOL),
+            entry(Items.AZURE_BLUET, Blocks.SNOW_BLOCK),
+            entry(Items.RED_TULIP, Blocks.RED_WOOL),
+            entry(Items.ORANGE_TULIP, Blocks.ORANGE_WOOL),
+            entry(Items.WHITE_TULIP, Blocks.SNOW_BLOCK),
+            entry(Items.PINK_TULIP, Blocks.PINK_WOOL),
+            entry(Items.OXEYE_DAISY, Blocks.SNOW_BLOCK),
+            entry(Items.CORNFLOWER, Blocks.BLUE_WOOL),
+            entry(Items.WITHER_ROSE, Blocks.BLACK_WOOL),
+            entry(Items.LILY_OF_THE_VALLEY, Blocks.WHITE_WOOL),
+            entry(Items.BROWN_MUSHROOM, Blocks.BROWN_MUSHROOM_BLOCK),
+            entry(Items.RED_MUSHROOM, Blocks.RED_MUSHROOM_BLOCK),
+            entry(Items.STICK, Blocks.OAK_PLANKS),
+            entry(Items.GOLD_INGOT, Blocks.GOLD_BLOCK),
+            entry(Items.IRON_INGOT, Blocks.IRON_BLOCK),
+            entry(Items.DIAMOND, Blocks.DIAMOND_BLOCK),
+            entry(Items.NETHERITE_INGOT, Blocks.NETHERITE_BLOCK),
+            entry(Items.SUNFLOWER, Blocks.YELLOW_WOOL),
+            entry(Items.LILAC, Blocks.MAGENTA_WOOL),
+            entry(Items.ROSE_BUSH, Blocks.RED_WOOL),
+            entry(Items.PEONY, Blocks.PINK_WOOL),
+            entry(Items.CARROT, Blocks.ORANGE_WOOL),
+            entry(Items.APPLE, Blocks.RED_WOOL),
+            entry(Items.WHEAT, Blocks.HAY_BLOCK),
+            entry(Items.PORKCHOP, Blocks.PINK_WOOL),
+            entry(Items.RABBIT, Blocks.PINK_WOOL),
+            entry(Items.CHICKEN, Blocks.WHITE_TERRACOTTA),
+            entry(Items.BEEF, Blocks.NETHERRACK),
+            entry(Items.ENCHANTED_GOLDEN_APPLE, Blocks.GOLD_BLOCK),
+            entry(Items.COD, Blocks.WHITE_TERRACOTTA),
+            entry(Items.SALMON, Blocks.ACACIA_PLANKS),
+            entry(Items.ROTTEN_FLESH, Blocks.BROWN_WOOL),
+            entry(Items.PUFFERFISH, Blocks.YELLOW_TERRACOTTA),
+            entry(Items.TROPICAL_FISH, Blocks.ORANGE_WOOL),
+            entry(Items.POTATO, Blocks.WHITE_TERRACOTTA),
+            entry(Items.MUTTON, Blocks.RED_WOOL),
+            entry(Items.BEETROOT, Blocks.NETHERRACK),
+            entry(Items.MELON_SLICE, Blocks.MELON),
+            entry(Items.POISONOUS_POTATO, Blocks.SLIME_BLOCK),
+            entry(Items.SPIDER_EYE, Blocks.NETHERRACK),
+            entry(Items.GUNPOWDER, Blocks.GRAY_WOOL),
+            entry(Items.TURTLE_SCUTE, Blocks.LIME_WOOL),
+            entry(Items.ARMADILLO_SCUTE, Blocks.ANCIENT_DEBRIS),
+            entry(Items.FEATHER, Blocks.WHITE_WOOL),
+            entry(Items.FLINT, Blocks.BLACK_WOOL),
+            entry(Items.LEATHER, Blocks.SPRUCE_PLANKS),
+            entry(Items.GLOWSTONE_DUST, Blocks.GLOWSTONE),
+            entry(Items.PAPER, Blocks.WHITE_WOOL),
+            entry(Items.BRICK, Blocks.BRICKS),
+            entry(Items.INK_SAC, Blocks.BLACK_WOOL),
+            entry(Items.SNOWBALL, Blocks.SNOW_BLOCK),
+            entry(Items.WATER_BUCKET, Blocks.WATER),
+            entry(Items.LAVA_BUCKET, Blocks.LAVA),
+            entry(Items.MILK_BUCKET, Blocks.WHITE_WOOL),
+            entry(Items.CLAY_BALL, Blocks.CLAY),
+            entry(Items.COCOA_BEANS, Blocks.COCOA),
+            entry(Items.BONE, Blocks.BONE_BLOCK),
+            entry(Items.COD_BUCKET, Blocks.BROWN_TERRACOTTA),
+            entry(Items.PUFFERFISH_BUCKET, Blocks.YELLOW_TERRACOTTA),
+            entry(Items.SALMON_BUCKET, Blocks.PINK_TERRACOTTA),
+            entry(Items.TROPICAL_FISH_BUCKET, Blocks.ORANGE_TERRACOTTA),
+            entry(Items.SUGAR, Blocks.WHITE_WOOL),
+            entry(Items.BLAZE_POWDER, Blocks.GOLD_BLOCK),
+            entry(Items.ENDER_PEARL, Blocks.WARPED_PLANKS),
+            entry(Items.NETHER_STAR, Blocks.DIAMOND_BLOCK),
+            entry(Items.PRISMARINE_CRYSTALS, Blocks.SEA_LANTERN),
+            entry(Items.PRISMARINE_SHARD, Blocks.PRISMARINE),
+            entry(Items.RABBIT_HIDE, Blocks.OAK_PLANKS),
+            entry(Items.CHORUS_FRUIT, Blocks.PURPUR_BLOCK),
+            entry(Items.SHULKER_SHELL, Blocks.SHULKER_BOX),
+            entry(Items.NAUTILUS_SHELL, Blocks.BONE_BLOCK),
+            entry(Items.HEART_OF_THE_SEA, Blocks.CONDUIT),
+            entry(Items.HONEYCOMB, Blocks.HONEYCOMB_BLOCK),
+            entry(Items.NAME_TAG, Blocks.BONE_BLOCK),
+            entry(Items.TOTEM_OF_UNDYING, Blocks.YELLOW_TERRACOTTA),
+            entry(Items.TRIDENT, Blocks.PRISMARINE),
+            entry(Items.GHAST_TEAR, Blocks.WHITE_WOOL),
+            entry(Items.PHANTOM_MEMBRANE, Blocks.BONE_BLOCK),
+            entry(Items.EGG, Blocks.BONE_BLOCK),
+            entry(Items.COPPER_INGOT, Blocks.COPPER_BLOCK),
+            entry(Items.AMETHYST_SHARD, Blocks.AMETHYST_BLOCK)
+    );
+
+    @SuppressWarnings("deprecation")
+    @Nullable
+    public static TextColor guessColor(@NotNull MinecraftServer server, Item item) {
+        RegistryAccess registryAccess = server.registryAccess();
+        TextColor direct = fromItem(item, registryAccess);
+        if (direct != null) {
+            return direct;
+        }
+
+        ResourceLocation id = registryAccess.lookupOrThrow(Registries.ITEM).getKey(item);
+        if (id == null) {
+            return null;
+        }
+
+
+        for (Recipe<?> recipe : getRecipesForOutput(server.getRecipeManager(), id, server.overworld())) {
+            for (Ingredient ingredient : recipe.placementInfo().ingredients()) {
+                Optional<Holder<Item>> match = ingredient.items().filter(stack -> fromItem(stack.value(), registryAccess) != null).findFirst();
+                if (match.isPresent()) {
+                    return fromItem(match.get().value(), registryAccess);
+                }
+            }
+        }
+        return null;
+    }
+
+    @NotNull
+    public static List<Recipe<?>> getRecipesForOutput(@NotNull RecipeManager recipeManager, ResourceLocation id, Level level) {
+        List<Recipe<?>> results = new ArrayList<>();
+        ContextMap context = SlotDisplayContext.fromLevel(level);
+        recipeManager.getRecipes().forEach(recipe -> {
+            for (RecipeDisplay recipeDisplay : recipe.value().display()) {
+                recipeDisplay.result().resolveForStacks(context).forEach(stack -> {
+                    if (BuiltInRegistries.ITEM.wrapAsHolder(stack.getItem()).unwrapKey().map(ResourceKey::location).orElseThrow(IllegalStateException::new).equals(id)) {
+                        results.add(recipe.value());
+                    }
+                });
+            }
+        });
+        return results;
+    }
+
+    @Nullable
+    public static TextColor fromItem(Item item, RegistryAccess registryAccess) {
+        if (DEFAULTS.containsKey(item)) {
+            return TextColor.color(appropriateColor(DEFAULTS.get(item).defaultMapColor().col));
+        }
+        if (item instanceof DyeItem dye) {
+            return TextColor.color(appropriateColor(dye.getDyeColor().getMapColor().col));
+        }
+
+        Block block = null;
+        final Registry<Item> itemRegistry = registryAccess.lookupOrThrow(Registries.ITEM);
+        final Registry<Block> blockRegistry = registryAccess.lookupOrThrow(Registries.BLOCK);
+        ResourceLocation id = itemRegistry.getKey(item);
+        if (item instanceof BlockItem blockItem) {
+            block = blockItem.getBlock();
+        } else if (blockRegistry.getOptional(id).isPresent()) {
+            block = blockRegistry.getValue(id);
+        }
+
+        if (block != null) {
+            if (block instanceof AbstractBannerBlock) {
+                return TextColor.color(appropriateColor(((AbstractBannerBlock) block).getColor().getMapColor().col));
+            } else if (block instanceof BeaconBeamBlock) {
+                return TextColor.color(appropriateColor(((BeaconBeamBlock) block).getColor().getMapColor().col));
+            }
+            return TextColor.color(appropriateColor(block.defaultMapColor().col));
+        }
+        return null;
+    }
+
+    public static int appropriateColor(int color) {
+        if (color == 0) {
+            return MapColor.SNOW.col;
+        }
+        int r = (color >> 16 & 255);
+        int g = (color >> 8 & 255);
+        int b = (color & 255);
+        if (r < 70) {
+            r = 70;
+        }
+        if (g < 70) {
+            g = 70;
+        }
+        if (b < 70) {
+            b = 70;
+        }
+        return (r << 16) + (g << 8) + b;
+    }
+
+    public long getTotalItems() {
+        return counter.isEmpty() ? 0 : counter.values().longStream().sum();
+    }
+
+    public static HopperCounter getCounter(DyeColor color) {
+        return COUNTERS.get(color);
+    }
+
+    public static void setEnabled(boolean is) {
+        enabled = is;
+    }
+
+    public static boolean isEnabled() {
+        return WoolHopperCounterConfig.enabled && enabled;
+    }
+}

lophine-server/src/main/java/org/leavesmc/leaves/util/WoolUtils.java

@@ -0,0 +1,55 @@
+/*
+ * This file is part of Leaves (https://github.com/LeavesMC/Leaves)
+ *
+ * Leaves is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Leaves is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Leaves. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package org.leavesmc.leaves.util;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.item.DyeColor;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.Map;
+
+import static java.util.Map.entry;
+
+public class WoolUtils {
+    private static final Map<Block, DyeColor> WOOL_BLOCK_TO_DYE = Map.ofEntries(
+            entry(Blocks.WHITE_WOOL, DyeColor.WHITE),
+            entry(Blocks.ORANGE_WOOL, DyeColor.ORANGE),
+            entry(Blocks.MAGENTA_WOOL, DyeColor.MAGENTA),
+            entry(Blocks.LIGHT_BLUE_WOOL, DyeColor.LIGHT_BLUE),
+            entry(Blocks.YELLOW_WOOL, DyeColor.YELLOW),
+            entry(Blocks.LIME_WOOL, DyeColor.LIME),
+            entry(Blocks.PINK_WOOL, DyeColor.PINK),
+            entry(Blocks.GRAY_WOOL, DyeColor.GRAY),
+            entry(Blocks.LIGHT_GRAY_WOOL, DyeColor.LIGHT_GRAY),
+            entry(Blocks.CYAN_WOOL, DyeColor.CYAN),
+            entry(Blocks.PURPLE_WOOL, DyeColor.PURPLE),
+            entry(Blocks.BLUE_WOOL, DyeColor.BLUE),
+            entry(Blocks.BROWN_WOOL, DyeColor.BROWN),
+            entry(Blocks.GREEN_WOOL, DyeColor.GREEN),
+            entry(Blocks.RED_WOOL, DyeColor.RED),
+            entry(Blocks.BLACK_WOOL, DyeColor.BLACK)
+    );
+
+    public static DyeColor getWoolColorAtPosition(Level worldIn, BlockPos pos) {
+        BlockState state = worldIn.getBlockState(pos);
+        return WOOL_BLOCK_TO_DYE.get(state.getBlock());
+    }
+}