Use setters and getters for frozen state, separate superHot and

don't tick regular tick events

src/main/java/carpet/commands/TickCommand.java

@@ -96,19 +96,15 @@ public class TickCommand
 
     private static int toggleFreeze(ServerCommandSource source, boolean isDeep)
     {
-        TickSpeed.is_paused = !TickSpeed.is_paused;
+        TickSpeed.setFrozenState(!TickSpeed.isPaused(), isDeep);
-        if (TickSpeed.is_paused)
+        if (TickSpeed.isPaused())
         {
-            TickSpeed.deepFreeze = isDeep;
             Messenger.m(source, "gi Game is "+(isDeep?"deeply ":"")+"frozen");
-
         }
         else
         {
-            TickSpeed.deepFreeze = false;
             Messenger.m(source, "gi Game runs normally");
         }
-        ServerNetworkHandler.updateTickingStateToConnectedPlayers();
         return 1;
     }
 
@@ -121,10 +117,10 @@ public class TickCommand
     private static int toggleSuperHot(ServerCommandSource source)
     {
         TickSpeed.is_superHot = !TickSpeed.is_superHot;
-        ServerNetworkHandler.updateTickingStateToConnectedPlayers();
+        ServerNetworkHandler.updateSuperHotStateToConnectedPlayers();
         if (TickSpeed.is_superHot)
         {
-            Messenger.m(source,"gi Superhot enabled");
+            Messenger.m(source, "gi Superhot enabled");
         }
         else
         {

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

@@ -25,10 +25,42 @@ public class TickSpeed
     public static ServerCommandSource tick_warp_sender = null;
     public static int player_active_timeout = 0;
     public static boolean process_entities = true;
-    public static boolean deepFreeze = false;
+    private static boolean deepFreeze = false;
-    public static boolean is_paused = false;
+    private static boolean is_paused = false;
     public static boolean is_superHot = false;
 
+    /**
+     * @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 static boolean isPaused() {
+	    return is_paused;
+    }
+
+    /**
+     * This can be used for things that you may not normally want
+     * to freeze, but may need to in some situations.
+     * This should be used with {@link #process_entities} to make sure the 
+     * current tick is actually frozen
+     * @return Whether or not the game is deeply frozen.
+     */
+    public static 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 static void setFrozenState(boolean isPaused, boolean isDeepFreeze) {
+        is_paused = isPaused;
+        deepFreeze = isPaused ? isDeepFreeze : false;
+        ServerNetworkHandler.updateFrozenStateToConnectedPlayers();
+    }
+
     /**
      * Functional interface that listens for tickrate changes. This is
      * implemented to allow tickrate compatibility with other mods etc.

src/main/java/carpet/mixins/ChunkTicketManager_tickMixin.java

@@ -18,6 +18,6 @@ public class ChunkTicketManager_tickMixin
     {
         // pausing expiry of tickets
         // that will prevent also chunks from unloading, so require a deep frozen state
-        if (!TickSpeed.process_entities && TickSpeed.deepFreeze) age--;
+        if (!TickSpeed.process_entities && TickSpeed.deeplyFrozen()) age--;
     }
 }

src/main/java/carpet/mixins/CommandFunctionManager_tickMixin.java

@@ -16,7 +16,7 @@ public class CommandFunctionManager_tickMixin
     @Inject(method = "tick", at = @At("HEAD"), cancellable = true)
     private void beforeDatapacks(CallbackInfo ci)
     {
-    	if (!TickSpeed.process_entities && TickSpeed.deepFreeze) ci.cancel();
+    	if (!TickSpeed.process_entities) ci.cancel();
     	else
         currentSection = CarpetProfiler.start_section(null, "Datapacks", CarpetProfiler.TYPE.GENERAL);
     }

src/main/java/carpet/mixins/MinecraftClientMixin.java

@@ -28,7 +28,7 @@ public class MinecraftClientMixin
         if (this.world != null) {
             if (CarpetServer.minecraft_server == null)
                 TickSpeed.tick();
-            if (!TickSpeed.process_entities && TickSpeed.deepFreeze)
+            if (!TickSpeed.process_entities && TickSpeed.deeplyFrozen())
                 CarpetClient.shapes.renewShapes();
         }
     }

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

@@ -70,7 +70,7 @@ public abstract class MinecraftServer_scarpetMixin extends ReentrantThreadExecut
     ))
     public void tickTasks(BooleanSupplier booleanSupplier_1, CallbackInfo ci)
     {
-        if (!TickSpeed.process_entities && TickSpeed.deepFreeze)
+        if (!TickSpeed.process_entities)
             return;
         TICK.onTick();
         NETHER_TICK.onTick();

src/main/java/carpet/network/ClientNetworkHandler.java

@@ -9,6 +9,7 @@ import carpet.settings.SettingsManager;
 import io.netty.buffer.Unpooled;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.nbt.AbstractNumberTag;
+import net.minecraft.nbt.ByteTag;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
 import net.minecraft.nbt.Tag;
@@ -67,9 +68,10 @@ public class ClientNetworkHandler
         dataHandlers.put("TickRate", (p, t) -> TickSpeed.tickrate(((AbstractNumberTag)t).getFloat(), false));
         dataHandlers.put("TickingState", (p, t) -> {
             CompoundTag tickingState = (CompoundTag)t;
-            TickSpeed.is_paused = tickingState.getBoolean("is_paused");
+            TickSpeed.setFrozenState(tickingState.getBoolean("is_paused"), tickingState.getBoolean("deepFreeze"));
-            TickSpeed.deepFreeze = tickingState.getBoolean("deepFreeze");
+        });
-            TickSpeed.is_superHot = tickingState.getBoolean("is_superHot");
+        dataHandlers.put("SuperHotState", (p, t) -> {
+            TickSpeed.is_superHot = ((ByteTag) t).equals(ByteTag.ONE);
         });
         dataHandlers.put("TickPlayerActiveTimeout", (p, t) -> TickSpeed.player_active_timeout = ((AbstractNumberTag)t).getInt());
         dataHandlers.put("scShape", (p, t) -> { // deprecated

src/main/java/carpet/network/ServerNetworkHandler.java

@@ -77,7 +77,7 @@ public class ServerNetworkHandler
             CarpetSettings.LOG.info("Player "+playerEntity.getName().getString()+" joined with a matching carpet client");
         else
             CarpetSettings.LOG.warn("Player "+playerEntity.getName().getString()+" joined with another carpet version: "+clientVersion);
-        DataBuilder data = DataBuilder.create().withTickRate().withTickingState().withTickPlayerActiveTimeout();
+        DataBuilder data = DataBuilder.create().withTickRate().withFrozenState().withTickPlayerActiveTimeout(); // .withSuperHotState()
         CarpetServer.settingsManager.getRules().forEach(data::withRule);
         CarpetServer.extensions.forEach(e -> {
             SettingsManager eManager = e.customSettingsManager();
@@ -173,14 +173,26 @@ public class ServerNetworkHandler
         }
     }
 
-    public static void updateTickingStateToConnectedPlayers()
+    public static void updateFrozenStateToConnectedPlayers()
     {
         if (CarpetSettings.superSecretSetting) return;
         for (ServerPlayerEntity player : remoteCarpetPlayers.keySet())
         {
             player.networkHandler.sendPacket(new CustomPayloadS2CPacket(
                     CarpetClient.CARPET_CHANNEL,
-                    DataBuilder.create().withTickingState().build()
+                    DataBuilder.create().withFrozenState().build()
+            ));
+        }
+    }
+
+    public static void updateSuperHotStateToConnectedPlayers()
+    {
+        if(CarpetSettings.superSecretSetting) return;
+        for (ServerPlayerEntity player : remoteCarpetPlayers.keySet())
+        {
+            player.networkHandler.sendPacket(new CustomPayloadS2CPacket(
+                    CarpetClient.CARPET_CHANNEL,
+                    DataBuilder.create().withSuperHotState().build()
             ));
         }
     }
@@ -264,15 +276,19 @@ public class ServerNetworkHandler
             tag.putFloat("TickRate", TickSpeed.tickrate);
             return this;
         }
-        private DataBuilder withTickingState()
+        private DataBuilder withFrozenState()
         {
             CompoundTag tickingState = new CompoundTag();
-            tickingState.putBoolean("is_paused", TickSpeed.is_paused);
+            tickingState.putBoolean("is_paused", TickSpeed.isPaused());
-            tickingState.putBoolean("deepFreeze", TickSpeed.deepFreeze);
+            tickingState.putBoolean("deepFreeze", TickSpeed.deeplyFrozen());
-            tickingState.putBoolean("is_superhot", TickSpeed.is_superHot);
             tag.put("TickingState", tickingState);
             return this;
         }
+        private DataBuilder withSuperHotState()
+        {
+        	tag.putBoolean("SuperHotState", TickSpeed.is_superHot);
+        	return this;
+        }
         private DataBuilder withTickPlayerActiveTimeout()
         {
             tag.putInt("TickPlayerActiveTimeout", TickSpeed.player_active_timeout);

src/main/java/carpet/script/CarpetEventServer.java

@@ -961,7 +961,7 @@ public class CarpetEventServer
 
     public void tick()
     {
-        if (!TickSpeed.process_entities && TickSpeed.deepFreeze)
+        if (!TickSpeed.process_entities && TickSpeed.deeplyFrozen())
             return;
         Iterator<ScheduledCall> eventIterator = scheduledCalls.iterator();
         List<ScheduledCall> currentCalls = new ArrayList<>();