diff --git a/src/api/java/mekanism/api/gear/IModuleHelper.java b/src/api/java/mekanism/api/gear/IModuleHelper.java index f0dbc977a30..4c30eb3920e 100644 --- a/src/api/java/mekanism/api/gear/IModuleHelper.java +++ b/src/api/java/mekanism/api/gear/IModuleHelper.java @@ -100,7 +100,7 @@ public interface IModuleHelper { * @return {@code true} if the item has the module installed and enabled. */ default boolean isEnabled(ItemStack stack, IModuleDataProvider typeProvider) { - IModuleContainer container = getModuleContainer(stack).orElse(null); + IModuleContainer container = getModuleContainerNullable(stack); return container != null && container.hasEnabled(typeProvider); } @@ -114,7 +114,7 @@ default boolean isEnabled(ItemStack stack, IModuleDataProvider typeProvider) */ @Nullable default > IModule load(ItemStack stack, IModuleDataProvider typeProvider) { - IModuleContainer container = getModuleContainer(stack).orElse(null); + IModuleContainer container = getModuleContainerNullable(stack); return container == null ? null : container.get(typeProvider); } @@ -125,7 +125,15 @@ default > IModule load(ItemStack st * * @since 10.5.0 */ - Optional getModuleContainer(ItemStack stack); + @Deprecated(forRemoval = true) + default Optional getModuleContainer(ItemStack stack) { + return Optional.ofNullable(getModuleContainerNullable(stack)); + } + + @Nullable + IModuleContainer getModuleContainerNullable(ItemStack stack); + + @Nullable > IModule getModule(ItemStack stack, IModuleDataProvider typeProvider); /** * {@return module container for the item in entity's equipment slot, or empty if it is empty or not a module container} @@ -135,11 +143,17 @@ default > IModule load(ItemStack st * * @since 10.5.0 */ + @Deprecated(forRemoval = true) default Optional getModuleContainer(@Nullable LivingEntity entity, @Nullable EquipmentSlot slot) { + return Optional.ofNullable(getModuleContainerNullable(entity, slot)); + } + + @Nullable + default IModuleContainer getModuleContainerNullable(@Nullable LivingEntity entity, @Nullable EquipmentSlot slot) { if (entity == null || slot == null) { - return Optional.empty(); + return null; } - return getModuleContainer(entity.getItemBySlot(slot)); + return getModuleContainerNullable(entity.getItemBySlot(slot)); } /** @@ -172,9 +186,8 @@ default boolean isModuleContainer(ItemStack stack) { * @param stack Module container, for example a Meka-Tool or MekaSuit piece. */ default Collection> loadAll(ItemStack stack) { - return getModuleContainer(stack) - .map(IModuleContainer::modules) - .orElse(List.of()); + IModuleContainer container = getModuleContainerNullable(stack); + return container != null ? container.modules() : List.of(); } /** @@ -204,9 +217,8 @@ default > List> loadAllTypes(ItemStack stack) { - return getModuleContainer(stack) - .map(IModuleContainer::moduleTypes) - .orElse(Set.of()); + IModuleContainer container = getModuleContainerNullable(stack); + return container != null ? container.moduleTypes() : Set.of(); } /** @@ -277,4 +289,16 @@ default void addMekaSuitModuleModelSpec(String name, IModuleDataProvider modu * @apiNote Must only be called on the client side and from {@link FMLClientSetupEvent}. */ void addMekaSuitModuleModelSpec(String name, IModuleDataProvider moduleDataProvider, EquipmentSlot slotType, Predicate isActive); + + @Nullable + default > IModule getIfEnabled(ItemStack stack, IModuleDataProvider typeProvider) { + IModuleContainer container = getModuleContainerNullable(stack); + return container == null ? null : container.getIfEnabled(typeProvider); + } + + @Nullable + default > IModule getIfEnabled(@Nullable LivingEntity entity, @Nullable EquipmentSlot slot, IModuleDataProvider typeProvider) { + IModuleContainer container = getModuleContainerNullable(entity, slot); + return container == null ? null : container.getIfEnabled(typeProvider); + } } \ No newline at end of file diff --git a/src/main/java/mekanism/client/ClientRegistration.java b/src/main/java/mekanism/client/ClientRegistration.java index 5b5f27c6e4f..3ec04e2fcfd 100644 --- a/src/main/java/mekanism/client/ClientRegistration.java +++ b/src/main/java/mekanism/client/ClientRegistration.java @@ -7,6 +7,8 @@ import java.util.Map; import java.util.Objects; import java.util.concurrent.ConcurrentHashMap; +import mekanism.api.gear.IModule; +import mekanism.api.gear.IModuleContainer; import mekanism.api.gear.IModuleHelper; import mekanism.api.providers.IItemProvider; import mekanism.api.text.EnumColor; @@ -148,6 +150,7 @@ import mekanism.common.Mekanism; import mekanism.common.attachments.FormulaAttachment; import mekanism.common.block.attribute.Attribute; +import mekanism.common.content.gear.shared.ModuleColorModulationUnit; import mekanism.common.item.ItemConfigurationCard; import mekanism.common.item.block.machine.ItemBlockFluidTank; import mekanism.common.lib.FieldReflectionHelper; @@ -551,11 +554,12 @@ public static void registerItemColorHandlers(RegisterColorHandlersEvent.Item eve ClientRegistrationUtil.registerItemColorHandler(event, (stack, index) -> { if (index == 1) { - return IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(container -> container.get(MekanismModules.COLOR_MODULATION_UNIT)) - .map(colorModulation -> colorModulation.getCustomInstance().getColor()) - .map(color -> color.toTint().argb()) - .orElse(-1); + IModule colorModulationUnit = IModuleHelper.INSTANCE.getModule(stack, MekanismModules.COLOR_MODULATION_UNIT); + if (colorModulationUnit == null) { + return -1; + } else { + return colorModulationUnit.getCustomInstance().getColor().toTint().argb();//todo store tint argb on the unit? + } } return -1; }, MekanismItems.MEKASUIT_HELMET, MekanismItems.MEKASUIT_BODYARMOR, MekanismItems.MEKASUIT_PANTS, MekanismItems.MEKASUIT_BOOTS); diff --git a/src/main/java/mekanism/client/ClientTickHandler.java b/src/main/java/mekanism/client/ClientTickHandler.java index fca4fbe4493..14ced403176 100644 --- a/src/main/java/mekanism/client/ClientTickHandler.java +++ b/src/main/java/mekanism/client/ClientTickHandler.java @@ -117,7 +117,7 @@ public static boolean isGravitationalModulationOn(Player player) { } public static boolean isVisionEnhancementOn(Player player) { - IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.HEAD).orElse(null); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(player, EquipmentSlot.HEAD); if (container != null && !container.isContainerOnCooldown(player)) { IModule module = container.getIfEnabled(MekanismModules.VISION_ENHANCEMENT_UNIT); return module != null && module.hasEnoughEnergy(MekanismConfig.gear.mekaSuitEnergyUsageVisionEnhancement); @@ -306,9 +306,8 @@ public void onFogLighting(ViewportEvent.ComputeFogColor event) { @SubscribeEvent public void onFog(ViewportEvent.RenderFog event) { if (visionEnhancement && event.getCamera().getEntity() instanceof Player player) { - IModule module = IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.HEAD) - .map(container -> container.getIfEnabled(MekanismModules.VISION_ENHANCEMENT_UNIT)) - .orElse(null); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(player, EquipmentSlot.HEAD); + IModule module = container != null ? container.getIfEnabled(MekanismModules.VISION_ENHANCEMENT_UNIT) : null; if (module != null) { //This near plane is the same as spectators have set for lava and powdered snow event.setNearPlaneDistance(-8.0F); diff --git a/src/main/java/mekanism/client/gui/element/custom/module/ColorSelection.java b/src/main/java/mekanism/client/gui/element/custom/module/ColorSelection.java index 7eff8faf466..9b7f3d9e70a 100644 --- a/src/main/java/mekanism/client/gui/element/custom/module/ColorSelection.java +++ b/src/main/java/mekanism/client/gui/element/custom/module/ColorSelection.java @@ -1,9 +1,7 @@ package mekanism.client.gui.element.custom.module; -import java.util.Optional; import java.util.function.Consumer; import mekanism.api.gear.IModule; -import mekanism.api.gear.config.IModuleConfigItem; import mekanism.api.gear.config.ModuleColorData; import mekanism.client.gui.GuiModuleTweaker; import mekanism.client.gui.GuiUtils; @@ -11,6 +9,7 @@ import mekanism.client.gui.element.text.GuiTextField; import mekanism.client.gui.element.window.GuiColorWindow; import mekanism.common.MekanismLang; +import mekanism.common.content.gear.Module; import mekanism.common.content.gear.ModuleConfigItem; import mekanism.common.content.gear.ModuleHelper; import mekanism.common.content.gear.shared.ModuleColorModulationUnit; @@ -84,20 +83,18 @@ protected void click(double mouseX, double mouseY) { if (armorPreview != null && data.matches(MekanismModules.COLOR_MODULATION_UNIT, ModuleColorModulationUnit.COLOR_CONFIG_KEY) && currentModule != null) { ItemStack stack = currentModule.getContainer().getPreviewStack(); if (stack.getItem() instanceof ArmorItem armorItem) { - Optional> foundConfig = ModuleHelper.get().getModuleContainer(stack) - .map(container -> container.get(MekanismModules.COLOR_MODULATION_UNIT)) - .map(module -> module.getConfigItem(ModuleColorModulationUnit.COLOR_CONFIG_KEY)) - .filter(configItem -> configItem.getData() instanceof ModuleColorData) - .map(configItem -> (IModuleConfigItem) configItem); - if (foundConfig.isPresent()) { - IModuleConfigItem configItem = foundConfig.get(); - //Ensure the preview has been initialized - armorPreview.get(); - EquipmentSlot slot = armorItem.getEquipmentSlot(); - //Replace the current preview with our copy - armorPreview.updatePreview(slot, stack); - updatePreviewColor = c -> configItem.set(c.argb()); - previewReset = () -> armorPreview.resetToDefault(slot); + Module module = ModuleHelper.get().getModule(stack, MekanismModules.COLOR_MODULATION_UNIT); + if (module != null) { + ModuleColorData configItem = module.getConfigItemData(ModuleColorModulationUnit.COLOR_CONFIG_KEY, ModuleColorData.class); + if (configItem != null) { + //Ensure the preview has been initialized + armorPreview.get(); + EquipmentSlot slot = armorItem.getEquipmentSlot(); + //Replace the current preview with our copy + armorPreview.updatePreview(slot, stack); + updatePreviewColor = c -> configItem.set(c.argb()); + previewReset = () -> armorPreview.resetToDefault(slot); + } } } } diff --git a/src/main/java/mekanism/client/gui/element/scroll/GuiModuleScrollList.java b/src/main/java/mekanism/client/gui/element/scroll/GuiModuleScrollList.java index ed43fed62bb..c91b13d14da 100644 --- a/src/main/java/mekanism/client/gui/element/scroll/GuiModuleScrollList.java +++ b/src/main/java/mekanism/client/gui/element/scroll/GuiModuleScrollList.java @@ -50,7 +50,7 @@ public GuiModuleScrollList(IGuiWrapper gui, int x, int y, int width, int height, public void updateItemAndList(ItemStack stack) { currentItem = stack; - currentContainer = ModuleHelper.get().getModuleContainer(stack).orElse(null); + currentContainer = ModuleHelper.get().getModuleContainerNullable(stack); currentList.clear(); if (currentContainer != null) { currentList.addAll(currentContainer.moduleTypes()); diff --git a/src/main/java/mekanism/client/render/HUDRenderer.java b/src/main/java/mekanism/client/render/HUDRenderer.java index e95fc7ceef4..6764d21704b 100644 --- a/src/main/java/mekanism/client/render/HUDRenderer.java +++ b/src/main/java/mekanism/client/render/HUDRenderer.java @@ -123,9 +123,9 @@ private void renderMekaSuitModuleIcons(Player player, Font font, GuiGraphics gui pose.pushPose(); //Render any elements that might be on modules in the meka suit while worn or on the meka tool while held for (EquipmentSlot type : EQUIPMENT_ORDER) { - Optional moduleContainer = IModuleHelper.INSTANCE.getModuleContainer(player, type); - if (moduleContainer.isPresent()) { - for (IHUDElement element : moduleContainer.get().getHUDElements(player)) { + IModuleContainer moduleContainer = IModuleHelper.INSTANCE.getModuleContainerNullable(player, type); + if (moduleContainer != null) { + for (IHUDElement element : moduleContainer.getHUDElements(player)) { curY -= 18; if (reverseHud) { //Align the mekasuit module icons to the left of the screen diff --git a/src/main/java/mekanism/client/render/armor/MekaSuitArmor.java b/src/main/java/mekanism/client/render/armor/MekaSuitArmor.java index d3269a66c19..0557ea29276 100644 --- a/src/main/java/mekanism/client/render/armor/MekaSuitArmor.java +++ b/src/main/java/mekanism/client/render/armor/MekaSuitArmor.java @@ -27,6 +27,7 @@ import java.util.Set; import java.util.UUID; import java.util.function.Predicate; +import mekanism.api.gear.IModule; import mekanism.api.gear.IModuleContainer; import mekanism.api.gear.IModuleHelper; import mekanism.api.gear.ModuleData; @@ -40,6 +41,7 @@ import mekanism.client.render.lib.QuickHash; import mekanism.client.render.lib.effect.BoltRenderer; import mekanism.common.Mekanism; +import mekanism.common.content.gear.shared.ModuleColorModulationUnit; import mekanism.common.item.gear.ItemMekaSuitArmor; import mekanism.common.item.gear.ItemMekaTool; import mekanism.common.lib.Color; @@ -112,10 +114,8 @@ private MekaSuitArmor(EquipmentSlot type, EquipmentSlot adjacentType) { } private static Color getColor(ItemStack stack) { - return IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(container -> container.get(MekanismModules.COLOR_MODULATION_UNIT)) - .map(module -> module.getCustomInstance().getColor()) - .orElse(Color.WHITE); + IModule colorUnit = IModuleHelper.INSTANCE.getModule(stack, MekanismModules.COLOR_MODULATION_UNIT); + return colorUnit != null ? colorUnit.getCustomInstance().getColor() : Color.WHITE; } public void renderArm(HumanoidModel baseModel, @NotNull PoseStack matrix, @NotNull MultiBufferSource renderer, int light, int overlayLight, @@ -540,10 +540,8 @@ public QuickHash key(LivingEntity player) { Object2BooleanMap modules = new Object2BooleanOpenHashMap<>(); Set wornParts = EnumSet.noneOf(EquipmentSlot.class); for (EquipmentSlot slotType : EnumUtils.ARMOR_SLOTS) { - Optional optionalIModuleContainer = IModuleHelper.INSTANCE.getModuleContainer(player, slotType) - .filter(container -> container.isInstance(ItemMekaSuitArmor.class)); - if (optionalIModuleContainer.isPresent()) { - IModuleContainer container = optionalIModuleContainer.get(); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(player, slotType); + if (container != null && container.isInstance(ItemMekaSuitArmor.class)) { wornParts.add(slotType); for (Entry, ModuleModelSpec> entry : moduleModelSpec.row(slotType).entrySet()) { if (container.hasEnabled(entry.getKey())) { diff --git a/src/main/java/mekanism/client/render/hud/MekanismHUD.java b/src/main/java/mekanism/client/render/hud/MekanismHUD.java index f5be40195bf..e32292bc81c 100644 --- a/src/main/java/mekanism/client/render/hud/MekanismHUD.java +++ b/src/main/java/mekanism/client/render/hud/MekanismHUD.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.List; import java.util.function.Consumer; +import mekanism.api.gear.IModuleContainer; import mekanism.api.gear.IModuleHelper; import mekanism.client.gui.GuiUtils; import mekanism.client.render.HUDRenderer; @@ -38,11 +39,11 @@ private MekanismHUD() { @Nullable private IItemHUDProvider getHudProvider(ItemStack stack) { if (stack.getItem() instanceof IItemHUDProvider hudProvider) { + //mekanism does this return hudProvider; } - return IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(container -> (list, player, s, slotType) -> list.addAll(container.getHUDStrings(player))) - .orElse(null); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + return container != null ? (list, player, s, slotType) -> list.addAll(container.getHUDStrings(player)) : null; } @Override diff --git a/src/main/java/mekanism/common/CommonPlayerTickHandler.java b/src/main/java/mekanism/common/CommonPlayerTickHandler.java index 398dd29890d..791abc63a6c 100644 --- a/src/main/java/mekanism/common/CommonPlayerTickHandler.java +++ b/src/main/java/mekanism/common/CommonPlayerTickHandler.java @@ -9,12 +9,14 @@ import mekanism.api.energy.IEnergyContainer; import mekanism.api.functions.FloatSupplier; import mekanism.api.gear.IModule; +import mekanism.api.gear.IModuleContainer; import mekanism.api.gear.IModuleHelper; import mekanism.api.math.FloatingLong; import mekanism.api.math.FloatingLongSupplier; import mekanism.common.base.KeySync; import mekanism.common.config.MekanismConfig; import mekanism.common.content.gear.IBlastingItem; +import mekanism.common.content.gear.mekasuit.ModuleGravitationalModulatingUnit; import mekanism.common.content.gear.mekasuit.ModuleHydraulicPropulsionUnit; import mekanism.common.content.gear.mekasuit.ModuleHydrostaticRepulsorUnit; import mekanism.common.content.gear.mekasuit.ModuleLocomotiveBoostingUnit; @@ -87,18 +89,14 @@ public static float getStepBoost(Player player) { } else if (stack.getItem() instanceof ItemFreeRunners freeRunners && freeRunners.getMode(stack).providesStepBoost()) { return 0.5F; } - return IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(container -> container.getIfEnabled(MekanismModules.HYDRAULIC_PROPULSION_UNIT)) - .map(module -> module.getCustomInstance().getStepHeight()) - .orElse(0F); + IModule hydraulic = IModuleHelper.INSTANCE.getIfEnabled(stack, MekanismModules.HYDRAULIC_PROPULSION_UNIT); + return hydraulic != null ? hydraulic.getCustomInstance().getStepHeight() : 0F; } public static float getSwimBoost(Player player) { - Optional> swimModule = IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.LEGS) - .map(container -> container.getIfEnabled(MekanismModules.HYDROSTATIC_REPULSOR_UNIT)); - if (swimModule.isPresent()) { - IModule module = swimModule.get(); - if (module.getCustomInstance().isSwimBoost(module, player)) { + IModule swimModule = IModuleHelper.INSTANCE.getIfEnabled(player, EquipmentSlot.LEGS, MekanismModules.HYDROSTATIC_REPULSOR_UNIT); + if (swimModule != null) { + if (swimModule.getCustomInstance().isSwimBoost(swimModule, player)) { return 1; } } @@ -184,10 +182,8 @@ public static boolean isGravitationalModulationReady(Player player) { } public static boolean isGravitationalModulationReady(ItemStack stack) { - return IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(container -> container.getIfEnabled(MekanismModules.GRAVITATIONAL_MODULATING_UNIT)) - .filter(module -> module.hasEnoughEnergy(MekanismConfig.gear.mekaSuitEnergyUsageGravitationalModulation)) - .isPresent(); + IModule module = IModuleHelper.INSTANCE.getIfEnabled(stack, MekanismModules.GRAVITATIONAL_MODULATING_UNIT); + return module != null && module.hasEnoughEnergy(MekanismConfig.gear.mekaSuitEnergyUsageGravitationalModulation); } @@ -290,22 +286,18 @@ public void livingFall(LivingFallEvent event) { @SubscribeEvent public void onLivingJump(LivingJumpEvent event) { if (event.getEntity() instanceof Player player) { - Optional> propulsionModule = IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.FEET) - .map(container -> container.getIfEnabled(MekanismModules.HYDRAULIC_PROPULSION_UNIT)); - if (propulsionModule.isPresent() && Mekanism.keyMap.has(player.getUUID(), KeySync.BOOST)) { - IModule module = propulsionModule.get(); - float boost = module.getCustomInstance().getBoost(); + IModule propulsionModule = IModuleHelper.INSTANCE.getIfEnabled(player, EquipmentSlot.FEET, MekanismModules.HYDRAULIC_PROPULSION_UNIT); + if (propulsionModule != null && Mekanism.keyMap.has(player.getUUID(), KeySync.BOOST)) { + float boost = propulsionModule.getCustomInstance().getBoost(); FloatingLong usage = MekanismConfig.gear.mekaSuitBaseJumpEnergyUsage.get().multiply(boost / 0.1F); - if (module.canUseEnergy(player, usage)) { + if (propulsionModule.canUseEnergy(player, usage)) { // if we're sprinting with the boost module, limit the height - IModule boostModule = IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.LEGS) - .map(container -> container.getIfEnabled(MekanismModules.LOCOMOTIVE_BOOSTING_UNIT)) - .orElse(null); + IModule boostModule = IModuleHelper.INSTANCE.getIfEnabled(player, EquipmentSlot.LEGS, MekanismModules.LOCOMOTIVE_BOOSTING_UNIT); if (boostModule != null && boostModule.getCustomInstance().canFunction(boostModule, player)) { boost = Mth.sqrt(boost); } player.addDeltaMovement(new Vec3(0, boost, 0)); - module.useEnergy(player, usage, true); + propulsionModule.useEnergy(player, usage, true); } } } @@ -361,9 +353,7 @@ public void getBreakSpeed(BreakSpeed event) { } //Gyroscopic stabilization check - if (IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.LEGS) - .filter(container -> container.hasEnabled(MekanismModules.GYROSCOPIC_STABILIZATION_UNIT)) - .isPresent()) { + if (IModuleHelper.INSTANCE.isEnabled(player.getItemBySlot(EquipmentSlot.LEGS), MekanismModules.GYROSCOPIC_STABILIZATION_UNIT)) { if (player.isEyeInFluidType(NeoForgeMod.WATER_TYPE.value()) && !EnchantmentHelper.hasAquaAffinity(player)) { speed *= 5.0F; } diff --git a/src/main/java/mekanism/common/base/PlayerState.java b/src/main/java/mekanism/common/base/PlayerState.java index 7de288c533e..d399b695c91 100644 --- a/src/main/java/mekanism/common/base/PlayerState.java +++ b/src/main/java/mekanism/common/base/PlayerState.java @@ -237,16 +237,14 @@ public void updateFlightInfo(Player player) { } if (CommonPlayerTickHandler.isGravitationalModulationReady(player) && player.getAbilities().flying) { //If the player is actively flying (not just allowed to), and has the gravitational modulator ready then apply movement boost if active, and use energy - Optional> module = IModuleHelper.INSTANCE.getModuleContainer(player, EquipmentSlot.CHEST) - .map(container -> container.get(MekanismModules.GRAVITATIONAL_MODULATING_UNIT)); - if (module.isPresent()) {//Should not be null but double check - IModule gravUnit = module.get(); + IModule module = IModuleHelper.INSTANCE.getModule(player.getItemBySlot(EquipmentSlot.CHEST), MekanismModules.GRAVITATIONAL_MODULATING_UNIT); + if (module != null) {//Should not be null but double check FloatingLong usage = MekanismConfig.gear.mekaSuitEnergyUsageGravitationalModulation.get(); Holder gameEvent = MekanismGameEvents.GRAVITY_MODULATE; if (Mekanism.keyMap.has(player.getUUID(), KeySync.BOOST)) { FloatingLong boostUsage = usage.multiply(4); - if (gravUnit.canUseEnergy(player, boostUsage, false)) { - float boost = gravUnit.getCustomInstance().getBoost(); + if (module.canUseEnergy(player, boostUsage, false)) { + float boost = module.getCustomInstance().getBoost(); if (boost > 0) { player.moveRelative(boost, ModuleGravitationalModulatingUnit.BOOST_VEC); usage = boostUsage; @@ -254,7 +252,7 @@ public void updateFlightInfo(Player player) { } } } - gravUnit.useEnergy(player, usage); + module.useEnergy(player, usage); if (MekanismConfig.gear.mekaSuitGravitationalVibrations.get() && player.level().getGameTime() % MekanismUtils.TICKS_PER_HALF_SECOND == 0) { player.gameEvent(gameEvent.value()); } diff --git a/src/main/java/mekanism/common/content/gear/IModuleContainerItem.java b/src/main/java/mekanism/common/content/gear/IModuleContainerItem.java index ecdbe9f0b47..66026c91d19 100644 --- a/src/main/java/mekanism/common/content/gear/IModuleContainerItem.java +++ b/src/main/java/mekanism/common/content/gear/IModuleContainerItem.java @@ -2,7 +2,6 @@ import java.util.Collection; import java.util.List; -import java.util.Optional; import mekanism.api.gear.ICustomModule; import mekanism.api.gear.IModule; import mekanism.api.gear.IModuleContainer; @@ -23,25 +22,23 @@ public interface IModuleContainerItem extends IModeItem, IItemHUDProvider { - default Optional moduleContainer(ItemStack stack) { - return IModuleHelper.INSTANCE.getModuleContainer(stack); + default IModuleContainer moduleContainer(ItemStack stack) { + return IModuleHelper.INSTANCE.getModuleContainerNullable(stack); } default Collection> getModules(ItemStack stack) { - return moduleContainer(stack) - .map(IModuleContainer::modules) - .orElse(List.of()); + IModuleContainer container = moduleContainer(stack); + return container != null ? container.modules() : List.of(); } default boolean hasInstalledModules(ItemStack stack) { - return moduleContainer(stack) - .filter(container -> container.installedCount() > 0) - .isPresent(); + IModuleContainer container = moduleContainer(stack); + return container != null && container.installedCount() > 0; } @Nullable default > IModule getEnabledModule(ItemStack stack, IModuleDataProvider typeProvider) { - IModuleContainer container = moduleContainer(stack).orElse(null); + IModuleContainer container = moduleContainer(stack); return container == null ? null : container.getIfEnabled(typeProvider); } @@ -58,21 +55,20 @@ default void addModuleDetails(ItemStack stack, List tooltip) { } default boolean hasModule(ItemStack stack, IModuleDataProvider type) { - IModuleContainer container = moduleContainer(stack).orElse(null); + IModuleContainer container = moduleContainer(stack); return container != null && container.has(type); } default boolean isModuleEnabled(ItemStack stack, IModuleDataProvider type) { - IModuleContainer container = moduleContainer(stack).orElse(null); + IModuleContainer container = moduleContainer(stack); return container != null && container.hasEnabled(type); } @Override default void addHUDStrings(List list, Player player, ItemStack stack, EquipmentSlot slotType) { - Optional moduleContainer = moduleContainer(stack); - //noinspection OptionalIsPresent - Capturing lambda - if (moduleContainer.isPresent()) { - list.addAll(moduleContainer.get().getHUDStrings(player)); + IModuleContainer moduleContainer = moduleContainer(stack); + if (moduleContainer != null) { + list.addAll(moduleContainer.getHUDStrings(player)); } } @@ -88,7 +84,15 @@ default void changeMode(@NotNull Player player, @NotNull ItemStack stack, int sh @Override default boolean supportsSlotType(ItemStack stack, @NotNull EquipmentSlot slotType) { - return IModeItem.super.supportsSlotType(stack, slotType) && getModules(stack).stream().anyMatch(IModule::handlesAnyModeChange); + if (!IModeItem.super.supportsSlotType(stack, slotType)) { + return false; + } + for (IModule iModule : getModules(stack)) { + if (iModule.handlesAnyModeChange()) { + return true; + } + } + return false; } @Nullable diff --git a/src/main/java/mekanism/common/content/gear/Module.java b/src/main/java/mekanism/common/content/gear/Module.java index 6a946bf4d47..63839b1e12c 100644 --- a/src/main/java/mekanism/common/content/gear/Module.java +++ b/src/main/java/mekanism/common/content/gear/Module.java @@ -307,6 +307,15 @@ public ModuleConfigItem getConfigItem(String name) { return configItems.get(name); } + @Nullable + public > TYPE getConfigItemData(String name, Class dataType) { + ModuleConfigItem configItem = getConfigItem(name); + if (configItem != null && dataType.isInstance(configItem.getData())) { + return dataType.cast(configItem.getData()); + } + return null; + } + public Collection> getConfigItems() { return configItemsView; } diff --git a/src/main/java/mekanism/common/content/gear/ModuleDispenseBehavior.java b/src/main/java/mekanism/common/content/gear/ModuleDispenseBehavior.java index 842be4f1216..c86dae7fa55 100644 --- a/src/main/java/mekanism/common/content/gear/ModuleDispenseBehavior.java +++ b/src/main/java/mekanism/common/content/gear/ModuleDispenseBehavior.java @@ -25,9 +25,8 @@ protected ItemStack execute(@NotNull BlockSource source, @NotNull ItemStack stac return stack; } boolean preventDrop = result == ModuleDispenseResult.FAIL_PREVENT_DROP; - Collection> modules = IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(IModuleContainer::modules) - .orElse(List.of()); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + Collection> modules = container != null ? container.modules() : List.of(); for (IModule module : modules) { if (module.isEnabled()) { result = onModuleDispense(module, source); diff --git a/src/main/java/mekanism/common/content/gear/ModuleHelper.java b/src/main/java/mekanism/common/content/gear/ModuleHelper.java index c03b6d46712..23bf04821d3 100644 --- a/src/main/java/mekanism/common/content/gear/ModuleHelper.java +++ b/src/main/java/mekanism/common/content/gear/ModuleHelper.java @@ -13,8 +13,11 @@ import mekanism.api.MekanismIMC; import mekanism.api.MekanismIMC.ModuleContainerTarget; import mekanism.api.annotations.NothingNullByDefault; +import mekanism.api.gear.ICustomModule; import mekanism.api.gear.IHUDElement; import mekanism.api.gear.IHUDElement.HUDColor; +import mekanism.api.gear.IModule; +import mekanism.api.gear.IModuleContainer; import mekanism.api.gear.IModuleHelper; import mekanism.api.gear.ModuleData; import mekanism.api.providers.IModuleDataProvider; @@ -36,6 +39,7 @@ import net.minecraft.world.item.Item; import net.minecraft.world.item.ItemStack; import net.neoforged.fml.event.lifecycle.InterModProcessEvent; +import org.jetbrains.annotations.Nullable; /** * @apiNote Do not instantiate this class directly as it will be done via the service loader. Instead, access instances of this via {@link IModuleHelper#INSTANCE} @@ -153,8 +157,9 @@ public Set> getConflicting(IModuleDataProvider typeProvider) { } @Override - public Optional getModuleContainer(ItemStack stack) { - return isModuleContainer(stack) ? Optional.of(stack.getData(MekanismAttachmentTypes.MODULE_CONTAINER)) : Optional.empty(); + @Nullable + public ModuleContainer getModuleContainerNullable(ItemStack stack) { + return isModuleContainer(stack) ? stack.getData(MekanismAttachmentTypes.MODULE_CONTAINER) : null; } @Override @@ -186,4 +191,9 @@ public synchronized void addMekaSuitModuleModels(ResourceLocation location) { public synchronized void addMekaSuitModuleModelSpec(String name, IModuleDataProvider moduleDataProvider, EquipmentSlot slotType, Predicate isActive) { MekaSuitArmor.registerModule(name, moduleDataProvider, slotType, isActive); } + + public > Module getModule(ItemStack stack, IModuleDataProvider typeProvider) { + ModuleContainer container = getModuleContainerNullable(stack); + return container != null ? container.get(typeProvider) : null; + } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/content/gear/mekasuit/ModuleElectrolyticBreathingUnit.java b/src/main/java/mekanism/common/content/gear/mekasuit/ModuleElectrolyticBreathingUnit.java index ed52f062023..4f7487592b9 100644 --- a/src/main/java/mekanism/common/content/gear/mekasuit/ModuleElectrolyticBreathingUnit.java +++ b/src/main/java/mekanism/common/content/gear/mekasuit/ModuleElectrolyticBreathingUnit.java @@ -96,9 +96,7 @@ public void tickServer(IModule module, Player p */ private boolean checkChestPlate(ItemStack chestPlate) { if (chestPlate.is(MekanismItems.MEKASUIT_BODYARMOR)) { - return IModuleHelper.INSTANCE.getModuleContainer(chestPlate) - .map(container -> container.get(MekanismModules.JETPACK_UNIT)) - .isPresent(); + return IModuleHelper.INSTANCE.getModule(chestPlate, MekanismModules.JETPACK_UNIT) != null; } return true; } diff --git a/src/main/java/mekanism/common/content/gear/shared/ModuleEnergyUnit.java b/src/main/java/mekanism/common/content/gear/shared/ModuleEnergyUnit.java index b426ea6dd00..544a807f78d 100644 --- a/src/main/java/mekanism/common/content/gear/shared/ModuleEnergyUnit.java +++ b/src/main/java/mekanism/common/content/gear/shared/ModuleEnergyUnit.java @@ -22,13 +22,11 @@ public static FloatingLong getChargeRate(ItemStack stack, FloatingLong base) { } private static FloatingLong getEnergyValue(ItemStack stack, FloatingLong base) { - Optional> module = IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(container -> container.get(MekanismModules.ENERGY_UNIT)); - //noinspection OptionalIsPresent - Capturing lambda - if (module.isEmpty()) { + IModule module = IModuleHelper.INSTANCE.getModule(stack, MekanismModules.ENERGY_UNIT); + if (module == null) { return base; } - return base.multiply(Math.pow(2, module.get().getInstalledCount())); + return base.multiply(Math.pow(2, module.getInstalledCount())); } @Override diff --git a/src/main/java/mekanism/common/integration/crafttweaker/module/CrTModuleHelper.java b/src/main/java/mekanism/common/integration/crafttweaker/module/CrTModuleHelper.java index 7302e594887..c111c7dd5c6 100644 --- a/src/main/java/mekanism/common/integration/crafttweaker/module/CrTModuleHelper.java +++ b/src/main/java/mekanism/common/integration/crafttweaker/module/CrTModuleHelper.java @@ -105,6 +105,6 @@ public static Set> loadAllTypes(ItemStack stack) { } private static Optional container(ItemStack stack) { - return IModuleHelper.INSTANCE.getModuleContainer(stack); + return Optional.ofNullable(IModuleHelper.INSTANCE.getModuleContainerNullable(stack)); } } \ No newline at end of file diff --git a/src/main/java/mekanism/common/integration/projecte/processors/MekanismContentsProcessor.java b/src/main/java/mekanism/common/integration/projecte/processors/MekanismContentsProcessor.java index 412e6b705b5..fa1afadd1fc 100644 --- a/src/main/java/mekanism/common/integration/projecte/processors/MekanismContentsProcessor.java +++ b/src/main/java/mekanism/common/integration/projecte/processors/MekanismContentsProcessor.java @@ -53,9 +53,9 @@ public long recalculateEMC(@NotNull ItemInfo info, long currentEMC) throws Arith currentEMC = addEmc(emcProxy, currentEMC, upgradeAware.getInventorySlots(null)); } //Stored modules - Optional moduleContainer = IModuleHelper.INSTANCE.getModuleContainer(stack); - if (moduleContainer.isPresent()) { - for (IModule module : moduleContainer.get().modules()) { + IModuleContainer moduleContainer = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + if (moduleContainer != null) { + for (IModule module : moduleContainer.modules()) { ItemStack moduleStack = module.getData().getItemProvider().getItemStack(module.getInstalledCount()); currentEMC = addEmc(emcProxy, currentEMC, moduleStack); } diff --git a/src/main/java/mekanism/common/inventory/container/ModuleTweakerContainer.java b/src/main/java/mekanism/common/inventory/container/ModuleTweakerContainer.java index caf6a8447b8..a5c7b7e7f03 100644 --- a/src/main/java/mekanism/common/inventory/container/ModuleTweakerContainer.java +++ b/src/main/java/mekanism/common/inventory/container/ModuleTweakerContainer.java @@ -63,7 +63,7 @@ public boolean mayPlace(@NotNull ItemStack stack) { } public static boolean isTweakableItem(ItemStack stack) { - return IModuleHelper.INSTANCE.getModuleContainer(stack).isPresent(); + return IModuleHelper.INSTANCE.getModuleContainerNullable(stack) != null; } public static boolean hasTweakableItem(Player player) { diff --git a/src/main/java/mekanism/common/item/gear/ItemMekaSuitArmor.java b/src/main/java/mekanism/common/item/gear/ItemMekaSuitArmor.java index 8b38061e6ac..26dcfce689b 100644 --- a/src/main/java/mekanism/common/item/gear/ItemMekaSuitArmor.java +++ b/src/main/java/mekanism/common/item/gear/ItemMekaSuitArmor.java @@ -3,7 +3,6 @@ import com.google.common.collect.ImmutableMultimap; import com.google.common.collect.Multimap; import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Map; @@ -134,10 +133,8 @@ public ItemMekaSuitArmor(ArmorItem.Type armorType, Properties properties) { case CHESTPLATE -> { gasTankSpecs.add(ChemicalTankSpec.createFillOnly(MekanismConfig.gear.mekaSuitJetpackTransferRate, stack -> { //Note: We intentionally don't require the module to be enabled for purposes of calculating capacity - return moduleContainer(stack) - .map(container -> container.get(MekanismModules.JETPACK_UNIT)) - .map(moduleJetpackUnitIModule -> MekanismConfig.gear.mekaSuitJetpackMaxStorage.get() * moduleJetpackUnitIModule.getInstalledCount()) - .orElse(0L); + IModule module = IModuleHelper.INSTANCE.getModule(stack, MekanismModules.JETPACK_UNIT); + return module != null ? MekanismConfig.gear.mekaSuitJetpackMaxStorage.get() * module.getInstalledCount() : 0L; }, gas -> gas == MekanismGases.HYDROGEN.get(), stack -> hasModule(stack, MekanismModules.JETPACK_UNIT))); absorption = 0.4F; laserDissipation = 0.3; @@ -236,7 +233,7 @@ public boolean isNotReplaceableByPickAction(ItemStack stack, Player player, int @Override public int getEnchantmentLevel(ItemStack stack, Enchantment enchantment) { //Enchantments in our data - IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainer(stack).orElse(null); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); int moduleLevel = container == null ? 0 : container.getModuleEnchantmentLevel(enchantment); return Math.max(moduleLevel, super.getEnchantmentLevel(stack, enchantment)); } @@ -244,10 +241,9 @@ public int getEnchantmentLevel(ItemStack stack, Enchantment enchantment) { @Override public Map getAllEnchantments(ItemStack stack) { Map enchantments = super.getAllEnchantments(stack); - Optional> optionalEnchantmentMap = IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(IModuleContainer::moduleBasedEnchantments); - if (optionalEnchantmentMap.isPresent()) { - for (Entry entry : optionalEnchantmentMap.get().entrySet()) { + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + if (container != null) { + for (Entry entry : container.moduleBasedEnchantments().entrySet()) { enchantments.merge(entry.getKey(), entry.getValue(), Math::max); } } @@ -263,11 +259,11 @@ public void addItems(CreativeModeTab.Output tabOutput) { public void inventoryTick(@NotNull ItemStack stack, @NotNull Level level, @NotNull Entity entity, int slotId, boolean isSelected) { super.inventoryTick(stack, level, entity, slotId, isSelected); if (slotId >= Inventory.INVENTORY_SIZE && slotId < Inventory.INVENTORY_SIZE + 4 && entity instanceof Player player) { - Collection> modules = ModuleHelper.get().getModuleContainer(stack) - .map(ModuleContainer::modules) - .orElse(Collections.emptyList()); - for (Module module : modules) { - module.tick(player); + ModuleContainer container = ModuleHelper.get().getModuleContainerNullable(stack); + if (container != null) { + for (Module module : container.modules()) { + module.tick(player); + } } } } @@ -334,7 +330,7 @@ public boolean supportsSlotType(ItemStack stack, @NotNull EquipmentSlot slotType public boolean canElytraFly(ItemStack stack, LivingEntity entity) { if (getType() == ArmorItem.Type.CHESTPLATE && !entity.isShiftKeyDown()) { //Don't allow elytra flight if the player is sneaking. This lets the player exit elytra flight early - IModuleContainer container = moduleContainer(stack).orElse(null); + IModuleContainer container = moduleContainer(stack); if (container != null) { IModule elytra = container.getIfEnabled(MekanismModules.ELYTRA_UNIT); if (elytra != null && elytra.canUseEnergy(entity, MekanismConfig.gear.mekaSuitElytraEnergyUsage.get())) { diff --git a/src/main/java/mekanism/common/item/gear/ItemMekaTool.java b/src/main/java/mekanism/common/item/gear/ItemMekaTool.java index 40d881796d4..f1514e2f5e0 100644 --- a/src/main/java/mekanism/common/item/gear/ItemMekaTool.java +++ b/src/main/java/mekanism/common/item/gear/ItemMekaTool.java @@ -12,7 +12,6 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; -import java.util.Optional; import java.util.stream.Collectors; import mekanism.api.Action; import mekanism.api.AutomationType; @@ -114,7 +113,7 @@ public void appendHoverText(@NotNull ItemStack stack, Level world, @NotNull List @Override public boolean canPerformAction(ItemStack stack, ToolAction action) { - IModuleContainer container = moduleContainer(stack).orElse(null); + IModuleContainer container = moduleContainer(stack); if (container != null) { if (ItemAtomicDisassembler.ALWAYS_SUPPORTED_ACTIONS.contains(action)) { return hasEnergyForDigAction(container, StorageUtils.getEnergyContainer(stack, 0)); @@ -164,18 +163,16 @@ public boolean isNotReplaceableByPickAction(ItemStack stack, Player player, int @Override public int getEnchantmentLevel(ItemStack stack, Enchantment enchantment) { //Enchantments in our data - IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainer(stack).orElse(null); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); int moduleLevel = container == null ? 0 : container.getModuleEnchantmentLevel(enchantment); return Math.max(moduleLevel, super.getEnchantmentLevel(stack, enchantment)); } - @Override public Map getAllEnchantments(ItemStack stack) { Map enchantments = super.getAllEnchantments(stack); - Optional> optionalEnchantmentMap = IModuleHelper.INSTANCE.getModuleContainer(stack) - .map(IModuleContainer::moduleBasedEnchantments); - if (optionalEnchantmentMap.isPresent()) { - for (Entry entry : optionalEnchantmentMap.get().entrySet()) { + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + if (container != null) { + for (Entry entry : container.moduleBasedEnchantments().entrySet()) { enchantments.merge(entry.getKey(), entry.getValue(), Math::max); } } diff --git a/src/main/java/mekanism/common/item/predicate/MaxedModuleContainerItemPredicate.java b/src/main/java/mekanism/common/item/predicate/MaxedModuleContainerItemPredicate.java index 875e83beffe..bb1de7c996f 100644 --- a/src/main/java/mekanism/common/item/predicate/MaxedModuleContainerItemPredicate.java +++ b/src/main/java/mekanism/common/item/predicate/MaxedModuleContainerItemPredicate.java @@ -5,6 +5,7 @@ import java.util.Optional; import java.util.Set; import mekanism.api.JsonConstants; +import mekanism.api.gear.IModule; import mekanism.api.gear.IModuleContainer; import mekanism.api.gear.IModuleHelper; import mekanism.api.gear.ModuleData; @@ -27,11 +28,17 @@ public MaxedModuleContainerItemPredicate(Item item) { @Override public boolean test(@NotNull ItemStack stack) { if (stack.is(item)) { - Optional moduleContainer = IModuleHelper.INSTANCE.getModuleContainer(stack); - if (moduleContainer.isPresent()) { - IModuleContainer container = moduleContainer.get(); - return container.moduleTypes().containsAll(supportedModules) && - container.modules().stream().allMatch(module -> module.getInstalledCount() == module.getData().getMaxStackSize()); + IModuleContainer container = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + if (container != null) { + if (!container.moduleTypes().containsAll(supportedModules)) { + return false; + } + for (IModule module : container.modules()) { + if (module.getInstalledCount() != module.getData().getMaxStackSize()) { + return false; + } + } + return true; } } return false; diff --git a/src/main/java/mekanism/common/network/to_server/PacketUpdateModuleSettings.java b/src/main/java/mekanism/common/network/to_server/PacketUpdateModuleSettings.java index 9c5dc96a060..e9ac934c8f0 100644 --- a/src/main/java/mekanism/common/network/to_server/PacketUpdateModuleSettings.java +++ b/src/main/java/mekanism/common/network/to_server/PacketUpdateModuleSettings.java @@ -69,9 +69,9 @@ public void handle(PlayPayloadContext context) { Player player = context.player().orElse(null); if (player != null) { ItemStack stack = player.getInventory().getItem(slotId); - Optional moduleContainer = ModuleHelper.get().getModuleContainer(stack); - if (moduleContainer.isPresent()) { - Module module = moduleContainer.get().get(moduleType); + ModuleContainer moduleContainer = ModuleHelper.get().getModuleContainerNullable(stack); + if (moduleContainer != null) { + Module module = moduleContainer.get(moduleType); if (module != null) { setValue(module.getConfigItem(data)); } diff --git a/src/main/java/mekanism/common/tile/TileEntityModificationStation.java b/src/main/java/mekanism/common/tile/TileEntityModificationStation.java index 728be95d851..47239bd71ca 100644 --- a/src/main/java/mekanism/common/tile/TileEntityModificationStation.java +++ b/src/main/java/mekanism/common/tile/TileEntityModificationStation.java @@ -91,9 +91,8 @@ protected boolean onUpdateServer() { if (energyContainer.getEnergy().greaterOrEqual(energyContainer.getEnergyPerTick()) && !moduleSlot.isEmpty() && !containerSlot.isEmpty()) { ModuleData data = ((IModuleItem) moduleSlot.getStack().getItem()).getModuleData(); ItemStack stack = containerSlot.getStack(); - Optional moduleContainer = ModuleHelper.get().getModuleContainer(stack); - if (moduleContainer.isPresent()) { - ModuleContainer container = moduleContainer.get(); + ModuleContainer container = ModuleHelper.get().getModuleContainerNullable(stack); + if (container != null) { // make sure the container supports this module and that we can still install more of this module if (container.canInstall(data)) { operated = true; @@ -124,9 +123,8 @@ public boolean usedEnergy() { public void removeModule(Player player, ModuleData type, boolean removeAll) { ItemStack stack = containerSlot.getStack(); - Optional moduleContainer = ModuleHelper.get().getModuleContainer(stack); - if (moduleContainer.isPresent()) { - ModuleContainer container = moduleContainer.get(); + ModuleContainer container = ModuleHelper.get().getModuleContainerNullable(stack); + if (container != null) { if (container.has(type)) { int toRemove = removeAll ? container.installedCount(type) : 1; if (player.getInventory().add(type.getItemProvider().getItemStack(toRemove))) { diff --git a/src/main/java/mekanism/common/util/InventoryUtils.java b/src/main/java/mekanism/common/util/InventoryUtils.java index 231d3d4bf55..fd0ccb84521 100644 --- a/src/main/java/mekanism/common/util/InventoryUtils.java +++ b/src/main/java/mekanism/common/util/InventoryUtils.java @@ -73,9 +73,9 @@ public static void dropItemContents(ItemEntity entity, DamageSource source) { dropItemContents(upgradeAware.getInventorySlots(null), scalar, dropper); dropItemContents(upgradeAware.getUpgrades().entrySet(), scalar, dropper, entry -> UpgradeUtils.getStack(entry.getKey(), entry.getValue())); } - Optional moduleContainer = IModuleHelper.INSTANCE.getModuleContainer(stack); - if (moduleContainer.isPresent()) { - dropItemContents(moduleContainer.get().modules(), scalar, dropper, module -> module.getData().getItemProvider().getItemStack(module.getInstalledCount())); + IModuleContainer moduleContainer = IModuleHelper.INSTANCE.getModuleContainerNullable(stack); + if (moduleContainer != null) { + dropItemContents(moduleContainer.modules(), scalar, dropper, module -> module.getData().getItemProvider().getItemStack(module.getInstalledCount())); } } }