retire static TickSpeed. Use Server and Client synchronization agents.

src/main/java/carpet/helpers/ServerTickRateManager.java

@@ -0,0 +1,246 @@
+package carpet.helpers;
+
+import carpet.CarpetServer;
+import carpet.network.ServerNetworkHandler;
+import carpet.utils.Messenger;
+import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+public class ServerTickRateManager extends TickRateManager
+{
+    private long remainingWarpTicks = 0;
+    private long tickWarpStartTime = 0;
+    private long scheduledCurrentWarpTicks = 0;
+    private ServerPlayer warpResponsiblePlayer = null;
+    private String tickWarpCallback = null;
+    private CommandSourceStack warpResponsibleSource = null;
+
+    private MinecraftServer server;
+
+    public ServerTickRateManager(MinecraftServer server) {
+        this.server = server;
+    }
+
+    public boolean isInWarpSpeed()
+    {
+        return tickWarpStartTime != 0;
+    }
+
+    /**
+     * Whether or not the game is deeply frozen.
+     * This can be used for things that you may not normally want
+     * to freeze, but may need to in some situations.
+     * This should be checked with {@link #runGameElements} to make sure the
+     * current tick is actually frozen, not only the game
+     *
+     * @return Whether or not the game is deeply frozen.
+     */
+    public boolean deeplyFrozen()
+    {
+        return deepFreeze;
+    }
+
+    /**
+     * Used to update the frozen state of the game.
+     * Handles connected clients as well.
+     *
+     * @param isPaused     Whether or not the game is paused
+     * @param isDeepFreeze Whether or not the game is deeply frozen
+     */
+    @Override
+    public void setFrozenState(boolean isPaused, boolean isDeepFreeze)
+    {
+        super.setFrozenState(isPaused, isDeepFreeze);
+        ServerNetworkHandler.updateFrozenStateToConnectedPlayers(server);
+    }
+
+
+    public void resetPlayerActivity()
+    {
+        if (playerActivityTimeout < PLAYER_GRACE)
+        {
+            playerActivityTimeout = PLAYER_GRACE;
+            ServerNetworkHandler.updateTickPlayerActiveTimeoutToConnectedPlayers(server);
+        }
+    }
+
+    public void stepGameIfPaused(int ticks)
+    {
+        playerActivityTimeout = PLAYER_GRACE + ticks;
+        ServerNetworkHandler.updateTickPlayerActiveTimeoutToConnectedPlayers(server);
+    }
+
+    public Component requestGameToWarpSpeed(ServerPlayer player, int advance, String callback, CommandSourceStack source)
+    {
+        if (0 == advance)
+        {
+            tickWarpCallback = null;
+            if (source != warpResponsibleSource)
+            {
+                warpResponsibleSource = null;
+            }
+            if (remainingWarpTicks > 0)
+            {
+                finishTickWarp();
+                warpResponsibleSource = null;
+                return Messenger.c("gi Warp interrupted");
+            }
+            return Messenger.c("ri No warp in progress");
+        }
+        if (remainingWarpTicks > 0)
+        {
+            String who = "Another player";
+            if (warpResponsiblePlayer != null)
+            {
+                who = warpResponsiblePlayer.getScoreboardName();
+            }
+            return Messenger.c("l " + who + " is already advancing time at the moment. Try later or ask them");
+        }
+        warpResponsiblePlayer = player;
+        tickWarpStartTime = System.nanoTime();
+        scheduledCurrentWarpTicks = advance;
+        remainingWarpTicks = advance;
+        tickWarpCallback = callback;
+        warpResponsibleSource = source;
+        return Messenger.c("gi Warp speed ....");
+    }
+
+    // should be private
+    public void finishTickWarp()
+    {
+
+        long completed_ticks = scheduledCurrentWarpTicks - remainingWarpTicks;
+        double milis_to_complete = System.nanoTime() - tickWarpStartTime;
+        if (milis_to_complete == 0.0)
+        {
+            milis_to_complete = 1.0;
+        }
+        milis_to_complete /= 1000000.0;
+        int tps = (int) (1000.0D * completed_ticks / milis_to_complete);
+        double mspt = (1.0 * milis_to_complete) / completed_ticks;
+        scheduledCurrentWarpTicks = 0;
+        tickWarpStartTime = 0;
+        if (tickWarpCallback != null)
+        {
+            Commands icommandmanager = warpResponsibleSource.getServer().getCommands();
+            try
+            {
+                icommandmanager.performPrefixedCommand(warpResponsibleSource, tickWarpCallback);
+            }
+            catch (Throwable var23)
+            {
+                if (warpResponsiblePlayer != null)
+                {
+                    Messenger.m(warpResponsiblePlayer, "r Command Callback failed - unknown error: ", "rb /" + tickWarpCallback, "/" + tickWarpCallback);
+                }
+            }
+            tickWarpCallback = null;
+            warpResponsibleSource = null;
+        }
+        if (warpResponsiblePlayer != null)
+        {
+            Messenger.m(warpResponsiblePlayer, String.format("gi ... Time warp completed with %d tps, or %.2f mspt", tps, mspt));
+            warpResponsiblePlayer = null;
+        }
+        else
+        {
+            Messenger.print_server_message(CarpetServer.minecraft_server, String.format("... Time warp completed with %d tps, or %.2f mspt", tps, mspt));
+        }
+        remainingWarpTicks = 0;
+
+    }
+
+    public boolean continueWarp()
+    {
+        if (!runGameElements)
+        // Returning false so we don't have to run at max speed when doing nothing
+        {
+            return false;
+        }
+        if (remainingWarpTicks > 0)
+        {
+            if (remainingWarpTicks == scheduledCurrentWarpTicks) //first call after previous tick, adjust start time
+            {
+                tickWarpStartTime = System.nanoTime();
+            }
+            remainingWarpTicks -= 1;
+            return true;
+        }
+        else
+        {
+            finishTickWarp();
+            return false;
+        }
+    }
+
+    /**
+     * Functional interface that listens for tickrate changes. This is
+     * implemented to allow tickrate compatibility with other mods etc.
+     */
+    private final Map<String, BiConsumer<String, Float>> tickrateListeners = new HashMap<>();
+    private static final float MIN_TICKRATE = 0.01f;
+
+    //unused - mod compat reasons
+    @Override
+    public void setTickRate(float rate)
+    {
+        setTickRate(rate, true);
+    }
+
+    public void setTickRate(float rate, boolean update)
+    {
+        super.setTickRate(rate);
+        if (update)
+        {
+            notifyTickrateListeners("carpet");
+        }
+    }
+
+    private void tickrateChanged(String modId, float rate)
+    {
+        // Other mods might change the tickrate in a slightly
+        // different way. Also allow for tickrates that don't
+        // divide into 1000 here.
+
+        if (rate < MIN_TICKRATE)
+        {
+            rate = MIN_TICKRATE;
+        }
+
+        tickrate = rate;
+        mspt = 1000.0f / tickrate;
+
+        notifyTickrateListeners(modId);
+    }
+
+    private void notifyTickrateListeners(String originModId)
+    {
+        synchronized (tickrateListeners)
+        {
+            for (Map.Entry<String, BiConsumer<String, Float>> listenerEntry : tickrateListeners.entrySet())
+            {
+                if (originModId == null || !originModId.equals(listenerEntry.getKey()))
+                {
+                    listenerEntry.getValue().accept(originModId, tickrate);
+                }
+            }
+        }
+        ServerNetworkHandler.updateTickSpeedToConnectedPlayers(server);
+    }
+
+    public BiConsumer<String, Float> addTickrateListener(String modId, BiConsumer<String, Float> tickrateListener)
+    {
+        synchronized (tickrateListeners)
+        {
+            tickrateListeners.put(modId, tickrateListener);
+        }
+        return this::tickrateChanged;
+    }
+}

