retire static TickSpeed. Use Server and Client synchronization agents.

src/main/java/carpet/mixins/BoundTickingBlockEntity_tickMixin.java

@@ -1,8 +1,9 @@
 package carpet.mixins;
 
+import carpet.fakes.ClientLevelInterface;
 import carpet.fakes.MinecraftServerInterface;
 import carpet.helpers.TickRateManager;
-import carpet.helpers.TickSpeed;
+import carpet.helpers.ServerTickRateManager;
 import carpet.utils.CarpetProfiler;
 import net.minecraft.core.BlockPos;
 import net.minecraft.server.level.ServerLevel;
@@ -37,14 +38,16 @@ public class BoundTickingBlockEntity_tickMixin<T extends BlockEntity>
     ))
     private void checkProcessBEs(BlockEntityTicker<T> blockEntityTicker, Level world, BlockPos pos, BlockState state, T blockEntity)
     {
+        // these two branches are identical, but we need to check the world type and inferfaces
         if (world.isClientSide()) {
             // client
-            if (TickSpeed.process_entitiesClient()) blockEntityTicker.tick(world, pos, state, blockEntity);
+            TickRateManager tickRateManager = ((ClientLevelInterface)world).getTickRateManager();
+            if (tickRateManager.runsNormally()) blockEntityTicker.tick(world, pos, state, blockEntity);
         } else {
             // server
             ServerLevel serverWorld = (ServerLevel) world;
-            TickRateManager tickRateManager = ((MinecraftServerInterface)serverWorld.getServer()).getTickRateManager();
-            if (tickRateManager.process_entities()) blockEntityTicker.tick(world, pos, state, blockEntity);
+            ServerTickRateManager serverTickRateManager = ((MinecraftServerInterface)serverWorld.getServer()).getTickRateManager();
+            if (serverTickRateManager.runsNormally()) blockEntityTicker.tick(world, pos, state, blockEntity);
         }
     }
 

src/main/java/carpet/mixins/ClientLevel_tickSpeedMixin.java

@@ -0,0 +1,28 @@
+package carpet.mixins;
+
+import carpet.fakes.ClientLevelInterface;
+import carpet.helpers.TickRateManager;
+import net.minecraft.client.multiplayer.ClientLevel;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ClientLevel.class)
+public class ClientLevel_tickSpeedMixin implements ClientLevelInterface
+{
+
+    private TickRateManager tickRateManager;
+
+    @Inject(method = "<init>", at = @At("RETURN"))
+    private void onInit(CallbackInfo ci)
+    {
+        this.tickRateManager = new TickRateManager();
+    }
+
+    @Override
+    public TickRateManager getTickRateManager()
+    {
+        return tickRateManager;
+    }
+}

src/main/java/carpet/mixins/ClientPacketListener_customPacketsMixin.java

@@ -1,6 +1,5 @@
 package carpet.mixins;
 
-import carpet.helpers.TickSpeed;
 import carpet.network.CarpetClient;
 import carpet.network.ClientNetworkHandler;
 import net.minecraft.client.Minecraft;
@@ -34,13 +33,11 @@ public abstract class ClientPacketListener_customPacketsMixin
     private void onGameJoined(ClientboundLoginPacket packet, CallbackInfo info)
     {
         CarpetClient.gameJoined(minecraft.player);
-        TickSpeed.resetClient();
     }
 
     @Inject(method = "onDisconnect", at = @At("HEAD"))
     private void onCMDisconnected(Component reason, CallbackInfo ci)
     {
         CarpetClient.disconnect();
-        TickSpeed.resetClient();
     }
 }

src/main/java/carpet/mixins/LevelRenderer_pausedShakeMixin.java

@@ -1,8 +1,10 @@
 package carpet.mixins;
 
+import carpet.fakes.ClientLevelInterface;
 import carpet.fakes.MinecraftClientInferface;
