refactor BlockBreakSpeed class for improved maintainability

Author: AoElite

common/src/main/java/ac/grim/grimac/utils/nmsutil/BlockBreakSpeed.java

@@ -54,16 +54,23 @@ public class BlockBreakSpeed {
             StateTypes.ENDER_CHEST
     );
 
-    private static final boolean serverUsesComponentsAndRules = PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_20_5);
+    private static final boolean SERVER_USES_COMPONENTS_AND_RULES = PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_20_5);
+
+    record ToolSpeedData(float speedMultiplier, boolean isCorrectToolForDrop) {
+    }
 
     public static double getBlockDamage(GrimPlayer player, WrappedBlockState block) {
+        ItemStack tool = player.inventory.getHeldItem();
+        return getBlockDamage(player, tool, block.getType());
+    }
+
+    public static double getBlockDamage(GrimPlayer player, ItemStack tool, StateType block) {
         // GET destroy speed
         // Starts with itemstack get destroy speed
-        ItemStack tool = player.inventory.getHeldItem();
         ItemType toolType = tool.getType();
 
         if (player.gamemode == GameMode.CREATIVE) {
-            if (serverUsesComponentsAndRules && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_5)) {
+            if (SERVER_USES_COMPONENTS_AND_RULES && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_5)) {
                 return tool.getComponent(ComponentTypes.TOOL)
                         .map(ItemTool::isCanDestroyBlocksInCreative)
                         .orElse(true) ? 1 : 0;
@@ -77,137 +84,35 @@ public static double getBlockDamage(GrimPlayer player, WrappedBlockState block)
             }
         }
 
-        float blockHardness = block.getType().getHardness();
+        float blockHardness = block.getHardness();
 
         // 1.15.2 and below need this hack
