Remove capturing lambda's from vein and blast mining calculations

Author: pupnewfster

src/main/java/mekanism/common/item/gear/ItemAtomicDisassembler.java

@@ -174,9 +174,11 @@ public boolean onBlockStartBreak(ItemStack stack, BlockPos pos, Player player) {
             if (energyContainer.extract(energyRequired, Action.SIMULATE, AutomationType.MANUAL).greaterOrEqual(energyRequired)) {
                 // Only allow mining things that are considered an ore
                 if (ModuleVeinMiningUnit.canVeinBlock(state) && state.is(MekanismTags.Blocks.ATOMIC_DISASSEMBLER_ORE)) {
-                    Object2IntMap<BlockPos> found = ModuleVeinMiningUnit.findPositions(world, Map.of(pos, state), 0, Reference2BooleanMaps.singleton(state.getBlock(), true));
-                    MekanismUtils.veinMineArea(energyContainer, energyRequired, world, pos, (ServerPlayer) player, stack, this, found, hardness -> FloatingLong.ZERO,
-                          (hardness, distance, bs) -> getDestroyEnergy(baseDestroyEnergy, hardness).multiply(0.5 * Math.pow(distance, 1.5)));
+                    Object2IntMap<BlockPos> found = ModuleVeinMiningUnit.findPositions(world, Map.of(pos, state), 0,
+                          Reference2BooleanMaps.singleton(state.getBlock(), true));
+                    MekanismUtils.veinMineArea(energyContainer, energyRequired, FloatingLong.ZERO, baseDestroyEnergy, world, pos, (ServerPlayer) player, stack,
+                          this, found, (base, hardness) -> FloatingLong.ZERO,
+                          (base, hardness, distance, bs) -> getDestroyEnergy(base, hardness).multiply(0.5 * Math.pow(distance, 1.5)));
                 }
             }
         }
@@ -187,7 +189,7 @@ private FloatingLong getDestroyEnergy(ItemStack itemStack, float hardness) {
         return getDestroyEnergy(getDestroyEnergy(itemStack), hardness);
     }
 
-    private FloatingLong getDestroyEnergy(FloatingLong baseDestroyEnergy, float hardness) {
+    private static FloatingLong getDestroyEnergy(FloatingLong baseDestroyEnergy, float hardness) {
         return hardness == 0 ? baseDestroyEnergy.divide(2) : baseDestroyEnergy;
     }
 

src/main/java/mekanism/common/item/gear/ItemMekaTool.java

@@ -309,9 +309,9 @@ public boolean onBlockStartBreak(ItemStack stack, BlockPos pos, Player player) {
                 if (!veinedBlocks.isEmpty()) {
                     //Don't include bonus energy required by efficiency modules when calculating energy of vein mining targets
                     FloatingLong baseDestroyEnergy = getDestroyEnergy(silk);
-                    MekanismUtils.veinMineArea(energyContainer, energyRequired, world, pos, (ServerPlayer) player, stack, this, veinedBlocks,
-                          hardness -> getDestroyEnergy(modDestroyEnergy, hardness),
-                          (hardness, distance, bs) -> getDestroyEnergy(baseDestroyEnergy, hardness).multiply(0.5 * Math.pow(distance, oreTracker.getBoolean(bs.getBlock()) ? 1.5 : 2)));
+                    MekanismUtils.veinMineArea(energyContainer, energyRequired, modDestroyEnergy, baseDestroyEnergy, world, pos, (ServerPlayer) player, stack, this, veinedBlocks,
+                          ItemMekaTool::getDestroyEnergy, (base, hardness, distance, bs) -> getDestroyEnergy(base, hardness)
+                                .multiply(0.5 * Math.pow(distance, bs.is(MekanismTags.Blocks.ATOMIC_DISASSEMBLER_ORE) ? 1.5 : 2)));
                 }
             }
         }
