Continued removal of capturing lambdas

pupnewfster · pupnewfster · commit b61e724c442c · 2024-04-09T13:43:13.000-05:00
diff --git a/src/main/java/mekanism/common/item/ItemConfigurator.java b/src/main/java/mekanism/common/item/ItemConfigurator.java
@@ -142,7 +142,7 @@ public InteractionResult useOn(UseOnContext context) {
                     //TODO: Switch this to items being handled by TileEntityMekanism, energy handled here (via lambdas?)
                     for (IInventorySlot inventorySlot : inv.getInventorySlots(null)) {
                         if (!inventorySlot.isEmpty()) {
-                            InventoryUtils.dropStack(inventorySlot.getStack().copy(), slotStack -> Block.popResourceFromFace(world, pos, side, slotStack));
+                            InventoryUtils.dropStack(world, pos, side, inventorySlot.getStack().copy(), Block::popResourceFromFace);
                             inventorySlot.setEmpty();
                         }
                     }
diff --git a/src/main/java/mekanism/common/tile/laser/TileEntityLaserTractorBeam.java b/src/main/java/mekanism/common/tile/laser/TileEntityLaserTractorBeam.java
@@ -27,7 +27,6 @@
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.state.BlockState;
-import net.neoforged.neoforge.common.util.Lazy;
 import org.jetbrains.annotations.NotNull;
 
 public class TileEntityLaserTractorBeam extends TileEntityLaserReceptor {
@@ -65,9 +64,8 @@ protected void handleBreakBlock(BlockState state, BlockPos hitPos, Player player
         breakBlock(state, hitPos);
         CommonWorldTickHandler.fallbackItemCollector = null;
         if (!drops.isEmpty()) {
-            Lazy<Direction> direction = Lazy.of(this::getDirection);
-            Lazy<BlockPos> dropPos = Lazy.of(() -> worldPosition.relative(direction.get(), 2));
-            Lazy<Direction> opposite = Lazy.of(() -> direction.get().getOpposite());
+            BlockPos dropPos = null;
+            Direction opposite = null;
             List<IInventorySlot> inventorySlots = getInventorySlots(null);
             for (ItemStack drop : drops) {
                 //Try inserting it first where it can stack and then into empty slots
@@ -76,7 +74,12 @@ protected void handleBreakBlock(BlockState state, BlockPos hitPos, Player player
                     //If we have some drop left over that we couldn't fit, then spawn it into the world
                     // Note: We use an adjusted position and an opposite direction to provide the item with momentum towards the tractor beam
                     // so that even though we couldn't fit the items into our inventory we can still have them appear to be "pulled" to the tractor beam
-                    Block.popResourceFromFace(level, dropPos.get(), opposite.get(), drop);
+                    if (dropPos == null) {
+                        Direction direction = getDirection();
+                        dropPos = worldPosition.relative(direction, 2);
+                        opposite = direction.getOpposite();
+                    }
+                    Block.popResourceFromFace(level, dropPos, opposite, drop);
                 }
             }
         }
diff --git a/src/main/java/mekanism/common/util/InventoryUtils.java b/src/main/java/mekanism/common/util/InventoryUtils.java
@@ -5,7 +5,6 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
-import java.util.function.Consumer;
 import java.util.function.Function;
 import mekanism.api.Action;
 import mekanism.api.AutomationType;
@@ -43,7 +42,8 @@ private InventoryUtils() {
      */
     public static void dropItemContents(ItemEntity entity, DamageSource source) {
         ItemStack stack = entity.getItem();
-        if (!entity.level().isClientSide && !stack.isEmpty()) {
+        Level level = entity.level();
+        if (!level.isClientSide && !stack.isEmpty()) {
             if (source.getEntity() instanceof Player player) {
                 //If the destroyer is a player use security utils to properly check for access
                 if (!IItemSecurityUtils.INSTANCE.canAccess(player, stack)) {
@@ -54,40 +54,42 @@ public static void dropItemContents(ItemEntity entity, DamageSource source) {
                 return;
             }
             int scalar = stack.getCount();
-            Consumer<ItemStack> dropper = slotStack -> entity.level().addFreshEntity(new ItemEntity(entity.level(), entity.getX(), entity.getY(), entity.getZ(), slotStack));
+            BlockPos blockPos = entity.blockPosition();
+            ItemDropper dropper = (lvl, pos, ignored, slotStack) -> lvl.addFreshEntity(new ItemEntity(lvl, pos.getX(), pos.getY(), pos.getZ(), slotStack));
             //Note: This instanceof check must be checked before the container type to allow overriding what contents can be dropped
             if (stack.getItem() instanceof IDroppableContents inventory) {
                 if (inventory.canContentsDrop(stack)) {
                     scalar = inventory.getScalar(stack);
-                    dropItemContents(inventory.getDroppedSlots(stack), scalar, dropper);
+                    dropItemContents(level, blockPos, inventory.getDroppedSlots(stack), scalar, dropper);
                 } else {
                     //Explicitly denying dropping items
                     return;
                 }
             } else if (ContainerType.ITEM.supports(stack)) {
-                dropItemContents(ContainerType.ITEM.getAttachmentContainersIfPresent(stack), scalar, dropper);
+                dropItemContents(level, blockPos, ContainerType.ITEM.getAttachmentContainersIfPresent(stack), scalar, dropper);
             }
             Optional<UpgradeAware> existingUpgrades = stack.getExistingData(MekanismAttachmentTypes.UPGRADES);
             if (existingUpgrades.isPresent()) {
                 UpgradeAware upgradeAware = existingUpgrades.get();
-                dropItemContents(upgradeAware.getInventorySlots(null), scalar, dropper);
-                dropItemContents(upgradeAware.getUpgrades().entrySet(), scalar, dropper, entry -> UpgradeUtils.getStack(entry.getKey(), entry.getValue()));
+                dropItemContents(level, blockPos, upgradeAware.getInventorySlots(null), scalar, dropper);
+                dropItemContents(level, blockPos, upgradeAware.getUpgrades().entrySet(), scalar, dropper, entry -> UpgradeUtils.getStack(entry.getKey(), entry.getValue()));
             }
             IModuleContainer moduleContainer = IModuleHelper.INSTANCE.getModuleContainerNullable(stack);
             if (moduleContainer != null) {
-                dropItemContents(moduleContainer.modules(), scalar, dropper, module -> module.getData().getItemProvider().getItemStack(module.getInstalledCount()));
+                dropItemContents(level, blockPos, moduleContainer.modules(), scalar, dropper, module -> module.getData().getItemProvider().getItemStack(module.getInstalledCount()));
             }
         }
     }
 
-    private static void dropItemContents(List<IInventorySlot> slots, int scalar, Consumer<ItemStack> dropper) {
-        dropItemContents(slots, scalar, dropper, slot -> slot.getStack().copy());
+    private static void dropItemContents(Level level, BlockPos pos, List<IInventorySlot> slots, int scalar, ItemDropper dropper) {
+        dropItemContents(level, pos, slots, scalar, dropper, slot -> slot.getStack().copy());
     }
 
     /**
      * @param stackExtractor It is expected the stack returned by the stack extractor can be safely mutated
      */
-    private static <T> void dropItemContents(Collection<T> toDrop, int scalar, Consumer<ItemStack> dropper, Function<T, ItemStack> stackExtractor) {
+    private static <T> void dropItemContents(Level level, BlockPos pos, Collection<T> toDrop, int scalar, ItemDropper dropper,
+          Function<T, ItemStack> stackExtractor) {
         for (T drop : toDrop) {
             ItemStack stackToDrop = stackExtractor.apply(drop);
             if (!stackToDrop.isEmpty()) {
@@ -106,7 +108,7 @@ private static <T> void dropItemContents(Collection<T> toDrop, int scalar, Consu
                     }
                 }
                 //Copy the stack as the passed slot is likely to be the actual backing slot
-                dropStack(stackToDrop, dropper);
+                dropStack(level, pos, null, stackToDrop, dropper);
             }
         }
     }
@@ -117,23 +119,23 @@ private static <T> void dropItemContents(Collection<T> toDrop, int scalar, Consu
      * @param stack   Item Stack to drop, may be passed directly to the dropper.
      * @param dropper Called to drop the item.
      */
-    public static void dropStack(ItemStack stack, Consumer<ItemStack> dropper) {
+    public static void dropStack(Level level, BlockPos pos, Direction side, ItemStack stack, ItemDropper dropper) {
         int count = stack.getCount();
         int max = stack.getMaxStackSize();
         if (count > max) {
             //If we have more than a stack of the item (such as we are a bin) or some other thing that allows for compressing
             // stack counts, drop as many stacks as we need at their max size
             while (count > max) {
-                dropper.accept(stack.copyWithCount(max));
+                dropper.drop(level, pos, side, stack.copyWithCount(max));
                 count -= max;
             }
             if (count > 0) {
                 //If we have anything left to drop afterward, do so
-                dropper.accept(stack.copyWithCount(count));
+                dropper.drop(level, pos, side, stack.copyWithCount(count));
             }
         } else {
             //If we have a valid stack, we can just directly drop that instead without requiring any copies
-            dropper.accept(stack);
+            dropper.drop(level, pos, side, stack);
         }
     }
 
@@ -226,4 +228,9 @@ public static ItemStack insertItem(List<? extends IInventorySlot> slots, @NotNul
         }
         return stack;
     }
+
+    public interface ItemDropper {
+
+        void drop(Level level, BlockPos pos, Direction side, ItemStack stack);
+    }
 }
diff --git a/src/main/java/mekanism/common/util/MekanismUtils.java b/src/main/java/mekanism/common/util/MekanismUtils.java
@@ -552,10 +552,12 @@ private static void onChangedPotionEffect(LivingEntity entity, MobEffectInstance
     }
 
     public static boolean isSameTypeFactory(Block block, Block factoryBlockType) {
-        return Attribute.matches(block, AttributeFactoryType.class, attribute -> {
+        AttributeFactoryType attribute = Attribute.get(block, AttributeFactoryType.class);
+        if (attribute != null) {
             AttributeFactoryType otherType = Attribute.get(factoryBlockType, AttributeFactoryType.class);
             return otherType != null && attribute.getFactoryType() == otherType.getFactoryType();
-        });
+        }
+        return false;
     }
 
     /**
diff --git a/src/main/java/mekanism/common/util/StorageUtils.java b/src/main/java/mekanism/common/util/StorageUtils.java
@@ -2,7 +2,7 @@
 
 import java.util.List;
 import java.util.Optional;
-import java.util.function.Function;
+import java.util.function.BiFunction;
 import mekanism.api.Action;
 import mekanism.api.chemical.Chemical;
 import mekanism.api.chemical.ChemicalStack;
@@ -72,17 +72,17 @@ public static void addStoredGas(@NotNull ItemStack stack, @NotNull List<Componen
 
     public static void addStoredGas(@NotNull ItemStack stack, @NotNull List<Component> tooltip, boolean showMissingCap, boolean showAttributes,
           ILangEntry emptyLangEntry) {
-        addStoredChemical(stack, tooltip, showMissingCap, showAttributes, emptyLangEntry, stored -> {
+        addStoredChemical(stack, tooltip, showMissingCap, showAttributes, emptyLangEntry, (stored, emptyLang) -> {
             if (stored.isEmpty()) {
-                return emptyLangEntry.translateColored(EnumColor.GRAY);
+                return emptyLang.translateColored(EnumColor.GRAY);
             }
             return MekanismLang.STORED.translateColored(EnumColor.ORANGE, EnumColor.ORANGE, stored, EnumColor.GRAY,
                   MekanismLang.GENERIC_MB.translate(TextUtils.format(stored.getAmount())));
         }, Capabilities.GAS.item(), ContainerType.GAS);
     }
 
     public static <CHEMICAL extends Chemical<CHEMICAL>, STACK extends ChemicalStack<CHEMICAL>> void addStoredChemical(@NotNull ItemStack stack, @NotNull List<Component> tooltip,
-          boolean showMissingCap, boolean showAttributes, ILangEntry emptyLangEntry, Function<STACK, Component> storedFunction, ItemCapability<? extends IChemicalHandler<CHEMICAL, STACK>, Void> capability,
+          boolean showMissingCap, boolean showAttributes, ILangEntry emptyLangEntry, BiFunction<STACK, ILangEntry, Component> storedFunction, ItemCapability<? extends IChemicalHandler<CHEMICAL, STACK>, Void> capability,
           ContainerType<?, ? extends IChemicalHandler<CHEMICAL, STACK>, ?> containerType) {
         IChemicalHandler<CHEMICAL, STACK> handler = stack.getCapability(capability);
         if (handler == null) {
@@ -92,7 +92,7 @@ public static <CHEMICAL extends Chemical<CHEMICAL>, STACK extends ChemicalStack<
         if (handler != null) {
             for (int tank = 0, tanks = handler.getTanks(); tank < tanks; tank++) {
                 STACK chemicalInTank = handler.getChemicalInTank(tank);
-                tooltip.add(storedFunction.apply(chemicalInTank));
+                tooltip.add(storedFunction.apply(chemicalInTank, emptyLangEntry));
                 if (showAttributes) {
                     ChemicalUtil.addAttributeTooltips(tooltip, chemicalInTank.getType());
                 }
@@ -107,25 +107,25 @@ public static void addStoredFluid(@NotNull ItemStack stack, @NotNull List<Compon
     }
 
     public static void addStoredFluid(@NotNull ItemStack stack, @NotNull List<Component> tooltip, boolean showMissingCap, ILangEntry emptyLangEntry) {
-        addStoredFluid(stack, tooltip, showMissingCap, emptyLangEntry, stored -> {
+        addStoredFluid(stack, tooltip, showMissingCap, emptyLangEntry, (stored, emptyLang) -> {
             if (stored.isEmpty()) {
-                return emptyLangEntry.translateColored(EnumColor.GRAY);
+                return emptyLang.translateColored(EnumColor.GRAY);
             }
             return MekanismLang.STORED.translateColored(EnumColor.ORANGE, EnumColor.ORANGE, stored, EnumColor.GRAY,
                   MekanismLang.GENERIC_MB.translate(TextUtils.format(stored.getAmount())));
         });
     }
 
     public static void addStoredFluid(@NotNull ItemStack stack, @NotNull List<Component> tooltip, boolean showMissingCap, ILangEntry emptyLangEntry,
-          Function<FluidStack, Component> storedFunction) {
+          BiFunction<FluidStack, ILangEntry, Component> storedFunction) {
         IFluidHandlerItem handler = Capabilities.FLUID.getCapability(stack);
         if (handler == null) {
             //Fall back to trying to look up the stored fluid by the container type if the stack doesn't expose it
             handler = (IFluidHandlerItem) ContainerType.FLUID.getAttachmentIfPresent(stack);
         }
         if (handler != null) {
             for (int tank = 0, tanks = handler.getTanks(); tank < tanks; tank++) {
-                tooltip.add(storedFunction.apply(handler.getFluidInTank(tank)));
+                tooltip.add(storedFunction.apply(handler.getFluidInTank(tank), emptyLangEntry));
             }
         } else if (showMissingCap) {
             tooltip.add(emptyLangEntry.translate());
diff --git a/src/main/java/mekanism/common/util/TransporterUtils.java b/src/main/java/mekanism/common/util/TransporterUtils.java
@@ -75,7 +75,7 @@ public static void drop(LogisticalTransporterBase transporter, TransporterStack
             blockPos = transporter.getBlockPos();
         }
         TransporterManager.remove(transporter.getLevel(), stack);
-        InventoryUtils.dropStack(stack.itemStack, item -> Block.popResource(transporter.getLevel(), blockPos, item));
+        InventoryUtils.dropStack(transporter.getLevel(), blockPos, null, stack.itemStack, (level, pos, ignored, item) -> Block.popResource(level, pos, item));
     }
 
     public static float[] getStackPosition(LogisticalTransporterBase transporter, TransporterStack stack, float partial) {

Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ public InteractionResult useOn(UseOnContext context) {`
`142`	`142`	`//TODO: Switch this to items being handled by TileEntityMekanism, energy handled here (via lambdas?)`
`143`	`143`	`for (IInventorySlot inventorySlot : inv.getInventorySlots(null)) {`
`144`	`144`	`if (!inventorySlot.isEmpty()) {`
`145`		`- InventoryUtils.dropStack(inventorySlot.getStack().copy(), slotStack -> Block.popResourceFromFace(world, pos, side, slotStack));`
	`145`	`+ InventoryUtils.dropStack(world, pos, side, inventorySlot.getStack().copy(), Block::popResourceFromFace);`
`146`	`146`	`inventorySlot.setEmpty();`
`147`	`147`	`}`
`148`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -552,10 +552,12 @@ private static void onChangedPotionEffect(LivingEntity entity, MobEffectInstance`
`552`	`552`	`}`
`553`	`553`
`554`	`554`	`public static boolean isSameTypeFactory(Block block, Block factoryBlockType) {`
`555`		`- return Attribute.matches(block, AttributeFactoryType.class, attribute -> {`
	`555`	`+ AttributeFactoryType attribute = Attribute.get(block, AttributeFactoryType.class);`
	`556`	`+ if (attribute != null) {`
`556`	`557`	`AttributeFactoryType otherType = Attribute.get(factoryBlockType, AttributeFactoryType.class);`
`557`	`558`	`return otherType != null && attribute.getFactoryType() == otherType.getFactoryType();`
`558`		`- });`
	`559`	`+ }`
	`560`	`+ return false;`
`559`	`561`	`}`
`560`	`562`
`561`	`563`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public static void drop(LogisticalTransporterBase transporter, TransporterStack`
`75`	`75`	`blockPos = transporter.getBlockPos();`
`76`	`76`	`}`
`77`	`77`	`TransporterManager.remove(transporter.getLevel(), stack);`
`78`		`- InventoryUtils.dropStack(stack.itemStack, item -> Block.popResource(transporter.getLevel(), blockPos, item));`
	`78`	`+ InventoryUtils.dropStack(transporter.getLevel(), blockPos, null, stack.itemStack, (level, pos, ignored, item) -> Block.popResource(level, pos, item));`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`public static float[] getStackPosition(LogisticalTransporterBase transporter, TransporterStack stack, float partial) {`