-import carpet.helpers.TickSpeed;
+import carpet.helpers.TickRateManager;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.renderer.LevelRenderer;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -15,6 +17,7 @@ public class LevelRenderer_pausedShakeMixin
 {
     @Shadow @Final private Minecraft minecraft;
 
+    @Shadow private ClientLevel level;
     float initial = -1234.0f;
 
     // require 0 is for optifine being a bitch as it usually is.
@@ -25,7 +28,8 @@ public class LevelRenderer_pausedShakeMixin
     private float changeTickPhase(float previous)
     {
         initial = previous;
-        if (!TickSpeed.process_entitiesClient())
+        TickRateManager trm = ((ClientLevelInterface)level).getTickRateManager();
+        if (!trm.runsNormally())
             return ((MinecraftClientInferface)minecraft).getPausedTickDelta();
         return previous;
     }

src/main/java/carpet/mixins/Level_tickMixin.java

@@ -1,10 +1,12 @@
 package carpet.mixins;
 
+import carpet.fakes.ClientLevelInterface;
 import carpet.fakes.LevelInterface;
 import carpet.fakes.MinecraftServerInterface;
 import carpet.helpers.TickRateManager;
-import carpet.helpers.TickSpeed;
+import carpet.helpers.ServerTickRateManager;
 import carpet.utils.CarpetProfiler;
+import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.level.redstone.NeighborUpdater;
 import org.spongepowered.asm.mixin.Final;
@@ -53,55 +55,26 @@ public abstract class Level_tickMixin implements LevelInterface
     private void endBlockEntities(CallbackInfo ci) {
         CarpetProfiler.end_current_section(currentSection);
     }
-/*
-    @Inject(method = "tickBlockEntities", locals = LocalCapture.CAPTURE_FAILHARD, at = @At(
-            value = "INVOKE",
-            target = "Lnet/minecraft/class_5562;method_31704()Z",
-            shift = At.Shift.BEFORE,
-            ordinal = 0
-    ))
-    private void startTileEntitySection(CallbackInfo ci, Profiler profiler_1, Iterator i, class_5562 lv)
-    {
-        entitySection = CarpetProfiler.start_block_entity_section((World)(Object)this, (BlockEntity) lv, CarpetProfiler.TYPE.TILEENTITY);
-    }
 
-    @Redirect(method = "tickBlockEntities", at = @At(
-            value = "INVOKE",
-            target = "Lnet/minecraft/class_5562;method_31704()Z",
-            ordinal = 0
-    ))   // isRemoved()
-    private boolean checkProcessTEs(class_5562 class_5562)
-    {
-        return class_5562.method_31704() || !TickSpeed.process_entities; // blockEntity can be NULL? happened once with fake player
-    }
-
-    @Inject(method = "tickBlockEntities", at = @At(
-            value = "INVOKE",
-            target = "Lnet/minecraft/class_5562;method_31703()V",
-            shift = At.Shift.AFTER,
-            ordinal = 0
-    ))
-    private void endTileEntitySection(CallbackInfo ci)
-    {
-         CarpetProfiler.end_current_entity_section(entitySection);
-    }
-*/
     @Inject(method = "guardEntityTick", at = @At("HEAD"), cancellable = true)
     private void startEntity(Consumer<Entity> consumer_1, Entity e, CallbackInfo ci)
     {
         // this shows that probably tick speed controller needs to be accessible through level referring to servers on server and client on clientLevel
+        // these two branches could also be merged into one generic for cloent and server
         if (!isClientSide)
         {
             ServerLevel serverLevel = (ServerLevel) (Object) this;
-            TickRateManager trm = ((MinecraftServerInterface)serverLevel.getServer()).getTickRateManager();
-            if (!(trm.process_entities() || (e instanceof Player)))
+            ServerTickRateManager trm = ((MinecraftServerInterface)serverLevel.getServer()).getTickRateManager();
+            if (!(trm.runsNormally() || (e instanceof Player)))
             {
                 ci.cancel();
             }
         }
         else
         {
-            if (!(TickSpeed.process_entitiesClient() || (e instanceof Player) || TickSpeed.isIs_superHotClient() && e.getControllingPassenger() instanceof Player))
+            ClientLevel clientLevel = (ClientLevel) (Object) this;
+            TickRateManager trm = ((ClientLevelInterface)clientLevel).getTickRateManager();
+            if (!(trm.runsNormally() || (e instanceof Player) || trm.isSuperHot() && e.getControllingPassenger() instanceof Player))
             {
                 ci.cancel();
             }

src/main/java/carpet/mixins/MinecraftMixin.java

@@ -1,7 +1,9 @@
 package carpet.mixins;
 
 import carpet.CarpetServer;
-import carpet.helpers.TickSpeed;
+import carpet.fakes.ClientLevelInterface;
+import carpet.helpers.TickRateManager;
+import carpet.fakes.MinecraftInterface;
 import carpet.network.CarpetClient;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.screens.Screen;
@@ -12,8 +14,10 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.util.Optional;
+
 @Mixin(Minecraft.class)
-public class MinecraftMixin
+public class MinecraftMixin implements MinecraftInterface
 {
     @Shadow public ClientLevel level;
     
@@ -26,16 +30,19 @@ public class MinecraftMixin
     @Inject(at = @At("HEAD"), method = "tick")
     private void onClientTick(CallbackInfo info) {
         if (this.level != null) {
-            TickSpeed.tickClient();
-            if (CarpetServer.minecraft_server == null) // remote client only ? no - now any client
-            {
-
-            } else {
-                // hmm, server should tick, rgiht?
-                //TickSpeed.tick();
-            }
-            if (!TickSpeed.process_entitiesClient())
+            getTickRateManager().ifPresent(TickRateManager::tick);
+            // hope server doesn't need to tick - should be handled by the server on its own
+            if (!getTickRateManager().map(TickRateManager::runsNormally).orElse(true))
                 CarpetClient.shapes.renewShapes();
         }
     }
+
+    @Override
+    public Optional<TickRateManager> getTickRateManager()
+    {
+        if (this.level != null) {
+            return Optional.of(((ClientLevelInterface)this.level).getTickRateManager());
+        }
+        return Optional.empty();
+    }
 }

src/main/java/carpet/mixins/MinecraftServer_scarpetMixin.java

@@ -88,7 +88,7 @@ public abstract class MinecraftServer_scarpetMixin extends ReentrantBlockableEve
     ))
     public void tickTasks(BooleanSupplier booleanSupplier_1, CallbackInfo ci)
     {
-        if (!getTickRateManager().process_entities())
+        if (!getTickRateManager().runsNormally())
         {
             return;
         }

src/main/java/carpet/mixins/MinecraftServer_tickspeedMixin.java

@@ -1,8 +1,7 @@
 package carpet.mixins;
 
 import carpet.fakes.MinecraftServerInterface;
-import carpet.helpers.TickRateManager;
-import carpet.helpers.TickSpeed;
+import carpet.helpers.ServerTickRateManager;
 import carpet.patches.CopyProfilerResult;
 import carpet.utils.CarpetProfiler;
 import net.minecraft.Util;
@@ -69,18 +68,18 @@ public abstract class MinecraftServer_tickspeedMixin extends ReentrantBlockableE
 
     private float carpetMsptAccum = 0.0f;
 
-    private TickRateManager tickRateManager;
+    private ServerTickRateManager serverTickRateManager;
 
     @Inject(method = "<init>", at = @At("RETURN"))
     private void onInit(CallbackInfo ci)
     {
-        tickRateManager = new TickRateManager((MinecraftServer)(Object)this);
+        serverTickRateManager = new ServerTickRateManager((MinecraftServer)(Object)this);
     }
 
     @Override
-    public TickRateManager getTickRateManager()
+    public ServerTickRateManager getTickRateManager()
     {
-        return tickRateManager;
+        return serverTickRateManager;
     }
 
     /**
@@ -111,8 +110,8 @@ public abstract class MinecraftServer_tickspeedMixin extends ReentrantBlockableE
             }
             long msThisTick = 0L;
             long long_1 = 0L;
-            float mspt = tickRateManager.mspt;
-            if (tickRateManager.time_warp_start_time != 0 && tickRateManager.continueWarp())
+            float mspt = serverTickRateManager.mspt();
+            if (serverTickRateManager.isInWarpSpeed() && serverTickRateManager.continueWarp())
             {
                 //making sure server won't flop after the warp or if the warp is interrupted
                 this.nextTickTime = this.lastOverloadWarning = Util.getMillis();
@@ -151,9 +150,9 @@ public abstract class MinecraftServer_tickspeedMixin extends ReentrantBlockableE
             //this.startMonitor(tickDurationMonitor);
             this.startMetricsRecordingTick();
             this.profiler.push("tick");
-            this.tickServer(tickRateManager.time_warp_start_time != 0 ? ()->true : this::haveTime);
+            this.tickServer(serverTickRateManager.isInWarpSpeed() ? ()->true : this::haveTime);
             this.profiler.popPush("nextTickWait");
-            if (tickRateManager.time_warp_start_time != 0) // clearing all hanging tasks no matter what when warping
+            if (serverTickRateManager.isInWarpSpeed()) // clearing all hanging tasks no matter what when warping
             {
                 while(this.runEveryTask()) {Thread.yield();}
             }

src/main/java/carpet/mixins/ServerChunkCache_tickMixin.java

@@ -2,7 +2,7 @@ package carpet.mixins;
 
 import carpet.fakes.MinecraftServerInterface;
 import carpet.fakes.ThreadedAnvilChunkStorageInterface;
-import carpet.helpers.TickRateManager;
+import carpet.helpers.ServerTickRateManager;
 import carpet.utils.CarpetProfiler;
 import net.minecraft.server.level.DistanceManager;
 import org.spongepowered.asm.mixin.Final;
@@ -80,7 +80,7 @@ public abstract class ServerChunkCache_tickMixin
     private boolean skipChunkTicking(ServerLevel serverWorld)
     {
         boolean debug = serverWorld.isDebug();
-        if (!((MinecraftServerInterface)serverWorld.getServer()).getTickRateManager().process_entities())
+        if (!((MinecraftServerInterface)serverWorld.getServer()).getTickRateManager().runsNormally())
         {
             // simplified chunk tick iteration assuming world is frozen otherwise as suggested by Hadron67
             // to be kept in sync with the original injection source
@@ -107,8 +107,8 @@ public abstract class ServerChunkCache_tickMixin
     {
         // pausing expiry of tickets
         // that will prevent also chunks from unloading, so require a deep frozen state
-        TickRateManager trm = ((MinecraftServerInterface) level.getServer()).getTickRateManager();
-        if (!trm.process_entities() && trm.deeplyFrozen()) return;
+        ServerTickRateManager trm = ((MinecraftServerInterface) level.getServer()).getTickRateManager();
+        if (!trm.runsNormally() && trm.deeplyFrozen()) return;
         distanceManager.purgeStaleTickets();
     }
 

src/main/java/carpet/mixins/ServerFunctionManager_tickMixin.java

@@ -20,7 +20,7 @@ public class ServerFunctionManager_tickMixin
     @Inject(method = "tick", at = @At("HEAD"), cancellable = true)
     private void beforeDatapacks(CallbackInfo ci)
     {
-    	if (! ((MinecraftServerInterface)server).getTickRateManager().process_entities())
+    	if (! ((MinecraftServerInterface)server).getTickRateManager().runsNormally())
         {
             ci.cancel();
         }

src/main/java/carpet/mixins/ServerGamePacketListenerImpl_tickMixin.java

@@ -27,7 +27,7 @@ public class ServerGamePacketListenerImpl_tickMixin
     {
         if (p.getXxa() != 0.0F || p.getZza() != 0.0F || p.isJumping() || p.isShiftKeyDown())
         {
-            ((MinecraftServerInterface)player.getServer()).getTickRateManager().reset_player_active_timeout();
+            ((MinecraftServerInterface)player.getServer()).getTickRateManager().resetPlayerActivity();
         }
     }
 
@@ -53,7 +53,7 @@ public class ServerGamePacketListenerImpl_tickMixin
         {
             lastMoved = movedBy;
             lastMovedTick = player.getServer().getTickCount();
-            ((MinecraftServerInterface)player.getServer()).getTickRateManager().reset_player_active_timeout();
+            ((MinecraftServerInterface)player.getServer()).getTickRateManager().resetPlayerActivity();
         }
     }
 }

src/main/java/carpet/mixins/ServerLevel_tickMixin.java

@@ -159,13 +159,13 @@ public abstract class ServerLevel_tickMixin extends Level
     ))
     private void tickWorldBorder(WorldBorder worldBorder)
     {
-        if (((MinecraftServerInterface)getServer()).getTickRateManager().process_entities()) worldBorder.tick();
+        if (((MinecraftServerInterface)getServer()).getTickRateManager().runsNormally()) worldBorder.tick();
     }
 
     @Inject(method = "advanceWeatherCycle", cancellable = true, at = @At("HEAD"))
     private void tickWeather(CallbackInfo ci)
     {
-        if (!((MinecraftServerInterface)getServer()).getTickRateManager().process_entities()) ci.cancel();
+        if (!((MinecraftServerInterface)getServer()).getTickRateManager().runsNormally()) ci.cancel();
     }
 
     @Redirect(method = "tick", at = @At(
@@ -174,7 +174,7 @@ public abstract class ServerLevel_tickMixin extends Level
     ))
     private void tickTimeConditionally(ServerLevel serverWorld)
     {
-        if (((MinecraftServerInterface)getServer()).getTickRateManager().process_entities()) tickTime();
+        if (((MinecraftServerInterface)getServer()).getTickRateManager().runsNormally()) tickTime();
     }
 
     @Redirect(method = "tick", at = @At(
@@ -183,7 +183,7 @@ public abstract class ServerLevel_tickMixin extends Level
     ))
     private boolean tickPendingBlocks(ServerLevel serverWorld)
     {
-        if (!((MinecraftServerInterface)getServer()).getTickRateManager().process_entities()) return true;
+        if (!((MinecraftServerInterface)getServer()).getTickRateManager().runsNormally()) return true;
         return serverWorld.isDebug(); // isDebug()
     }
 
@@ -193,7 +193,7 @@ public abstract class ServerLevel_tickMixin extends Level
     ))
     private void tickConditionally(Raids raidManager)
     {
-        if (((MinecraftServerInterface)getServer()).getTickRateManager().process_entities()) raidManager.tick();
+        if (((MinecraftServerInterface)getServer()).getTickRateManager().runsNormally()) raidManager.tick();
     }
 
     @Redirect(method = "tick", at = @At(
@@ -202,6 +202,6 @@ public abstract class ServerLevel_tickMixin extends Level
     ))
     private void tickConditionally(ServerLevel serverWorld)
     {
-        if (((MinecraftServerInterface)getServer()).getTickRateManager().process_entities()) runBlockEvents();
+        if (((MinecraftServerInterface)getServer()).getTickRateManager().runsNormally()) runBlockEvents();
     }
 }

src/main/java/carpet/mixins/Timer_tickSpeedMixin.java

@@ -1,12 +1,16 @@
 package carpet.mixins;
 
-import carpet.helpers.TickSpeed;
+import carpet.fakes.MinecraftInterface;
+import carpet.helpers.TickRateManager;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.Timer;
 import carpet.CarpetSettings;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
 
+import java.util.Optional;
+
 @Mixin(Timer.class)
 public class Timer_tickSpeedMixin {
     @Redirect(method = "advanceTime", at = @At(
@@ -14,9 +18,13 @@ public class Timer_tickSpeedMixin {
             target = "Lnet/minecraft/client/Timer;msPerTick:F"
     ))
     private float adjustTickSpeed(Timer counter) {
-        if (CarpetSettings.smoothClientAnimations && TickSpeed.process_entitiesClient())
+        if (CarpetSettings.smoothClientAnimations)
         {
-            return Math.max(50.0f, TickSpeed.msptClient());
+            Optional<TickRateManager> trm = ((MinecraftInterface)Minecraft.getInstance()).getTickRateManager();
+            if (trm.isPresent() && trm.get().runsNormally())
+            {
+                return Math.max(50.0f, trm.get().mspt());
+            }
         }
         return 50f;
     }