src/main/java/carpet/helpers/TickRateManager.java

@@ -1,237 +1,18 @@
 package carpet.helpers;
 
-import carpet.CarpetServer;
-import carpet.network.ServerNetworkHandler;
-import carpet.utils.Messenger;
-import net.minecraft.commands.CommandSourceStack;
-import net.minecraft.commands.Commands;
-import net.minecraft.network.chat.Component;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerPlayer;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.BiConsumer;
-
 public class TickRateManager
 {
     public static final int PLAYER_GRACE = 2;
-    public float tickrate = 20.0f;
-    public float mspt = 50.0f;
-    public long time_bias = 0;
-    public long time_warp_start_time = 0;
-    public long time_warp_scheduled_ticks = 0;
-    public ServerPlayer time_advancerer = null;
-    public String tick_warp_callback = null;
-    public CommandSourceStack tick_warp_sender = null;
-    public int player_active_timeout = 0;
-    public boolean process_entities = true;
-    private boolean deepFreeze = false;
-    private boolean is_paused = false;
-    public boolean is_superHot = false;
+    protected float tickrate = 20.0f;
+    protected float mspt = 50.0f;
+    protected int playerActivityTimeout = 0;
+    protected boolean runGameElements = true;
+    // deep freeze is onlyu used serverside
+    protected boolean deepFreeze = false;
+    protected boolean isGamePaused = false;
+    protected boolean isSuperHot = false;
 
-    private MinecraftServer server;
-
-    public TickRateManager(MinecraftServer server) {
-        this.server = server;
-    }
-
-
-    /**
-     * @return Whether or not the game is in a frozen state.
-     * You should normally use {@link #process_entities} instead,
-     * since that one accounts for tick steps and superhot
-     */
-    public boolean isPaused()
-    {
-        return is_paused;
-    }
-
-    public boolean process_entities()
-    {
-        return process_entities;
-    }
-
-    /**
-     * Whether or not the game is deeply frozen.
-     * This can be used for things that you may not normally want
-     * to freeze, but may need to in some situations.
-     * This should be checked with {@link #process_entities} to make sure the
-     * current tick is actually frozen, not only the game
-     *
-     * @return Whether or not the game is deeply frozen.
-     */
-    public boolean deeplyFrozen()
-    {
-        return deepFreeze;
-    }
-
-    /**
-     * Used to update the frozen state of the game.
-     * Handles connected clients as well.
-     *
-     * @param isPaused     Whether or not the game is paused
-     * @param isDeepFreeze Whether or not the game is deeply frozen
-     */
-    public void setFrozenState(boolean isPaused, boolean isDeepFreeze)
-    {
-        is_paused = isPaused;
-        deepFreeze = isPaused ? isDeepFreeze : false;
-        ServerNetworkHandler.updateFrozenStateToConnectedPlayers(server);
-    }
-
-
-    public void reset_player_active_timeout()
-    {
-        if (player_active_timeout < PLAYER_GRACE)
-        {
-            player_active_timeout = PLAYER_GRACE;
-            ServerNetworkHandler.updateTickPlayerActiveTimeoutToConnectedPlayers(server);
-        }
-    }
-
-    public void add_ticks_to_run_in_pause(int ticks)
-    {
-        player_active_timeout = PLAYER_GRACE + ticks;
-        ServerNetworkHandler.updateTickPlayerActiveTimeoutToConnectedPlayers(server);
-    }
-
-    public Component tickrate_advance(ServerPlayer player, int advance, String callback, CommandSourceStack source)
-    {
-        if (0 == advance)
-        {
-            tick_warp_callback = null;
-            if (source != tick_warp_sender)
-            {
-                tick_warp_sender = null;
-            }
-            if (time_bias > 0)
-            {
-                finish_time_warp();
-                tick_warp_sender = null;
-                return Messenger.c("gi Warp interrupted");
-            }
-            return Messenger.c("ri No warp in progress");
-        }
-        if (time_bias > 0)
-        {
-            String who = "Another player";
-            if (time_advancerer != null)
-            {
-                who = time_advancerer.getScoreboardName();
-            }
-            return Messenger.c("l " + who + " is already advancing time at the moment. Try later or ask them");
-        }
-        time_advancerer = player;
-        time_warp_start_time = System.nanoTime();
-        time_warp_scheduled_ticks = advance;
-        time_bias = advance;
-        tick_warp_callback = callback;
-        tick_warp_sender = source;
-        return Messenger.c("gi Warp speed ....");
-    }
-
-    public void finish_time_warp()
-    {
-
-        long completed_ticks = time_warp_scheduled_ticks - time_bias;
-        double milis_to_complete = System.nanoTime() - time_warp_start_time;
-        if (milis_to_complete == 0.0)
-        {
-            milis_to_complete = 1.0;
-        }
-        milis_to_complete /= 1000000.0;
-        int tps = (int) (1000.0D * completed_ticks / milis_to_complete);
-        double mspt = (1.0 * milis_to_complete) / completed_ticks;
-        time_warp_scheduled_ticks = 0;
-        time_warp_start_time = 0;
-        if (tick_warp_callback != null)
-        {
-            Commands icommandmanager = tick_warp_sender.getServer().getCommands();
-            try
-            {
-                icommandmanager.performPrefixedCommand(tick_warp_sender, tick_warp_callback);
-            }
-            catch (Throwable var23)
-            {
-                if (time_advancerer != null)
-                {
-                    Messenger.m(time_advancerer, "r Command Callback failed - unknown error: ", "rb /" + tick_warp_callback, "/" + tick_warp_callback);
-                }
-            }
-            tick_warp_callback = null;
-            tick_warp_sender = null;
-        }
-        if (time_advancerer != null)
-        {
-            Messenger.m(time_advancerer, String.format("gi ... Time warp completed with %d tps, or %.2f mspt", tps, mspt));
-            time_advancerer = null;
-        }
-        else
-        {
-            Messenger.print_server_message(CarpetServer.minecraft_server, String.format("... Time warp completed with %d tps, or %.2f mspt", tps, mspt));
-        }
-        time_bias = 0;
-
-    }
-
-    public boolean continueWarp()
-    {
-        if (!process_entities)
-        // Returning false so we don't have to run at max speed when doing nothing
-        {
-            return false;
-        }
-        if (time_bias > 0)
-        {
-            if (time_bias == time_warp_scheduled_ticks) //first call after previous tick, adjust start time
-            {
-                time_warp_start_time = System.nanoTime();
-            }
-            time_bias -= 1;
-            return true;
-        }
-        else
-        {
-            finish_time_warp();
-            return false;
-        }
-    }
-
-    public void tick()
-    {
-        if (player_active_timeout > 0)
-        {
-            player_active_timeout--;
-        }
-        if (is_paused)
-        {
-            process_entities = player_active_timeout >= PLAYER_GRACE;
-        }
-        else if (is_superHot)
-        {
-            process_entities = player_active_timeout > 0;
-        }
-        else
-        {
-            process_entities = true;
-        }
-    }
-
-    /**
-     * Functional interface that listens for tickrate changes. This is
-     * implemented to allow tickrate compatibility with other mods etc.
-     */
-    private final Map<String, BiConsumer<String, Float>> tickrateListeners = new HashMap<>();
-    private static final float MIN_TICKRATE = 0.01f;
-
-    //unused - mod compat reasons
-    public void tickrate(float rate)
-    {
-        tickrate(rate, true);
-    }
-
-    public void tickrate(float rate, boolean update)
+    public void setTickRate(float rate)
     {
         tickrate = rate;
         long msptt = (long) (1000.0 / tickrate);
@@ -240,53 +21,76 @@ public class TickRateManager
             msptt = 1L;
             tickrate = 1000.0f;
         }
-
-        this.mspt = msptt;
-
-        if (update)
-        {
-            notifyTickrateListeners("carpet");
-        }
+        mspt = msptt;
     }
 
