code style

src/main/java/carpet/network/CarpetClient.java

@@ -16,17 +16,20 @@ public class CarpetClient
 {
     public record CarpetPayload(CompoundTag data) implements CustomPacketPayload
     {
-        public CarpetPayload(FriendlyByteBuf input) {
+        public CarpetPayload(FriendlyByteBuf input)
+        {
             this(input.readNbt());
         }
 
         @Override
-        public void write(FriendlyByteBuf output) {
+        public void write(FriendlyByteBuf output)
+        {
             output.writeNbt(data);
         }
 
         @Override
-        public ResourceLocation id() {
+        public ResourceLocation id()
+        {
             return CARPET_CHANNEL;
         }
     }
@@ -78,7 +81,10 @@ public class CarpetClient
 
     public static boolean sendClientCommand(String command)
     {
-        if (!isServerCarpet && CarpetServer.minecraft_server == null) return false;
+        if (!isServerCarpet && CarpetServer.minecraft_server == null)
+        {
+            return false;
+        }
         ClientNetworkHandler.clientCommand(command);
         return true;
     }
@@ -86,15 +92,20 @@ public class CarpetClient
     public static void onClientCommand(Tag t)
     {
         CarpetSettings.LOG.info("Server Response:");
-        CompoundTag tag = (CompoundTag)t;
+        CompoundTag tag = (CompoundTag) t;
-        CarpetSettings.LOG.info(" - id: "+tag.getString("id"));
+        CarpetSettings.LOG.info(" - id: " + tag.getString("id"));
-        CarpetSettings.LOG.info(" - code: "+tag.getInt("code"));
+        CarpetSettings.LOG.info(" - code: " + tag.getInt("code"));
-        if (tag.contains("error")) CarpetSettings.LOG.warn(" - error: "+tag.getString("error"));
+        if (tag.contains("error"))
+        {
+            CarpetSettings.LOG.warn(" - error: " + tag.getString("error"));
+        }
         if (tag.contains("output"))
         {
             ListTag outputTag = (ListTag) tag.get("output");
             for (int i = 0; i < outputTag.size(); i++)
+            {
                 CarpetSettings.LOG.info(" - response: " + Component.Serializer.fromJson(outputTag.getString(i)).getString());
+            }
         }
     }
 }

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

@@ -8,9 +8,11 @@ import carpet.api.settings.InvalidRuleValueException;
 import carpet.fakes.LevelInterface;
 import carpet.helpers.TickRateManager;
 import carpet.api.settings.SettingsManager;
+
 import java.util.HashMap;
 import java.util.Map;
 import java.util.function.BiConsumer;
+
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.nbt.ByteTag;
 import net.minecraft.nbt.CompoundTag;
@@ -22,12 +24,13 @@ import net.minecraft.network.protocol.common.ServerboundCustomPayloadPacket;
 public class ClientNetworkHandler
 {
     private static final Map<String, BiConsumer<LocalPlayer, Tag>> dataHandlers = new HashMap<String, BiConsumer<LocalPlayer, Tag>>();
+
     static
     {
         dataHandlers.put(CarpetClient.HI, (p, t) -> onHi(t.getAsString()));
         dataHandlers.put("Rules", (p, t) -> {
-            CompoundTag ruleset = (CompoundTag)t;
+            CompoundTag ruleset = (CompoundTag) t;
-            for (String ruleKey: ruleset.getAllKeys())
+            for (String ruleKey : ruleset.getAllKeys())
             {
                 CompoundTag ruleNBT = (CompoundTag) ruleset.get(ruleKey);
                 SettingsManager manager = null;
@@ -42,7 +45,8 @@ public class ClientNetworkHandler
                     }
                     else
                     {
-                        for (CarpetExtension extension: CarpetServer.extensions) {
+                        for (CarpetExtension extension : CarpetServer.extensions)
+                        {
                             SettingsManager eManager = extension.extensionSettingsManager();
                             if (eManager != null && managerName.equals(eManager.identifier()))
                             {
@@ -61,38 +65,46 @@ public class ClientNetworkHandler
                 if (rule != null)
                 {
                     String value = ruleNBT.getString("Value");
-                    try { rule.set(null, value); } catch (InvalidRuleValueException ignored) { }
+                    try
+                    {
+                        rule.set(null, value);
+                    }
+                    catch (InvalidRuleValueException ignored)
+                    {
+                    }
                 }
             }
         });
         dataHandlers.put("TickRate", (p, t) -> {
-            TickRateManager tickRateManager = ((LevelInterface)p.clientLevel).tickRateManager();
+            TickRateManager tickRateManager = ((LevelInterface) p.clientLevel).tickRateManager();
             tickRateManager.setTickRate(((NumericTag) t).getAsFloat());
         });
         dataHandlers.put("TickingState", (p, t) -> {
-            CompoundTag tickingState = (CompoundTag)t;
+            CompoundTag tickingState = (CompoundTag) t;
-            TickRateManager tickRateManager = ((LevelInterface)p.clientLevel).tickRateManager();
+            TickRateManager tickRateManager = ((LevelInterface) p.clientLevel).tickRateManager();
             tickRateManager.setFrozenState(tickingState.getBoolean("is_paused"), tickingState.getBoolean("deepFreeze"));
         });
         dataHandlers.put("SuperHotState", (p, t) -> {
-            TickRateManager tickRateManager = ((LevelInterface)p.clientLevel).tickRateManager();
+            TickRateManager tickRateManager = ((LevelInterface) p.clientLevel).tickRateManager();
-            tickRateManager.setSuperHot(((ByteTag) t).equals(ByteTag.ONE));
+            tickRateManager.setSuperHot(t.equals(ByteTag.ONE));
         });
         dataHandlers.put("TickPlayerActiveTimeout", (p, t) -> {
-            TickRateManager tickRateManager = ((LevelInterface)p.clientLevel).tickRateManager();
+            TickRateManager tickRateManager = ((LevelInterface) p.clientLevel).tickRateManager();
             tickRateManager.setPlayerActiveTimeout(((NumericTag) t).getAsInt());
         });
         dataHandlers.put("scShape", (p, t) -> { // deprecated // and unused // should remove for 1.17
             if (CarpetClient.shapes != null)
-                CarpetClient.shapes.addShape((CompoundTag)t);
+            {
+                CarpetClient.shapes.addShape((CompoundTag) t);
+            }
         });
         dataHandlers.put("scShapes", (p, t) -> {
             if (CarpetClient.shapes != null)
+            {
                 CarpetClient.shapes.addShapes((ListTag) t);
+            }
         });
-        dataHandlers.put("clientCommand", (p, t) -> {
+        dataHandlers.put("clientCommand", (p, t) -> CarpetClient.onClientCommand(t));
-            CarpetClient.onClientCommand(t);
-        });
     }
 
     // Ran on the Main Minecraft Thread
@@ -107,7 +119,7 @@ public class ClientNetworkHandler
         }
         else
         {
-            CarpetSettings.LOG.warn("Joined carpet server with another carpet version: "+CarpetClient.serverCarpetVersion);
+            CarpetSettings.LOG.warn("Joined carpet server with another carpet version: " + CarpetClient.serverCarpetVersion);
         }
         // We can ensure that this packet is
         // processed AFTER the player has joined
@@ -125,19 +137,23 @@ public class ClientNetworkHandler
 
     public static void onServerData(CompoundTag compound, LocalPlayer player)
     {
-        for (String key: compound.getAllKeys())
+        for (String key : compound.getAllKeys())
         {
-            if (dataHandlers.containsKey(key)) {
+            if (dataHandlers.containsKey(key))
-                try {
+            {
+                try
+                {
                     dataHandlers.get(key).accept(player, compound.get(key));
                 }
                 catch (Exception exc)
                 {
-                    CarpetSettings.LOG.info("Corrupt carpet data for "+key);
+                    CarpetSettings.LOG.info("Corrupt carpet data for " + key);
                 }
             }
             else
-                CarpetSettings.LOG.error("Unknown carpet data: "+key);
+            {
+                CarpetSettings.LOG.error("Unknown carpet data: " + key);
+            }
         }
     }
 

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

@@ -34,12 +34,12 @@ public class ServerNetworkHandler
 
     private static final Map<String, BiConsumer<ServerPlayer, Tag>> dataHandlers = Map.of(
             CarpetClient.HELLO, (p, t) -> onHello(p, t.getAsString()),
-            "clientCommand", (p, t) -> handleClientCommand(p, (CompoundTag)t)
+            "clientCommand", (p, t) -> handleClientCommand(p, (CompoundTag) t)
     );
 
     public static void onPlayerJoin(ServerPlayer playerEntity)
     {
-        if (!((ServerGamePacketListenerImplInterface)playerEntity.connection).getConnection().isMemoryConnection())
+        if (!((ServerGamePacketListenerImplInterface) playerEntity.connection).getConnection().isMemoryConnection())
         {
             CompoundTag data = new CompoundTag();
             data.putString(CarpetClient.HI, CarpetSettings.carpetVersion);
@@ -56,16 +56,24 @@ public class ServerNetworkHandler
         validCarpetPlayers.add(playerEntity);
         remoteCarpetPlayers.put(playerEntity, version);
         if (version.equals(CarpetSettings.carpetVersion))
-            CarpetSettings.LOG.info("Player "+playerEntity.getName().getString()+" joined with a matching carpet client");
+        {
+            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: "+ version);
+        {
+            CarpetSettings.LOG.warn("Player " + playerEntity.getName().getString() + " joined with another carpet version: " + version);
+        }
         DataBuilder data = DataBuilder.create(playerEntity.server); // tickrate related settings are sent on world change
         CarpetServer.forEachManager(sm -> sm.getCarpetRules().forEach(data::withRule));
         playerEntity.connection.send(data.build());
     }
 
-    public static void sendPlayerLevelData(ServerPlayer player, ServerLevel level) {
+    public static void sendPlayerLevelData(ServerPlayer player, ServerLevel level)
-        if (CarpetSettings.superSecretSetting || !validCarpetPlayers.contains(player)) return;
+    {
+        if (CarpetSettings.superSecretSetting || !validCarpetPlayers.contains(player))
+        {
+            return;
+        }
         DataBuilder data = DataBuilder.create(player.server).withTickRate().withFrozenState().withTickPlayerActiveTimeout(); // .withSuperHotState()
         player.connection.send(data.build());
     }
@@ -90,28 +98,44 @@ public class ServerNetworkHandler
         CompoundTag result = new CompoundTag();
         result.putString("id", id);
         result.putInt("code", resultCode);
-        if (error[0] != null) result.putString("error", error[0].getContents().toString());
+        if (error[0] != null)
+        {
+            result.putString("error", error[0].getContents().toString());
+        }
         ListTag outputResult = new ListTag();
-        for (Component line: output) outputResult.add(StringTag.valueOf(Component.Serializer.toJson(line)));
+        for (Component line : output)
-        if (!output.isEmpty()) result.put("output", outputResult);
+        {
+            outputResult.add(StringTag.valueOf(Component.Serializer.toJson(line)));
+        }
+        if (!output.isEmpty())
+        {
+            result.put("output", outputResult);
+        }
         player.connection.send(DataBuilder.create(player.server).withCustomNbt("clientCommand", result).build());
         // run command plug to command output,
     }
 
     public static void onClientData(ServerPlayer player, CompoundTag compound)
     {
-        for (String key: compound.getAllKeys())
+        for (String key : compound.getAllKeys())
         {
             if (dataHandlers.containsKey(key))
+            {
                 dataHandlers.get(key).accept(player, compound.get(key));
+            }
             else
-                CarpetSettings.LOG.warn("Unknown carpet client data: "+key);
+            {
+                CarpetSettings.LOG.warn("Unknown carpet client data: " + key);
+            }
         }
     }
 
     public static void updateRuleWithConnectedClients(CarpetRule<?> rule)
     {
-        if (CarpetSettings.superSecretSetting) return;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return;
+        }
         for (ServerPlayer player : remoteCarpetPlayers.keySet())
         {
             player.connection.send(DataBuilder.create(player.server).withRule(rule).build());
@@ -120,7 +144,10 @@ public class ServerNetworkHandler
 
     public static void updateTickSpeedToConnectedPlayers(MinecraftServer server)
     {
-        if (CarpetSettings.superSecretSetting) return;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return;
+        }
         for (ServerPlayer player : validCarpetPlayers)
         {
             player.connection.send(DataBuilder.create(player.server).withTickRate().build());
@@ -129,7 +156,10 @@ public class ServerNetworkHandler
 
     public static void updateFrozenStateToConnectedPlayers(MinecraftServer server)
     {
-        if (CarpetSettings.superSecretSetting) return;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return;
+        }
         for (ServerPlayer player : validCarpetPlayers)
         {
             player.connection.send(DataBuilder.create(player.server).withFrozenState().build());
@@ -138,7 +168,10 @@ public class ServerNetworkHandler
 
     public static void updateSuperHotStateToConnectedPlayers(MinecraftServer server)
     {
-        if(CarpetSettings.superSecretSetting) return;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return;
+        }
         for (ServerPlayer player : validCarpetPlayers)
         {
             player.connection.send(DataBuilder.create(player.server).withSuperHotState().build());
@@ -147,7 +180,10 @@ public class ServerNetworkHandler
 
     public static void updateTickPlayerActiveTimeoutToConnectedPlayers(MinecraftServer server)
     {
-        if (CarpetSettings.superSecretSetting) return;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return;
+        }
         for (ServerPlayer player : validCarpetPlayers)
         {
             player.connection.send(DataBuilder.create(player.server).withTickPlayerActiveTimeout().build());
@@ -156,7 +192,10 @@ public class ServerNetworkHandler
 
     public static void broadcastCustomCommand(String command, Tag data)
     {
-        if (CarpetSettings.superSecretSetting) return;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return;
+        }
         for (ServerPlayer player : validCarpetPlayers)
         {
             player.connection.send(DataBuilder.create(player.server).withCustomNbt(command, data).build());
@@ -174,8 +213,10 @@ public class ServerNetworkHandler
     public static void onPlayerLoggedOut(ServerPlayer player)
     {
         validCarpetPlayers.remove(player);
-        if (!((ServerGamePacketListenerImplInterface)player.connection).getConnection().isMemoryConnection())
+        if (!((ServerGamePacketListenerImplInterface) player.connection).getConnection().isMemoryConnection())
+        {
             remoteCarpetPlayers.remove(player);
+        }
     }
 
     public static void close()
@@ -186,15 +227,24 @@ public class ServerNetworkHandler
 
     public static boolean isValidCarpetPlayer(ServerPlayer player)
     {
-        if (CarpetSettings.superSecretSetting) return false;
+        if (CarpetSettings.superSecretSetting)
+        {
+            return false;
+        }
         return validCarpetPlayers.contains(player);
 
     }
 
     public static String getPlayerStatus(ServerPlayer player)
     {
-        if (remoteCarpetPlayers.containsKey(player)) return "carpet "+remoteCarpetPlayers.get(player);
+        if (remoteCarpetPlayers.containsKey(player))
-        if (validCarpetPlayers.contains(player)) return "carpet "+CarpetSettings.carpetVersion;
+        {
+            return "carpet " + remoteCarpetPlayers.get(player);
+        }
+        if (validCarpetPlayers.contains(player))
+        {
+            return "carpet " + CarpetSettings.carpetVersion;
+        }
         return "vanilla";
     }
 
@@ -202,42 +252,49 @@ public class ServerNetworkHandler
     {
         private CompoundTag tag;
         private MinecraftServer server;
+
         private static DataBuilder create(final MinecraftServer server)
         {
             return new DataBuilder(server);
         }
+
         private DataBuilder(MinecraftServer server)
         {
             tag = new CompoundTag();
             this.server = server;
         }
+
         private DataBuilder withTickRate()
         {
-            ServerTickRateManager trm = ((MinecraftServerInterface)server).getTickRateManager();
+            ServerTickRateManager trm = ((MinecraftServerInterface) server).getTickRateManager();
             tag.putFloat("TickRate", trm.tickrate());
             return this;
         }
+
         private DataBuilder withFrozenState()
         {
-            ServerTickRateManager trm = ((MinecraftServerInterface)server).getTickRateManager();
+            ServerTickRateManager trm = ((MinecraftServerInterface) server).getTickRateManager();
             CompoundTag tickingState = new CompoundTag();
             tickingState.putBoolean("is_paused", trm.gameIsPaused());
             tickingState.putBoolean("deepFreeze", trm.deeplyFrozen());
             tag.put("TickingState", tickingState);
             return this;
         }
+
         private DataBuilder withSuperHotState()
         {
-            ServerTickRateManager trm = ((MinecraftServerInterface)server).getTickRateManager();
+            ServerTickRateManager trm = ((MinecraftServerInterface) server).getTickRateManager();
-        	tag.putBoolean("SuperHotState", trm.isSuperHot());
+            tag.putBoolean("SuperHotState", trm.isSuperHot());
-        	return this;
+            return this;
         }
+
         private DataBuilder withTickPlayerActiveTimeout()
         {
-            ServerTickRateManager trm = ((MinecraftServerInterface)server).getTickRateManager();
+            ServerTickRateManager trm = ((MinecraftServerInterface) server).getTickRateManager();
             tag.putInt("TickPlayerActiveTimeout", trm.getPlayerActiveTimeout());
             return this;
         }
+
         private DataBuilder withRule(CarpetRule<?> rule)
         {
             CompoundTag rules = (CompoundTag) tag.get("Rules");
@@ -248,7 +305,10 @@ public class ServerNetworkHandler
             }
             String identifier = rule.settingsManager().identifier();
             String key = rule.name();
-            while (rules.contains(key)) { key = key+"2";}
+            while (rules.contains(key))
+            {
+                key = key + "2";
+            }
             CompoundTag ruleNBT = new CompoundTag();
             ruleNBT.putString("Value", RuleHelper.toRuleString(rule.value()));
             ruleNBT.putString("Manager", identifier);