-        if ((block.getType() == StateTypes.PISTON || block.getType() == StateTypes.PISTON_HEAD || block.getType() == StateTypes.STICKY_PISTON) && player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_15_2)) {
+        if ((block == StateTypes.PISTON || block == StateTypes.PISTON_HEAD || block == StateTypes.STICKY_PISTON) && player.getClientVersion().isOlderThanOrEquals(ClientVersion.V_1_15_2)) {
             blockHardness = 0.5f;
         }
 
         if (blockHardness == -1) return 0; // Unbreakable block
 
-        boolean isCorrectToolForDrop = false;
-        float speedMultiplier = 1.0F;
-
-        // TODO technically its possible to use packet level manipulation to enforce Tool rules on newer clients on older servers
-        // But I've yet to hear of anyone even trying to do such a thing rather than just update the server
-        // And we can't support this because we don't see the tool components/data before Via
-        if (serverUsesComponentsAndRules && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_20_5)) {
-            Optional<ItemTool> toolComponentOpt = tool.getComponent(ComponentTypes.TOOL);
-            if (toolComponentOpt.isPresent()) {
-                ItemTool itemTool = toolComponentOpt.get();
-
-                // Initialize with final default values. These will be used if the loop doesn't find a value.
-                // isCorrectToolForDrop is already set to false, no need to set again as default
-                speedMultiplier = itemTool.getDefaultMiningSpeed();
-
-                boolean speedFound = false;
-                boolean dropsFound = false;
-
-                for (ItemTool.Rule rule : itemTool.getRules()) {
-                    MappedEntitySet<StateType.Mapped> predicate = rule.getBlocks();
-                    ResourceLocation tagKey = predicate.getTagKey();
-                    boolean isMatch;
-
-                    // First, determine if the current rule even applies to this block.
-                    if (tagKey != null) {
-                        SyncedTag<StateType> playerTag = player.tagManager.block(tagKey);
-                        isMatch = (playerTag != null && playerTag.contains(block.getType()))
-                                || BlockTags.getByName(tagKey.getKey()).contains(block.getType());
-                    } else {
-                        isMatch = predicate.getEntities().contains(block.getType().getMapped());
-                    }
-
-                    // If the rule matches the block, check if we still need its properties.
-                    if (isMatch) {
-                        // Check for speed if we haven't found it yet.
-                        if (!speedFound && rule.getSpeed() != null) {
-                            speedMultiplier = rule.getSpeed();
-                            speedFound = true;
-                        }
-
-                        // Check for drops if we haven't found it yet.
-                        if (!dropsFound && rule.getCorrectForDrops() != null) {
-                            isCorrectToolForDrop = rule.getCorrectForDrops();
-                            dropsFound = true;
-                        }
-                    }
-
-                    if (speedFound && dropsFound) {
-                        break;
-                    }
-                }
-            }
+        final ToolSpeedData toolSpeedData;
+        if (SERVER_USES_COMPONENTS_AND_RULES && player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_20_5)) {
+            toolSpeedData = getModernToolSpeedData(player, tool, block);
         } else {
-            // 1.13 and below need their own huge methods to support this...
-            if (toolType.hasAttribute(ItemTypes.ItemAttribute.AXE)) {
-                isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_AXE).contains(block.getType());
-            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.PICKAXE)) {
-                isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_PICKAXE).contains(block.getType());
-            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.SHOVEL)) {
-                isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_SHOVEL).contains(block.getType());
-            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.HOE)) {
-                isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_HOE).contains(block.getType());
-            }
-
-            if (isCorrectToolForDrop) {
-                int tier = 0;
-                if (toolType.hasAttribute(ItemTypes.ItemAttribute.WOOD_TIER)) { // Tier 0
-                    speedMultiplier = 2.0f;
-                } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.STONE_TIER)) { // Tier 1
-                    speedMultiplier = 4.0f;
-                    tier = 1;
-                } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.IRON_TIER)) { // Tier 2
-                    speedMultiplier = 6.0f;
-                    tier = 2;
-                } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.DIAMOND_TIER)) { // Tier 3
-                    speedMultiplier = 8.0f;
-                    tier = 3;
-                } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.GOLD_TIER)) { // Tier 0
-                    speedMultiplier = 12.0f;
-                } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.NETHERITE_TIER)) { // Tier 4
-                    speedMultiplier = 9.0f;
-                    tier = 4;
-                }
+            toolSpeedData = getLegacyToolSpeedData(player, tool, block);
+        }
 
-                if (tier < 3 && player.tagManager.block(SyncedTags.NEEDS_DIAMOND_TOOL).contains(block.getType())) {
-                    isCorrectToolForDrop = false;
-                } else if (tier < 2 && player.tagManager.block(SyncedTags.NEEDS_IRON_TOOL).contains(block.getType())) {
-                    isCorrectToolForDrop = false;
-                } else if (tier < 1 && player.tagManager.block(SyncedTags.NEEDS_STONE_TOOL).contains(block.getType())) {
-                    isCorrectToolForDrop = false;
-                }
-            }
+        final float speedMultiplier = getSpeedMultiplierFromToolData(player, tool, toolSpeedData);
 
-            // Shears can mine some blocks faster
-            if (toolType == ItemTypes.SHEARS) {
-                isCorrectToolForDrop = true;
-
-                if (block.getType() == StateTypes.COBWEB || Materials.isLeaves(block.getType())) {
-                    speedMultiplier = 15.0f;
-                } else if (BlockTags.WOOL.contains(block.getType())) {
-                    speedMultiplier = 5.0f;
-                } else if (block.getType() == StateTypes.VINE ||
-                        block.getType() == StateTypes.GLOW_LICHEN) {
-                    speedMultiplier = 2.0f;
-                } else {
-                    isCorrectToolForDrop = block.getType() == StateTypes.COBWEB ||
-                            block.getType() == StateTypes.REDSTONE_WIRE ||
-                            block.getType() == StateTypes.TRIPWIRE;
-                }
-            }
+        final boolean canHarvest = !block.isRequiresCorrectTool() || toolSpeedData.isCorrectToolForDrop
+                // temporary hardcode to workaround PE bug https://github.com/retrooper/packetevents/issues/1217; see https://github.com/GrimAnticheat/Grim/issues/2091
+                || player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_4) && HARVESTABLE_TYPES_1_21_4.contains(block);
 
