Cleanup BauSystem

2026-05-15 11:27:34 +02:00
parent bd471330e1
commit fd266969f5
52 changed files with 512 additions and 2428 deletions
@@ -19,28 +19,119 @@

 package de.steamwar.bausystem.utils;

+import com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.Reflection;
 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.core.VersionDependent;
+import net.minecraft.network.protocol.game.ClientboundTickingStatePacket;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.ServerTickRateManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;

-public interface TickManager extends Listener {
-    TickManager impl = VersionDependent.getVersionImpl(BauSystem.getInstance());
+public class TickManager implements Listener {
+    public static final TickManager impl = new TickManager();

-    void setTickRate(float tickRate);
-    float getTickRate();
+    private static final ServerTickRateManager manager = MinecraftServer.getServer().tickRateManager();
+    private static final Reflection.Field<Long> remainingSprintTicks = Reflection.getField(ServerTickRateManager.class, long.class, 0);

-    boolean canFreeze();
-    void setFreeze(boolean freeze);
-    boolean isFrozen();
+    private boolean blockTpsPacket = true;
+    private int totalSteps;

-    void stepTicks(int ticks);
-    boolean isStepping();
+    private TickManager() {
+        TinyProtocol.instance.addFilter(ClientboundTickingStatePacket.class, this::blockPacket);
+    }

-    void sprintTicks(int ticks);
-    boolean isSprinting();
+    private Object blockPacket(Player player, Object packet) {
+        if (blockTpsPacket) {
+            return new ClientboundTickingStatePacket(20, manager.isFrozen());
+        } else {
+            return packet;
+        }
+    }

-    void setBlockTpsPacket(boolean block);
-    long getRemainingTicks();
-    long getDoneTicks();
-    long getTotalTicks();
+    public boolean canFreeze() {
+        return true;
+    }
+
+    public void setBlockTpsPacket(boolean block) {
+        blockTpsPacket = block;
+        if (blockTpsPacket) {
+            ClientboundTickingStatePacket packet = new ClientboundTickingStatePacket(20, manager.isFrozen());
+            Bukkit.getOnlinePlayers().forEach(player -> TinyProtocol.instance.sendPacket(player, packet));
+        } else {
+            ClientboundTickingStatePacket packet = new ClientboundTickingStatePacket(manager.tickrate(), manager.isFrozen());
+            Bukkit.getOnlinePlayers().forEach(player -> TinyProtocol.instance.sendPacket(player, packet));
+        }
+    }
+
+    public void setTickRate(float tickRate) {
+        if (isFrozen()) {
+            setFreeze(false);
+        }
+        manager.setTickRate(tickRate);
+    }
+
+    public boolean isFrozen() {
+        return manager.isFrozen();
+    }
+
+    public void setFreeze(boolean freeze) {
+        manager.setFrozen(freeze);
+    }
+
+    public void stepTicks(int ticks) {
+        if (manager.isSprinting()) {
+            manager.stopSprinting();
+        } else if (manager.isSteppingForward()) {
+            manager.stopStepping();
+        }
+        this.totalSteps = ticks;
+        manager.setFrozen(true);
+        manager.stepGameIfPaused(ticks);
+        manager.setFrozen(false);
+        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), (bukkitTask) -> {
+            if (manager.isSteppingForward()) return;
+            manager.setFrozen(true);
+            bukkitTask.cancel();
+        }, 1, 1);
+    }
+
+    public void sprintTicks(int ticks) {
+        if (manager.isSteppingForward()) {
+            manager.stopStepping();
+        } else if (manager.isSprinting()) {
+            manager.stopSprinting();
+        }
+        this.totalSteps = ticks;
+        manager.requestGameToSprint(ticks, true);
+    }
+
+    public boolean isSprinting() {
+        return manager.isSprinting();
+    }
+
+    public boolean isStepping() {
+        return manager.isSteppingForward();
+    }
+
+    public float getTickRate() {
+        return manager.tickrate();
+    }
+
+    public long getRemainingTicks() {
+        if (isSprinting()) {
+            return remainingSprintTicks.get(manager);
+        } else {
+            return manager.frozenTicksToRun();
+        }
+    }
+
+    public long getDoneTicks() {
+        return totalSteps - getRemainingTicks();
+    }
+
+    public long getTotalTicks() {
+        return totalSteps;
+    }
 }