-    private void tickrateChanged(String modId, float rate)
+    public float tickrate()
     {
-        // Other mods might change the tickrate in a slightly
-        // different way. Also allow for tickrates that don't
-        // divide into 1000 here.
-
-        if (rate < MIN_TICKRATE)
-        {
-            rate = MIN_TICKRATE;
-        }
-
-        tickrate = rate;
-        mspt = 1000.0f / tickrate;
-
-        notifyTickrateListeners(modId);
+        return tickrate;
     }
 
-    private void notifyTickrateListeners(String originModId)
+    /**
+     * @return Whether or not the game is in a frozen state.
+     * You should normally use {@link #runGameElements} instead,
+     * since that one accounts for tick steps and superhot
+     */
+    public boolean gameIsPaused()
     {
-        synchronized (tickrateListeners)
-        {
-            for (Map.Entry<String, BiConsumer<String, Float>> listenerEntry : tickrateListeners.entrySet())
-            {
-                if (originModId == null || !originModId.equals(listenerEntry.getKey()))
-                {
-                    listenerEntry.getValue().accept(originModId, Float.valueOf(tickrate));
-                }
-            }
-        }
-        ServerNetworkHandler.updateTickSpeedToConnectedPlayers(server);
+        return isGamePaused;
     }
 
-    public BiConsumer<String, Float> addTickrateListener(String modId, BiConsumer<String, Float> tickrateListener)
+    public float mspt() {
+        return mspt;
+    }
+
+    public boolean runsNormally()
     {
-        synchronized (tickrateListeners)
+        return runGameElements;
+    }
+
+    public boolean isSuperHot()
+    {
+        return isSuperHot;
+    }
+
+    public void setPlayerActiveTimeout(int timeout)
+    {
+        playerActivityTimeout = timeout;
+    }
+
+    public int getPlayerActiveTimeout()
+    {
+        return playerActivityTimeout;
+    }
+
+    public void setFrozenState(boolean isPaused, boolean isDeepFreeze)
+    {
+        isGamePaused = isPaused;
+        deepFreeze = isPaused && isDeepFreeze;
+    }
+
+    public void setSuperHot(boolean isSuperHot)
+    {
+        this.isSuperHot = isSuperHot;
+    }
+
+    public void tick()
+    {
+        if (playerActivityTimeout > 0)
         {
-            tickrateListeners.put(modId, tickrateListener);
+            playerActivityTimeout--;
+        }
+        if (isGamePaused)
+        {
+            runGameElements = playerActivityTimeout >= PLAYER_GRACE;
+        }
+        else if (isSuperHot)
+        {
+            runGameElements = playerActivityTimeout > 0;
+        }
+        else
+        {
+            runGameElements = true;
         }
-        return this::tickrateChanged;
     }
 }