-            // Swords can also mine some blocks faster
-            if (toolType.hasAttribute(ItemTypes.ItemAttribute.SWORD)) {
-                if (block.getType() == StateTypes.COBWEB) {
-                    speedMultiplier = 15.0f;
-                } else if (player.tagManager.block(SyncedTags.SWORD_EFFICIENT).contains(block.getType())) {
-                    speedMultiplier = 1.5f;
-                }
+        float damage = speedMultiplier / blockHardness;
+        damage /= canHarvest ? 30F : 100F;
+        return damage;
+    }
 
-                isCorrectToolForDrop = block.getType() == StateTypes.COBWEB;
-            }
-        }
+    private static float getSpeedMultiplierFromToolData(GrimPlayer player, ItemStack tool, ToolSpeedData data) {
+        float speedMultiplier = data.speedMultiplier;
 
         if (speedMultiplier > 1.0f) {
             if (player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21) && PacketEvents.getAPI().getServerManager().getVersion().isNewerThanOrEquals(ServerVersion.V_1_21)) {
@@ -262,13 +167,138 @@ public static double getBlockDamage(GrimPlayer player, WrappedBlockState block)
             speedMultiplier /= 5;
         }
 
-        float damage = speedMultiplier / blockHardness;
+        return speedMultiplier;
+    }
 
