Clean up unused, duplicated, and/or unnecessary tool handling code

src/main/java/com/gregtechceu/gtceu/api/item/IGTTool.java

@@ -138,13 +138,11 @@ default Material getToolMaterial(ItemStack stack) {
         return GTMaterials.Iron;
     }
 
-    @Nullable
-    default ToolProperty getToolProperty() {
+    default @Nullable ToolProperty getToolProperty() {
         return getMaterial().getProperty(PropertyKey.TOOL);
     }
 
-    @Nullable
-    default DustProperty getDustProperty(ItemStack stack) {
+    default @Nullable DustProperty getDustProperty(ItemStack stack) {
         return getToolMaterial(stack).getProperty(PropertyKey.DUST);
     }
 
@@ -257,76 +255,55 @@ default int getTotalHarvestLevel() {
         return getMaterialHarvestLevel() + getToolStats().getBaseQuality();
     }
 
-    // Item.class methods
-    default float definition$getDestroySpeed(ItemStack stack, BlockState state) {
-        if (isToolEffective(stack, state, getToolClasses(stack), getTotalHarvestLevel())) {
-            return getTotalToolSpeed();
-        }
-
-        return getToolStats().isToolEffective(state) ? getToolStats().getTool().getMiningSpeed(state) : 1.0F;
-    }
-
     default boolean definition$hurtEnemy(ItemStack stack, LivingEntity target, LivingEntity attacker) {
         getBehaviorsComponent(stack).behaviors()
                 .forEach((key, behavior) -> behavior.hitEntity(stack, target, attacker));
         damageItem(stack, attacker, getToolStats().getToolDamagePerAttack(stack));
         return true;
     }
 
-    default boolean definition$onBlockStartBreak(ItemStack stack, BlockPos pos, Player player) {
-        if (player.level().isClientSide) return false;
+    default void definition$onBlockStartBreak(ItemStack stack, BlockPos pos, Player player) {
+        if (!(player instanceof ServerPlayer serverPlayer)) return;
+        if (player.isShiftKeyDown()) return;
+
         getBehaviorsComponent(stack).behaviors()
                 .forEach((type, behavior) -> behavior.onBlockStartBreak(stack, pos, player));
 
-        if (!player.isShiftKeyDown()) {
-            ServerPlayer serverPlayer = (ServerPlayer) player;
-            int result = -1;
-            if (isTool(stack, GTToolType.SHEARS)) {
-                result = shearBlockRoutine(serverPlayer, stack, pos);
-            }
-            if (result != 0) {
-                // prevent exploits with instantly breakable blocks
-                BlockState state = player.level().getBlockState(pos);
-                boolean effective = isToolEffective(stack, state, getToolClasses(stack), getTotalHarvestLevel());
-
-                if (effective) {
-                    if (areaOfEffectBlockBreakRoutine(stack, serverPlayer, pos)) {
-                        if (playSoundOnBlockDestroy()) playSound(player);
-                    } else {
-                        if (result == -1) {
-                            var behavior = getBehaviorsComponent(stack).getBehavior(GTToolBehaviors.TREE_FELLING);
-                            if (behavior != null && behavior.isEnabled() && state.is(BlockTags.LOGS)) {
-                                TreeFellingHelper.fellTree(stack, player.level(), state, pos, player);
-                            }
-                            if (playSoundOnBlockDestroy()) playSound(player);
-                        } else {
-                            return true;
-                        }
-                    }
-                }
+        // prevent exploits with instantly breakable blocks
+        BlockState state = player.level().getBlockState(pos);
+
+        if (!isToolEffective(stack, state)) {
+            return;
+        }
+        if (!areaOfEffectBlockBreakRoutine(stack, serverPlayer, pos)) {
+            var behavior = getBehaviorsComponent(stack).getBehavior(GTToolBehaviors.TREE_FELLING);
+            if (behavior != null && behavior.isEnabled() && state.is(BlockTags.LOGS)) {
+                TreeFellingHelper.fellTree(stack, player.level(), state, pos, player);
             }
         }
-        return false;
+        if (playSoundOnBlockDestroy()) {
+            playSound(player);
+        }
     }
 
-    default boolean definition$mineBlock(ItemStack stack, Level worldIn, BlockState state, BlockPos pos,
-                                         LivingEntity entityLiving) {
-        if (!worldIn.isClientSide) {
-            getToolStats().getBehaviors()
-                    .forEach(behavior -> behavior.onBlockDestroyed(stack, worldIn, state, pos, entityLiving));
+    default void definition$mineBlock(ItemStack stack, Level level, BlockState state, BlockPos pos,
+                                      LivingEntity entity) {
+        if (level.isClientSide) {
+            return;
+        }
+        getToolStats().getBehaviors()
+                .forEach(behavior -> behavior.onBlockDestroyed(stack, level, state, pos, entity));
 
-            if ((double) state.getDestroySpeed(worldIn, pos) != 0.0D) {
-                damageItem(stack, entityLiving, getToolStats().getToolDamagePerBlockBreak(stack));
-            }
-            if (entityLiving instanceof Player && playSoundOnBlockDestroy()) {
-                // sneaking disables AOE, which means it is okay to play the sound
-                // not checking this means the sound will play for every AOE broken block, which is very loud
-                if (entityLiving.isShiftKeyDown()) {
-                    playSound((Player) entityLiving);
-                }
+        if (state.getDestroySpeed(level, pos) != 0.0) {
+            damageItem(stack, entity, getToolStats().getToolDamagePerBlockBreak(stack));
+        }
+        if (entity instanceof Player player && playSoundOnBlockDestroy()) {
+            // sneaking disables AOE, which means it is okay to play the sound
+            // not checking this means the sound will play for every AOE broken block, which is very loud
+            if (entity.isShiftKeyDown()) {
+                playSound(player);
             }
         }
-        return true;
     }
 
     default boolean definition$isValidRepairItem(ItemStack toRepair, ItemStack repair) {
@@ -414,8 +391,7 @@ private static ItemEnchantments joinEnchants(ItemStack stackWithEnchants, ItemEn
                 .anyMatch(behavior -> behavior.canDisableShield(stack, shield, entity, attacker));
     }
 
-    default boolean definition$doesSneakBypassUse(@NotNull ItemStack stack, @NotNull BlockGetter world,
-                                                  @NotNull BlockPos pos, @NotNull Player player) {
+    default boolean definition$doesSneakBypassUse(ItemStack stack, BlockGetter world, BlockPos pos, Player player) {
         return getToolStats().doesSneakBypassUse();
     }
 
@@ -556,16 +532,16 @@ private static ItemEnchantments joinEnchants(ItemStack stackWithEnchants, ItemEn
         return true;
     }
 
-    default void definition$fillItemCategory(CreativeModeTab category, @NotNull NonNullList<ItemStack> items) {
+    default void definition$fillItemCategory(CreativeModeTab category, NonNullList<ItemStack> items) {
         if (isElectric()) {
             items.add(get(Integer.MAX_VALUE));
         } else {
             items.add(get());
         }
     }
 
-    default void definition$appendHoverText(@NotNull ItemStack stack, @NotNull Item.TooltipContext context,
-                                            @NotNull List<Component> tooltip, TooltipFlag flag) {
+    default void definition$appendHoverText(ItemStack stack, Item.TooltipContext context,
+                                            List<Component> tooltip, TooltipFlag flag) {
         if (!(stack.getItem() instanceof IGTTool tool)) return;
 
         IGTToolDefinition toolStats = tool.getToolStats();
@@ -751,13 +727,6 @@ default void attachCapabilities(RegisterCapabilitiesEvent event) {
         }
     }
 
-    default boolean definition$isCorrectToolForDrops(ItemStack stack, BlockState state) {
-        if (stack.getItem() instanceof IGTTool gtTool) {
-            return isToolEffective(stack, state, gtTool.getToolClasses(stack), gtTool.getTotalHarvestLevel());
-        }
-        return stack.isCorrectToolForDrops(state);
-    }
-
     static int tintColor(ItemStack stack, int index) {
         if (stack.getItem() instanceof IGTTool item) {
             Material material = item.getMaterial();

src/main/java/com/gregtechceu/gtceu/api/item/datacomponents/ToolBehaviors.java

@@ -10,6 +10,7 @@
 import net.minecraft.network.codec.StreamCodec;
 
 import com.mojang.serialization.Codec;
+import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.Unmodifiable;
 
 import java.util.Collections;
@@ -44,7 +45,7 @@ public boolean hasBehavior(ToolBehaviorType<?> type) {
         return behaviors.containsKey(type);
     }
 
-    public <T extends IToolBehavior<T>> T getBehavior(ToolBehaviorType<T> type) {
+    public <T extends IToolBehavior<T>> @Nullable T getBehavior(ToolBehaviorType<T> type) {
         return (T) this.behaviors.get(type);
     }
 

src/main/java/com/gregtechceu/gtceu/api/item/tool/GTToolItem.java

@@ -54,11 +54,6 @@ public GTToolItem(GTToolType toolType, MaterialToolTier tier, Material material,
         definition$init();
     }
 
-    public static GTToolItem create(GTToolType toolType, MaterialToolTier tier, Material material,
-                                    IGTToolDefinition definition, Properties properties) {
-        return new GTToolItem(toolType, tier, material, definition, properties);
-    }
-
     @Override
     public ItemStack getDefaultInstance() {
         return get();
@@ -96,7 +91,8 @@ public Component getName(ItemStack stack) {
 
     @Override
     public boolean mineBlock(ItemStack stack, Level level, BlockState state, BlockPos pos, LivingEntity miningEntity) {
-        return definition$mineBlock(stack, level, state, pos, miningEntity);
+        definition$mineBlock(stack, level, state, pos, miningEntity);
+        return true;
     }
 
     @Override
@@ -115,20 +111,11 @@ public boolean playSoundOnBlockDestroy() {
         return toolType.playSoundOnBlockDestroy;
     }
 
-    @Override
-    public float getDestroySpeed(ItemStack stack, BlockState state) {
-        return definition$getDestroySpeed(stack, state);
-    }
-
     @Override
     public boolean hurtEnemy(ItemStack stack, LivingEntity target, LivingEntity attacker) {
         return definition$hurtEnemy(stack, target, attacker);
     }
 
-    public boolean onBlockStartBreak(ItemStack stack, BlockPos pos, Player player) {
-        return definition$onBlockStartBreak(stack, pos, player);
-    }
-
     @Override
     public void appendHoverText(ItemStack stack, TooltipContext context, List<Component> tooltipComponents,
                                 TooltipFlag isAdvanced) {
@@ -189,9 +176,4 @@ public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStac
     public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
         return definition$use(level, player, usedHand);
     }
-
-    @Override
-    public boolean isCorrectToolForDrops(ItemStack stack, BlockState state) {
-        return this.definition$isCorrectToolForDrops(stack, state);
-    }
 }

src/main/java/com/gregtechceu/gtceu/api/item/tool/GTToolType.java

@@ -658,7 +658,7 @@ public static class Builder {
         @Setter
         private char symbol = ' ';
         @Setter
-        private ToolConstructor constructor = GTToolItem::create;
+        private ToolConstructor constructor = GTToolItem::new;
         @Setter
         private ResourceLocation modelLocation;
         private SoundEntry sound;

src/main/java/com/gregtechceu/gtceu/api/item/tool/MaterialToolTier.java

@@ -42,7 +42,7 @@ public float getAttackDamageBonus() {
     }
 
     @Override
-    public @NotNull TagKey<Block> getIncorrectBlocksForDrops() {
+    public TagKey<Block> getIncorrectBlocksForDrops() {
         return CustomTags.INCORRECT_TOOL_TIERS[property.getHarvestLevel()];
     }