@@ -322,17 +322,17 @@ private static FloatingLong getDestroyEnergy(boolean silk) {
         return silk ? MekanismConfig.gear.mekaToolEnergyUsageSilk.get() : MekanismConfig.gear.mekaToolEnergyUsage.get();
     }
 
-    public FloatingLong getDestroyEnergy(ItemStack itemStack, float hardness, boolean silk) {
+    public static FloatingLong getDestroyEnergy(ItemStack itemStack, float hardness, boolean silk) {
         return getDestroyEnergy(getDestroyEnergy(itemStack, silk), hardness);
     }
 
     private static FloatingLong getDestroyEnergy(FloatingLong baseDestroyEnergy, float hardness) {
         return hardness == 0 ? baseDestroyEnergy.divide(2) : baseDestroyEnergy;
     }
 
-    private FloatingLong getDestroyEnergy(ItemStack itemStack, boolean silk) {
+    private static FloatingLong getDestroyEnergy(ItemStack itemStack, boolean silk) {
         FloatingLong destroyEnergy = getDestroyEnergy(silk);
-        IModule<ModuleExcavationEscalationUnit> module = getEnabledModule(itemStack, MekanismModules.EXCAVATION_ESCALATION_UNIT);
+        IModule<ModuleExcavationEscalationUnit> module = IModuleHelper.INSTANCE.getIfEnabled(itemStack, MekanismModules.EXCAVATION_ESCALATION_UNIT);
         float efficiency = module == null ? MekanismConfig.gear.mekaToolBaseEfficiency.get() : module.getCustomInstance().getEfficiency();
         return destroyEnergy.multiply(efficiency);
     }

src/main/java/mekanism/common/util/MekanismUtils.java

@@ -721,8 +721,9 @@ public static Map<FluidType, FluidInDetails> getFluidsIn(Player player, double d
         return fluidsIn;
     }
 
-    public static void veinMineArea(IEnergyContainer energyContainer, FloatingLong energyRequired, Level world, BlockPos pos, ServerPlayer player, ItemStack stack, Item usedTool,
-          Object2IntMap<BlockPos> found, BlastEnergyFunction blastEnergy, VeinEnergyFunction veinEnergy) {
+    public static void veinMineArea(IEnergyContainer energyContainer, FloatingLong energyRequired, FloatingLong baseBlastEnergy, FloatingLong baseVeinEnergy,
+          Level world, BlockPos pos, ServerPlayer player, ItemStack stack, Item usedTool, Object2IntMap<BlockPos> found, BlastEnergyFunction blastEnergy,
+          VeinEnergyFunction veinEnergy) {
         FloatingLong energyUsed = FloatingLong.ZERO;
         FloatingLong energyAvailable = energyContainer.getEnergy();
         //Subtract from our available energy the amount that we will require to break the target block
@@ -741,7 +742,7 @@ public static void veinMineArea(IEnergyContainer energyContainer, FloatingLong e
                 continue;
             }
             int distance = foundEntry.getIntValue();
-            FloatingLong destroyEnergy = distance == 0 ? blastEnergy.calc(hardness) : veinEnergy.calc(hardness, distance, targetState);
+            FloatingLong destroyEnergy = distance == 0 ? blastEnergy.calc(baseBlastEnergy, hardness) : veinEnergy.calc(baseVeinEnergy, hardness, distance, targetState);
             if (energyUsed.add(destroyEnergy).greaterThan(energyAvailable)) {
                 //If we don't have energy to break the block continue
                 //Note: We do not break as given the energy scales with hardness, so it is possible we still have energy to break another block
@@ -824,12 +825,12 @@ public double getMaxHeight() {
     @FunctionalInterface
     public interface BlastEnergyFunction {
 
-        FloatingLong calc(float hardness);
+        FloatingLong calc(FloatingLong baseBlastEnergy, float hardness);
     }
 
     @FunctionalInterface
     public interface VeinEnergyFunction {
 
-        FloatingLong calc(float hardness, int distance, BlockState state);
+        FloatingLong calc(FloatingLong baseVeinEnergy, float hardness, int distance, BlockState state);
     }
 }