-        boolean canHarvest = !block.getType().isRequiresCorrectTool() || isCorrectToolForDrop
-                // temporary hardcode to workaround PE bug https://github.com/retrooper/packetevents/issues/1217; see https://github.com/GrimAnticheat/Grim/issues/2091
-                || player.getClientVersion().isNewerThanOrEquals(ClientVersion.V_1_21_4) && HARVESTABLE_TYPES_1_21_4.contains(block.getType());
-        damage /= canHarvest ? 30F : 100F;
+    // TODO technically its possible to use packet level manipulation to enforce Tool rules on newer clients on older servers
+    // But I've yet to hear of anyone even trying to do such a thing rather than just update the server
+    // And we can't support this because we don't see the tool components/data before Via
+    private static ToolSpeedData getModernToolSpeedData(GrimPlayer player, ItemStack tool, StateType block) {
+        Optional<ItemTool> toolComponentOpt = tool.getComponent(ComponentTypes.TOOL);
+        float speedMultiplier = 1.0f;
+        boolean isCorrectToolForDrop = false;
+        if (toolComponentOpt.isPresent()) {
+            ItemTool itemTool = toolComponentOpt.get();
+
+            // Initialize with final default values. These will be used if the loop doesn't find a value.
+            // isCorrectToolForDrop is already set to false, no need to set again as default
+            speedMultiplier = itemTool.getDefaultMiningSpeed();
+
+            boolean speedFound = false;
+            boolean dropsFound = false;
+
+            for (ItemTool.Rule rule : itemTool.getRules()) {
+                MappedEntitySet<StateType.Mapped> predicate = rule.getBlocks();
+                ResourceLocation tagKey = predicate.getTagKey();
+                boolean isMatch;
+
+                // First, determine if the current rule even applies to this block.
+                if (tagKey != null) {
+                    SyncedTag<StateType> playerTag = player.tagManager.block(tagKey);
+                    isMatch = (playerTag != null && playerTag.contains(block))
+                            || BlockTags.getByName(tagKey.getKey()).contains(block);
+                } else {
+                    isMatch = predicate.getEntities().contains(block.getMapped());
+                }
 
-        return damage;
+                // If the rule matches the block, check if we still need its properties.
+                if (isMatch) {
+                    // Check for speed if we haven't found it yet.
+                    if (!speedFound && rule.getSpeed() != null) {
+                        speedMultiplier = rule.getSpeed();
+                        speedFound = true;
+                    }
+
+                    // Check for drops if we haven't found it yet.
+                    if (!dropsFound && rule.getCorrectForDrops() != null) {
+                        isCorrectToolForDrop = rule.getCorrectForDrops();
+                        dropsFound = true;
+                    }
+                }
+
+                if (speedFound && dropsFound) {
+                    break;
+                }
+            }
+        }
+        return new ToolSpeedData(speedMultiplier, isCorrectToolForDrop);
+    }
+
+    private static ToolSpeedData getLegacyToolSpeedData(GrimPlayer player, ItemStack tool, StateType block) {
+        ItemType toolType = tool.getType();
+        float speedMultiplier = 1.0f;
+        boolean isCorrectToolForDrop = false;
+        // 1.13 and below need their own huge methods to support this...
+        if (toolType.hasAttribute(ItemTypes.ItemAttribute.AXE)) {
+            isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_AXE).contains(block);
+        } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.PICKAXE)) {
+            isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_PICKAXE).contains(block);
+        } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.SHOVEL)) {
+            isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_SHOVEL).contains(block);
+        } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.HOE)) {
+            isCorrectToolForDrop = player.tagManager.block(SyncedTags.MINEABLE_HOE).contains(block);
+        }
+
+        if (isCorrectToolForDrop) {
+            int tier = 0;
+            if (toolType.hasAttribute(ItemTypes.ItemAttribute.WOOD_TIER)) { // Tier 0
+                speedMultiplier = 2.0f;
+            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.STONE_TIER)) { // Tier 1
+                speedMultiplier = 4.0f;
+                tier = 1;
+            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.IRON_TIER)) { // Tier 2
+                speedMultiplier = 6.0f;
+                tier = 2;
+            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.DIAMOND_TIER)) { // Tier 3
+                speedMultiplier = 8.0f;
+                tier = 3;
+            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.GOLD_TIER)) { // Tier 0
+                speedMultiplier = 12.0f;
+            } else if (toolType.hasAttribute(ItemTypes.ItemAttribute.NETHERITE_TIER)) { // Tier 4
+                speedMultiplier = 9.0f;
+                tier = 4;
+            }
+
+            if (tier < 3 && player.tagManager.block(SyncedTags.NEEDS_DIAMOND_TOOL).contains(block)) {
+                isCorrectToolForDrop = false;
+            } else if (tier < 2 && player.tagManager.block(SyncedTags.NEEDS_IRON_TOOL).contains(block)) {
+                isCorrectToolForDrop = false;
+            } else if (tier < 1 && player.tagManager.block(SyncedTags.NEEDS_STONE_TOOL).contains(block)) {
+                isCorrectToolForDrop = false;
+            }
+        }
+
+        // Shears can mine some blocks faster
+        if (toolType == ItemTypes.SHEARS) {
+            isCorrectToolForDrop = true;
+
+            if (block == StateTypes.COBWEB || Materials.isLeaves(block)) {
+                speedMultiplier = 15.0f;
+            } else if (BlockTags.WOOL.contains(block)) {
+                speedMultiplier = 5.0f;
+            } else if (block == StateTypes.VINE ||
+                    block == StateTypes.GLOW_LICHEN) {
+                speedMultiplier = 2.0f;
+            } else {
+                isCorrectToolForDrop = block == StateTypes.COBWEB ||
+                        block == StateTypes.REDSTONE_WIRE ||
+                        block == StateTypes.TRIPWIRE;
+            }
+        }
+
+        // Swords can also mine some blocks faster
+        if (toolType.hasAttribute(ItemTypes.ItemAttribute.SWORD)) {
+            if (block == StateTypes.COBWEB) {
+                speedMultiplier = 15.0f;
+            } else if (player.tagManager.block(SyncedTags.SWORD_EFFICIENT).contains(block)) {
+                speedMultiplier = 1.5f;
+            }
+
+            isCorrectToolForDrop = block == StateTypes.COBWEB;
+        }
+        //
+        return new ToolSpeedData(speedMultiplier, isCorrectToolForDrop);
     }
+
+
 }