Address misc TODOs and fix being unable to lock bins, and mekasuit losing power on relog

pupnewfster · pupnewfster · commit e004b26bd01a · 2024-06-13T12:56:48.000-05:00
diff --git a/src/api/java/mekanism/api/chemical/merged/BoxedChemical.java b/src/api/java/mekanism/api/chemical/merged/BoxedChemical.java
@@ -65,7 +65,7 @@ public class BoxedChemical implements IHasTextComponent {
      */
     public static BoxedChemical box(Chemical<?> chemical) {
         if (chemical.isEmptyType()) {
-            //TODO - 1.21: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?
+            //TODO: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?
             return EMPTY;
         }
         return new BoxedChemical(ChemicalType.getTypeFor(chemical), chemical);
diff --git a/src/api/java/mekanism/api/chemical/merged/BoxedChemicalStack.java b/src/api/java/mekanism/api/chemical/merged/BoxedChemicalStack.java
@@ -66,7 +66,7 @@ public class BoxedChemicalStack implements IHasTextComponent {
      */
     public static BoxedChemicalStack box(ChemicalStack<?> chemicalStack) {
         if (chemicalStack.isEmpty()) {
-            //TODO - 1.21: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?
+            //TODO: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?
             return EMPTY;
         }
         return new BoxedChemicalStack(ChemicalType.getTypeFor(chemicalStack), chemicalStack);
diff --git a/src/api/java/mekanism/api/math/FloatingLong.java b/src/api/java/mekanism/api/math/FloatingLong.java
@@ -23,15 +23,28 @@
 @NothingNullByDefault
 public class FloatingLong extends Number implements Comparable<FloatingLong> {
 
+    //we don't lose accuracy due to using a double, and because for some reason it seems like
+    // the codecs occasionally have issues being parsed
     public static final Codec<FloatingLong> CODEC = new PrimitiveCodec<>() {
         @Override
         public <T> DataResult<FloatingLong> read(DynamicOps<T> ops, T input) {
-            return ops.getNumberValue(input).flatMap(number -> fromNumber(number, true));
+            return ops.getStringValue(input).flatMap(number -> {
+                try {
+                    return DataResult.success(parseFloatingLong(number, true));
+                } catch (NumberFormatException e) {
+                    return DataResult.error(e::getMessage);
+                }
+            });
         }
 
         @Override
         public <T> T write(DynamicOps<T> ops, FloatingLong value) {
-            return ops.createNumeric(value);
+            return ops.createString(value.toString());
+        }
+
+        @Override
+        public String toString() {
+            return "FloatingLong";
         }
     };
     public static final Codec<FloatingLong> NONZERO_CODEC = CODEC.validate(f -> {
@@ -45,7 +58,7 @@ public <T> T write(DynamicOps<T> ops, FloatingLong value) {
           // as in general it will still provide an improvement
           ByteBufCodecs.VAR_LONG, FloatingLong::getValue,
           ByteBufCodecs.SHORT, FloatingLong::getDecimal,
-          FloatingLong::create
+          FloatingLong::createConst
     );
     private static final DecimalFormat df = new DecimalFormat("0.0000", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
 
@@ -1208,27 +1221,6 @@ public static FloatingLong parseFloatingLong(String string, boolean isConstant)
         return isConstant ? createConst(value, decimal) : create(value, decimal);
     }
 
-    private static DataResult<FloatingLong> fromNumber(Number number, boolean isConstant) {
-        if (number instanceof Integer || number instanceof Long || number instanceof Short || number instanceof Byte || number instanceof BigInteger) {
-            long longValue = number.longValue();
-            if (longValue < 0) {
-                return DataResult.error(() -> "Number must be positive");
-            }
-            return DataResult.success(isConstant ? createConst(longValue, (short) 0) : create(longValue, (short) 0));
-        } else if (number instanceof BigDecimal decimal) {
-            try {
-                long longValue = decimal.longValueExact();
-                return DataResult.success(isConstant ? createConst(longValue, (short) 0) : create(longValue, (short) 0));
-            } catch (ArithmeticException ignored) {
-            }
-        }
-        try {
-            return DataResult.success(parseFloatingLong(number.toString(), isConstant));
-        } catch (NumberFormatException e) {
-            return DataResult.error(e::getMessage);
-        }
-    }
-
     /**
      * Parses the decimal out of a string argument and gets the representation as a short. The characters in the string must all be decimal digits, with a decimal point
      * being valid to convey where the decimal starts.
diff --git a/src/generators/java/mekanism/generators/common/block/turbine/BlockTurbineRotor.java b/src/generators/java/mekanism/generators/common/block/turbine/BlockTurbineRotor.java
@@ -46,6 +46,7 @@ protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull Blo
                     if (!player.isCreative()) {
                         stack.shrink(1);
                     }
+                    return ItemInteractionResult.CONSUME;
                 }
             }
         } else if (stack.isEmpty()) {
@@ -54,6 +55,7 @@ protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull Blo
                     player.setItemInHand(hand, GeneratorsItems.TURBINE_BLADE.getItemStack());
                     player.getInventory().setChanged();
                 }
+                return ItemInteractionResult.CONSUME;
             }
         } else if (stack.getItem() instanceof ItemTurbineBlade) {
             if (stack.getCount() < stack.getMaxStackSize()) {
@@ -62,6 +64,7 @@ protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull Blo
                         stack.grow(1);
                         player.getInventory().setChanged();
                     }
+                    return ItemInteractionResult.CONSUME;
                 }
             }
         }
diff --git a/src/main/java/mekanism/client/model/BaseModelCache.java b/src/main/java/mekanism/client/model/BaseModelCache.java
@@ -77,7 +77,6 @@ protected JSONModelData registerJSON(ResourceLocation rl) {
     protected JSONModelData registerJSONAndBake(ResourceLocation rl) {
         ModelManager modelManager = Minecraft.getInstance().getModelManager();
         ModelBakery modelBakery = modelManager.getModelBakery();
-        //TODO - 1.21: Test this
         ModelResourceLocation mrl = ModelResourceLocation.standalone(rl);
         ModelBaker baker = modelBakery.new ModelBakerImpl(
               (modelLoc, material) -> material.sprite(),
diff --git a/src/main/java/mekanism/client/render/MekanismRenderType.java b/src/main/java/mekanism/client/render/MekanismRenderType.java
@@ -81,7 +81,6 @@ private static RenderType createStandard(String name, ResourceLocation resourceL
               .setTextureState(new RenderStateShard.TextureStateShard(resourceLocation, false, false))
               .setTransparencyState(TRANSLUCENT_TRANSPARENCY)
               .createCompositeState(true);
-        //TODO - 1.21: Check the shader implementation that it doesn't need things to change
         return create("mek_flame", DefaultVertexFormat.POSITION_TEX_COLOR, Mode.QUADS, 256, true, false, state);
     });
 
@@ -110,7 +109,6 @@ private static RenderType createStandard(String name, ResourceLocation resourceL
               .setTransparencyState(LIGHTNING_TRANSPARENCY)
               .setOutputState(RenderType.TRANSLUCENT_TARGET)
               .createCompositeState(true);
-        //TODO - 1.21: Check the shader implementation that it doesn't need things to change
         return create("mek_sps", DefaultVertexFormat.POSITION_TEX_COLOR, Mode.QUADS, 256, true, true, state);
     });
 }
diff --git a/src/main/java/mekanism/client/render/transmitter/RenderTransmitterBase.java b/src/main/java/mekanism/client/render/transmitter/RenderTransmitterBase.java
@@ -41,7 +41,6 @@
 public abstract class RenderTransmitterBase<TRANSMITTER extends TileEntityTransmitter> extends MekanismTileEntityRenderer<TRANSMITTER> {
 
     public static final ResourceLocation MODEL_LOCATION = MekanismUtils.getResource(ResourceType.MODEL, "transmitter_contents.obj");
-    //TODO - 1.21: Test this
     private static final ModelResourceLocation MODEL_VARIANT = ModelResourceLocation.standalone(MODEL_LOCATION);
     private static final IGeometryBakingContext contentsConfiguration = StandaloneGeometryBakingContext.builder()
           .withGui3d(false)
diff --git a/src/main/java/mekanism/common/attachments/containers/chemical/ComponentBackedChemicalTank.java b/src/main/java/mekanism/common/attachments/containers/chemical/ComponentBackedChemicalTank.java
@@ -79,7 +79,12 @@ public ChemicalAttributeValidator getAttributeValidator() {
         return attributeValidator == null ? IChemicalTank.super.getAttributeValidator() : attributeValidator;
     }
 
-    protected long getRate(@Nullable AutomationType automationType) {
+    protected long getInsertRate(@Nullable AutomationType automationType) {
+        //Allow unknown or manual interaction to bypass rate limit for the item
+        return automationType == null || automationType == AutomationType.MANUAL ? Long.MAX_VALUE : rate.getAsLong();
+    }
+
+    protected long getExtractRate(@Nullable AutomationType automationType) {
         //Allow unknown or manual interaction to bypass rate limit for the item
         return automationType == null || automationType == AutomationType.MANUAL ? Long.MAX_VALUE : rate.getAsLong();
     }
@@ -104,7 +109,7 @@ public STACK insert(STACK stack, Action action, AutomationType automationType) {
         }
         ATTACHED attachedChemicals = getAttached();
         STACK stored = getContents(attachedChemicals);
-        long needed = Math.min(getRate(automationType), getNeeded(stored));
+        long needed = Math.min(getInsertRate(automationType), getNeeded(stored));
         if (needed <= 0) {
             //Fail if we are a full tank or our rate is zero
             return stack;
@@ -139,7 +144,7 @@ protected STACK extract(ATTACHED attachedChemicals, STACK stored, long amount, A
         }
         //Note: While we technically could just return the stack itself if we are removing all that we have, it would require a lot more checks
         // We also are limiting it by the rate this tank has
-        long size = Math.min(Math.min(getRate(automationType), stored.getAmount()), amount);
+        long size = Math.min(Math.min(getExtractRate(automationType), stored.getAmount()), amount);
         if (size == 0) {
             return getEmptyStack();
         }
@@ -188,9 +193,11 @@ public long growStack(long amount, Action action) {
             return 0;
         } else if (amount > 0) {
             //Cap adding amount at how much we need, so that we don't risk integer overflow
-            amount = Math.min(Math.min(amount, getNeeded(stored)), getRate(null));
+            //If we are increasing the stack's size, use the insert rate
+            amount = Math.min(Math.min(amount, getNeeded(stored)), getInsertRate(null));
         } else if (amount < 0) {
-            amount = Math.max(amount, -getRate(null));
+            //If we are decreasing the stack's size, use the extract rate
+            amount = Math.max(amount, -getExtractRate(null));
         }
         long newSize = setStackSize(attachedChemicals, stored, current + amount, action);
         return newSize - current;
diff --git a/src/main/java/mekanism/common/attachments/containers/energy/ComponentBackedEnergyContainer.java b/src/main/java/mekanism/common/attachments/containers/energy/ComponentBackedEnergyContainer.java
@@ -73,7 +73,12 @@ protected void setContents(AttachedEnergy attachedEnergy, FloatingLong energy) {
         super.setContents(attachedEnergy, clampEnergy(energy));
     }
 
-    protected FloatingLong getRate(@Nullable AutomationType automationType) {
+    protected FloatingLong getInsertRate(@Nullable AutomationType automationType) {
+        //Allow unknown or manual interaction to bypass rate limit for the item
+        return automationType == null || automationType == AutomationType.MANUAL ? FloatingLong.MAX_VALUE : rate.get();
+    }
+
+    protected FloatingLong getExtractRate(@Nullable AutomationType automationType) {
         //Allow unknown or manual interaction to bypass rate limit for the item
         return automationType == null || automationType == AutomationType.MANUAL ? FloatingLong.MAX_VALUE : rate.get();
     }
@@ -85,7 +90,7 @@ public FloatingLong insert(FloatingLong amount, Action action, AutomationType au
         }
         AttachedEnergy attachedEnergy = getAttached();
         FloatingLong stored = getContents(attachedEnergy);
-        FloatingLong needed = getRate(automationType).min(getNeeded(stored));
+        FloatingLong needed = getInsertRate(automationType).min(getNeeded(stored));
         if (needed.isZero()) {
             //Fail if we are a full container or our rate is zero
             return amount;
@@ -109,7 +114,7 @@ public FloatingLong extract(FloatingLong amount, Action action, AutomationType a
         if (stored.isZero() || !canExtract.test(automationType)) {
             return FloatingLong.ZERO;
         }
-        FloatingLong ret = getRate(automationType).min(stored).min(amount).copy();
+        FloatingLong ret = getExtractRate(automationType).min(stored).min(amount).copy();
         if (!ret.isZero() && action.execute()) {
             //Note: this also will mark that the contents changed
             setContents(attachedEnergy, stored.subtract(ret));
diff --git a/src/main/java/mekanism/common/attachments/containers/energy/EnergyContainersBuilder.java b/src/main/java/mekanism/common/attachments/containers/energy/EnergyContainersBuilder.java
@@ -14,10 +14,10 @@
 
 public class EnergyContainersBuilder {
 
-    private static final IBasicContainerCreator<? extends ComponentBackedEnergyContainer> MEKASUIT = (type, attachedTo, containerIndex) -> new ComponentBackedNoClampEnergyContainer(attachedTo, containerIndex, BasicEnergyContainer.manualOnly,
-          BasicEnergyContainer.alwaysTrue,
-          () -> ModuleEnergyUnit.getChargeRate(attachedTo, MekanismConfig.gear.mekaSuitBaseChargeRate.get()),
-          () -> ModuleEnergyUnit.getEnergyCapacity(attachedTo, MekanismConfig.gear.mekaSuitBaseEnergyCapacity.get())
+    private static final IBasicContainerCreator<? extends ComponentBackedEnergyContainer> MEKASUIT = (type, attachedTo, containerIndex) -> new ComponentBackedNoClampEnergyContainer(
+          attachedTo, containerIndex, BasicEnergyContainer.manualOnly, BasicEnergyContainer.alwaysTrue,
+          () -> ModuleEnergyUnit.getChargeRate(attachedTo, MekanismConfig.gear.mekaSuitBaseChargeRate),
+          () -> ModuleEnergyUnit.getEnergyCapacity(attachedTo, MekanismConfig.gear.mekaSuitBaseEnergyCapacity)
     );
 
     public static EnergyContainersBuilder builder() {
diff --git a/src/main/java/mekanism/common/attachments/containers/fluid/ComponentBackedFluidTank.java b/src/main/java/mekanism/common/attachments/containers/fluid/ComponentBackedFluidTank.java
@@ -78,7 +78,12 @@ public int getCapacity() {
         return capacity.getAsInt();
     }
 
-    protected int getRate(@Nullable AutomationType automationType) {
+    protected int getInsertRate(@Nullable AutomationType automationType) {
+        //Allow unknown or manual interaction to bypass rate limit for the item
+        return automationType == null || automationType == AutomationType.MANUAL ? Integer.MAX_VALUE : rate.getAsInt();
+    }
+
+    protected int getExtractRate(@Nullable AutomationType automationType) {
         //Allow unknown or manual interaction to bypass rate limit for the item
         return automationType == null || automationType == AutomationType.MANUAL ? Integer.MAX_VALUE : rate.getAsInt();
     }
@@ -93,7 +98,7 @@ public FluidStack insert(FluidStack stack, Action action, AutomationType automat
         }
         AttachedFluids attachedFluids = getAttached();
         FluidStack stored = getContents(attachedFluids);
-        int needed = Math.min(getRate(automationType), getNeeded(stored));
+        int needed = Math.min(getInsertRate(automationType), getNeeded(stored));
         if (needed <= 0) {
             //Fail if we are a full tank or our rate is zero
             return stack;
@@ -128,7 +133,7 @@ protected FluidStack extract(AttachedFluids attachedFluids, FluidStack stored, i
         }
         //Note: While we technically could just return the stack itself if we are removing all that we have, it would require a lot more checks
         // We also are limiting it by the rate this tank has
-        int size = Math.min(Math.min(getRate(automationType), stored.getAmount()), amount);
+        int size = Math.min(Math.min(getExtractRate(automationType), stored.getAmount()), amount);
         FluidStack ret = stored.copyWithAmount(size);
         if (!ret.isEmpty() && action.execute()) {
             //Note: We let setStack handle updating the backing holding stack
@@ -174,9 +179,11 @@ public int growStack(int amount, Action action) {
             return 0;
         } else if (amount > 0) {
             //Cap adding amount at how much we need, so that we don't risk integer overflow
-            amount = Math.min(Math.min(amount, getNeeded(stored)), getRate(null));
+            //If we are increasing the stack's size, use the insert rate
+            amount = Math.min(Math.min(amount, getNeeded(stored)), getInsertRate(null));
         } else if (amount < 0) {
-            amount = Math.max(amount, -getRate(null));
+            //If we are decreasing the stack's size, use the extract rate
+            amount = Math.max(amount, -getExtractRate(null));
         }
         int newSize = setStackSize(attachedFluids, stored,current + amount, action);
         return newSize - current;
diff --git a/src/main/java/mekanism/common/block/basic/BlockBin.java b/src/main/java/mekanism/common/block/basic/BlockBin.java
@@ -74,9 +74,6 @@ protected void attack(@NotNull BlockState state, @NotNull Level world, @NotNull
     @Override
     protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull BlockState state, @NotNull Level world, @NotNull BlockPos pos, @NotNull Player player,
           @NotNull InteractionHand hand, @NotNull BlockHitResult hit) {
-        if (stack.isEmpty()) {
-            return ItemInteractionResult.PASS_TO_DEFAULT_BLOCK_INTERACTION;
-        }
         TileEntityBin bin = WorldUtils.getTileEntity(TileEntityBin.class, world, pos);
         if (bin == null) {
             //No tile, we can just skip trying to use without an item
diff --git a/src/main/java/mekanism/common/content/gear/shared/ModuleEnergyUnit.java b/src/main/java/mekanism/common/content/gear/shared/ModuleEnergyUnit.java
@@ -9,27 +9,28 @@
 import mekanism.api.gear.IModuleContainer;
 import mekanism.api.gear.IModuleHelper;
 import mekanism.api.math.FloatingLong;
+import mekanism.api.math.FloatingLongSupplier;
 import mekanism.common.capabilities.Capabilities;
 import mekanism.common.registries.MekanismModules;
 import net.minecraft.world.item.ItemStack;
 
 @ParametersAreNotNullByDefault
 public class ModuleEnergyUnit implements ICustomModule<ModuleEnergyUnit> {
 
-    public static FloatingLong getEnergyCapacity(ItemStack stack, FloatingLong base) {
+    public static FloatingLong getEnergyCapacity(ItemStack stack, FloatingLongSupplier base) {
         return getEnergyValue(stack, base);
     }
 
-    public static FloatingLong getChargeRate(ItemStack stack, FloatingLong base) {
+    public static FloatingLong getChargeRate(ItemStack stack, FloatingLongSupplier base) {
         return getEnergyValue(stack, base);
     }
 
-    private static FloatingLong getEnergyValue(ItemStack stack, FloatingLong base) {
+    private static FloatingLong getEnergyValue(ItemStack stack, FloatingLongSupplier base) {
         IModule<ModuleEnergyUnit> module = IModuleHelper.INSTANCE.getModule(stack, MekanismModules.ENERGY_UNIT);
         if (module == null) {
-            return base;
+            return base.get();
         }
-        return base.multiply(Math.pow(2, module.getInstalledCount()));
+        return base.get().multiply(Math.pow(2, module.getInstalledCount()));
     }
 
     @Override
diff --git a/src/main/java/mekanism/common/item/gear/ItemSpecialArmor.java b/src/main/java/mekanism/common/item/gear/ItemSpecialArmor.java
@@ -12,7 +12,6 @@
 
 public abstract class ItemSpecialArmor extends ArmorItem implements ICapabilityAware {
 
-    //TODO - 1.21: Override getDefaultAttributeModifiers for the ones that actually have config based stuff??
     protected ItemSpecialArmor(Holder<ArmorMaterial> material, ArmorItem.Type armorType, Properties properties) {
         super(material, armorType, properties);
     }
diff --git a/src/main/java/mekanism/common/registries/MekanismItems.java b/src/main/java/mekanism/common/registries/MekanismItems.java
@@ -155,8 +155,8 @@ private MekanismItems() {
     public static final ItemRegistryObject<ItemMekaTool> MEKA_TOOL = ITEMS.registerUnburnable("meka_tool", ItemMekaTool::new)
           .addAttachedContainerCapabilities(ContainerType.ENERGY, () -> EnergyContainersBuilder.builder()
                 .addContainer((type, attachedTo, containerIndex) -> new ComponentBackedNoClampEnergyContainer(attachedTo, containerIndex, BasicEnergyContainer.manualOnly,
-                      BasicEnergyContainer.alwaysTrue, () -> ModuleEnergyUnit.getChargeRate(attachedTo, MekanismConfig.gear.mekaToolBaseChargeRate.get()),
-                      () -> ModuleEnergyUnit.getEnergyCapacity(attachedTo, MekanismConfig.gear.mekaToolBaseEnergyCapacity.get())))
+                      BasicEnergyContainer.alwaysTrue, () -> ModuleEnergyUnit.getChargeRate(attachedTo, MekanismConfig.gear.mekaToolBaseChargeRate),
+                      () -> ModuleEnergyUnit.getEnergyCapacity(attachedTo, MekanismConfig.gear.mekaToolBaseEnergyCapacity)))
                 .build(), MekanismConfig.gear
           );
     // Armor
diff --git a/src/main/java/mekanism/common/tile/base/TileEntityMekanism.java b/src/main/java/mekanism/common/tile/base/TileEntityMekanism.java
@@ -600,7 +600,6 @@ public WrenchResult tryWrench(BlockState state, Player player, ItemStack stack)
         return WrenchResult.PASS;
     }
 
-    //TODO - 1.21: Figure out why it seems like other players can't open things even on public? At least on my test server in dev
     public InteractionResult openGui(Player player) {
         //Everything that calls this has isRemote being false but add the check just in case anyway
         if (hasGui() && !isRemote() && !player.isShiftKeyDown()) {
diff --git a/src/main/java/mekanism/common/tile/machine/TileEntityDigitalMiner.java b/src/main/java/mekanism/common/tile/machine/TileEntityDigitalMiner.java
diff --git a/src/main/resources/assets/mekanism/shaders/core/rendertype_flame.json b/src/main/resources/assets/mekanism/shaders/core/rendertype_flame.json
diff --git a/src/main/resources/assets/mekanism/shaders/core/rendertype_mekasuit.json b/src/main/resources/assets/mekanism/shaders/core/rendertype_mekasuit.json
diff --git a/src/main/resources/assets/mekanism/shaders/core/rendertype_sps.json b/src/main/resources/assets/mekanism/shaders/core/rendertype_sps.json

Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public class BoxedChemical implements IHasTextComponent {`
`65`	`65`	`*/`
`66`	`66`	`public static BoxedChemical box(Chemical<?> chemical) {`
`67`	`67`	`if (chemical.isEmptyType()) {`
`68`		`- //TODO - 1.21: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?`
	`68`	`+ //TODO: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?`
`69`	`69`	`return EMPTY;`
`70`	`70`	`}`
`71`	`71`	`return new BoxedChemical(ChemicalType.getTypeFor(chemical), chemical);`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ public class BoxedChemicalStack implements IHasTextComponent {`
`66`	`66`	`*/`
`67`	`67`	`public static BoxedChemicalStack box(ChemicalStack<?> chemicalStack) {`
`68`	`68`	`if (chemicalStack.isEmpty()) {`
`69`		`- //TODO - 1.21: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?`
	`69`	`+ //TODO: Do we care that this can lose the type of chemical as it uses a single instance that always has a type of gas?`
`70`	`70`	`return EMPTY;`
`71`	`71`	`}`
`72`	`72`	`return new BoxedChemicalStack(ChemicalType.getTypeFor(chemicalStack), chemicalStack);`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull Blo`
`46`	`46`	`if (!player.isCreative()) {`
`47`	`47`	`stack.shrink(1);`
`48`	`48`	`}`
	`49`	`+ return ItemInteractionResult.CONSUME;`
`49`	`50`	`}`
`50`	`51`	`}`
`51`	`52`	`} else if (stack.isEmpty()) {`
`@@ -54,6 +55,7 @@ protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull Blo`
`54`	`55`	`player.setItemInHand(hand, GeneratorsItems.TURBINE_BLADE.getItemStack());`
`55`	`56`	`player.getInventory().setChanged();`
`56`	`57`	`}`
	`58`	`+ return ItemInteractionResult.CONSUME;`
`57`	`59`	`}`
`58`	`60`	`} else if (stack.getItem() instanceof ItemTurbineBlade) {`
`59`	`61`	`if (stack.getCount() < stack.getMaxStackSize()) {`
`@@ -62,6 +64,7 @@ protected ItemInteractionResult useItemOn(@NotNull ItemStack stack, @NotNull Blo`
`62`	`64`	`stack.grow(1);`
`63`	`65`	`player.getInventory().setChanged();`
`64`	`66`	`}`
	`67`	`+ return ItemInteractionResult.CONSUME;`
`65`	`68`	`}`
`66`	`69`	`}`
`67`	`70`	`}`