src/main/java/carpet/helpers/TickSpeed.java

@@ -10,27 +10,28 @@ import net.minecraft.server.level.ServerPlayer;
 import carpet.CarpetServer;
 import carpet.utils.Messenger;
 
+@Deprecated(forRemoval = true, since = "now")
 public class TickSpeed
 {
-    private static Optional<TickRateManager> gTRM() {
+    private static Optional<ServerTickRateManager> gTRM() {
         if (CarpetServer.minecraft_server == null) return Optional.empty();
         return Optional.of(((MinecraftServerInterface)CarpetServer.minecraft_server).getTickRateManager());
     }
 
     public static boolean process_entities() {
-        return gTRM().map(trm -> trm.process_entities).orElse(true);
+        return gTRM().map(ServerTickRateManager::runsNormally).orElse(true);
     }
 
     public static float mspt() {
-        return gTRM().map(trm -> trm.mspt).orElse(50.0f);
+        return gTRM().map(ServerTickRateManager::mspt).orElse(50.0f);
     }
 
     public static boolean isPaused() {
-	    return gTRM().map(TickRateManager::isPaused).orElse(false);
+	    return gTRM().map(ServerTickRateManager::gameIsPaused).orElse(false);
     }
 
     public static boolean deeplyFrozen() {
-        return gTRM().map(TickRateManager::deeplyFrozen).orElse(false);
+        return gTRM().map(ServerTickRateManager::deeplyFrozen).orElse(false);
     }
 
     public static void setFrozenState(boolean isPaused, boolean isDeepFreeze) {
@@ -39,7 +40,7 @@ public class TickSpeed
     
     public static void reset_player_active_timeout()
     {
-        gTRM().ifPresent(TickRateManager::reset_player_active_timeout);
+        gTRM().ifPresent(ServerTickRateManager::resetPlayerActivity);
     }
 
     public static void reset()
@@ -49,33 +50,33 @@ public class TickSpeed
 
     public static void add_ticks_to_run_in_pause(int ticks)
     {
-        gTRM().ifPresent(trm -> trm.add_ticks_to_run_in_pause(ticks));
+        gTRM().ifPresent(trm -> trm.stepGameIfPaused(ticks));
     }
 
     public static Component tickrate_advance(ServerPlayer player, int advance, String callback, CommandSourceStack source)
     {
-        return gTRM().map(trm -> trm.tickrate_advance(player, advance, callback, source)).orElse(Messenger.c("ri Tickrate management not enabled"));
+        return gTRM().map(trm -> trm.requestGameToWarpSpeed(player, advance, callback, source)).orElse(Messenger.c("ri Tickrate management not enabled"));
     }
 
     public static void finish_time_warp()
     {
-        gTRM().ifPresent(TickRateManager::finish_time_warp);
+        gTRM().ifPresent(ServerTickRateManager::finishTickWarp);
     }
 
     public static boolean continueWarp()
     {
-        return gTRM().map(TickRateManager::continueWarp).orElse(false);
+        return gTRM().map(ServerTickRateManager::continueWarp).orElse(false);
     }
 
     public static void tick()
     {
-        gTRM().ifPresent(TickRateManager::tick);
+        gTRM().ifPresent(ServerTickRateManager::tick);
     }
     //unused - mod compat reasons
     public static void tickrate(float rate) {tickrate(rate, true);}
     public static void tickrate(float rate, boolean update)
     {
-        gTRM().ifPresent(trm -> trm.tickrate(rate, update));
+        gTRM().ifPresent(trm -> trm.setTickRate(rate, update));
     }
 
 
@@ -147,7 +148,7 @@ public class TickSpeed
         }
         if (is_paused)
         {
-            process_entities = player_active_timeout >= TickRateManager.PLAYER_GRACE;
+            process_entities = player_active_timeout >= ServerTickRateManager.PLAYER_GRACE;
         }
         else if (is_superHot)
         {