Make the ratio between EU and FE configurable. Default: 1 EU = 10 FE (#1067)

Author: Technici4n

src/generated/resources/assets/modern_industrialization/lang/en_us.json

@@ -1119,6 +1119,8 @@
   "modern_industrialization.configuration.defaultIndustrialistTrades.tooltip": "Enable the default trades from the Industrialist villager provided by MI. Disable this to provide your own set of trades.",
   "modern_industrialization.configuration.defaultOreGenTooltips": "Ore generation tooltips",
   "modern_industrialization.configuration.defaultOreGenTooltips.tooltip": "Enable the default ore generation tooltips. These tooltips show how each MI ore generates, based on the default ore generation settings in MI. Set this to false if you change the ore features in a datapack.",
+  "modern_industrialization.configuration.forgeEnergyPerEu": "FE per EU",
+  "modern_industrialization.configuration.forgeEnergyPerEu.tooltip": "How many Forge Energy units a single EU from MI is worth.",
   "modern_industrialization.configuration.ftbQuestsIntegration": "FTB Quests integration",
   "modern_industrialization.configuration.ftbQuestsIntegration.tooltip": "Enable the FTB Quests integration, if present.",
   "modern_industrialization.configuration.fuelTooltips": "Fuel tooltips",
@@ -1134,7 +1136,6 @@
   "modern_industrialization.configuration.maxDistillationTowerHeight": "Max distillation tower height",
   "modern_industrialization.configuration.maxDistillationTowerHeight.tooltip": "Maximum height of the distillation tower multiblock.",
   "modern_industrialization.configuration.messages": "Messages",
-  "modern_industrialization.configuration.misc": "Miscellaneous",
   "modern_industrialization.configuration.missingRecipeViewerMessage": "Missing recipe viewer message",
   "modern_industrialization.configuration.missingRecipeViewerMessage.tooltip": "Enable login message when EMI, JEI and REI are all missing.",
   "modern_industrialization.configuration.newVersionMessage": "New version message",

src/main/java/aztech/modern_industrialization/api/energy/EnergyApi.java

@@ -24,18 +24,23 @@
 package aztech.modern_industrialization.api.energy;
 
 import aztech.modern_industrialization.MI;
+import aztech.modern_industrialization.config.MIServerConfig;
 import aztech.modern_industrialization.config.MIStartupConfig;
-import dev.technici4n.grandpower.api.DelegatingEnergyStorage;
 import dev.technici4n.grandpower.api.ILongEnergyStorage;
-import dev.technici4n.grandpower.api.LimitingEnergyStorage;
 import net.minecraft.core.Direction;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.level.block.Block;
 import net.neoforged.neoforge.capabilities.BlockCapability;
 import net.neoforged.neoforge.capabilities.ItemCapability;
 import net.neoforged.neoforge.capabilities.RegisterCapabilitiesEvent;
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
 
+/**
+ * MI's energy API. It uses the same types as GrandPower (i.e. {@link ILongEnergyStorage},
+ * however the conversion ratio between EU and GrandPower energy is configurable.
+ * So don't mix them up!
+ */
 public class EnergyApi {
     public static final BlockCapability<MIEnergyStorage, Direction> SIDED = BlockCapability
             .createSided(MI.id("sided_mi_energy_storage"), MIEnergyStorage.class);
@@ -101,7 +106,7 @@ public static void init(RegisterCapabilitiesEvent event, Block[] allBlocks, Item
 
                 IN_COMPAT.set(true);
                 try {
-                    return world.getCapability(SIDED, pos, state, blockEntity, context);
+                    return WrappedMIStorage.of(world.getCapability(SIDED, pos, state, blockEntity, context));
                 } finally {
                     IN_COMPAT.set(false);
                 }
@@ -113,8 +118,7 @@ public static void init(RegisterCapabilitiesEvent event, Block[] allBlocks, Item
 
                 IN_COMPAT.set(true);
                 try {
-                    var trStorage = world.getCapability(ILongEnergyStorage.BLOCK, pos, state, blockEntity, context);
-                    return trStorage == null ? null : new WrappedTrStorage(trStorage);
+                    return WrappedExternalStorage.of(world.getCapability(ILongEnergyStorage.BLOCK, pos, state, blockEntity, context));
                 } finally {
                     IN_COMPAT.set(false);
                 }
@@ -127,7 +131,7 @@ public static void init(RegisterCapabilitiesEvent event, Block[] allBlocks, Item
 
                 IN_COMPAT.set(true);
                 try {
-                    return stack.getCapability(ITEM);
+                    return WrappedMIStorage.of(stack.getCapability(ITEM));
                 } finally {
                     IN_COMPAT.set(false);
                 }
@@ -139,15 +143,14 @@ public static void init(RegisterCapabilitiesEvent event, Block[] allBlocks, Item
 
                 IN_COMPAT.set(true);
                 try {
-                    return stack.getCapability(ILongEnergyStorage.ITEM);
+                    return WrappedExternalStorage.of(stack.getCapability(ILongEnergyStorage.ITEM));
                 } finally {
                     IN_COMPAT.set(false);
                 }
             }, allItems);
         } else {
             event.registerBlock(SIDED, (world, pos, state, blockEntity, context) -> {
-                var trStorage = world.getCapability(ILongEnergyStorage.BLOCK, pos, state, blockEntity, context);
-                return trStorage == null || !trStorage.canReceive() ? null : new InsertOnlyTrStorage(trStorage);
+                return InsertOnlyExternalStorage.of(world.getCapability(ILongEnergyStorage.BLOCK, pos, state, blockEntity, context));
             }, allBlocks);
             event.registerItem(ITEM, (stack, ctx) -> {
                 if (IN_COMPAT.get()) {
@@ -156,8 +159,7 @@ public static void init(RegisterCapabilitiesEvent event, Block[] allBlocks, Item
 
                 IN_COMPAT.set(true);
                 try {
-                    var trStorage = stack.getCapability(ILongEnergyStorage.ITEM);
-                    return trStorage == null || !trStorage.canReceive() ? null : new LimitingEnergyStorage(trStorage, Long.MAX_VALUE, 0);
+                    return InsertOnlyExternalStorage.of(stack.getCapability(ILongEnergyStorage.ITEM));
                 } finally {
                     IN_COMPAT.set(false);
                 }
@@ -169,50 +171,168 @@ public static void init(RegisterCapabilitiesEvent event, Block[] allBlocks, Item
 
                 IN_COMPAT.set(true);
                 try {
-                    var miStorage = stack.getCapability(ITEM);
-                    return miStorage == null || !miStorage.canExtract() ? null : new LimitingEnergyStorage(miStorage, 0, Long.MAX_VALUE);
+                    return ExtractOnlyMIStorage.of(stack.getCapability(ITEM));
                 } finally {
                     IN_COMPAT.set(false);
                 }
             }, allItems);
         }
     }
 
-    private record InsertOnlyTrStorage(ILongEnergyStorage trStorage) implements MIEnergyStorage.NoExtract {
+    private static long ratio() {
+        return MIServerConfig.INSTANCE.forgeEnergyPerEu.getAsInt();
+    }
+
+    /**
+     * An MI energy storage that wraps an external storage to apply the energy conversion ratio to it.
+     */
+    private static class WrappedExternalStorage implements MIEnergyStorage {
+        @Nullable
+        private static WrappedExternalStorage of(@Nullable ILongEnergyStorage externalStorage) {
+            return externalStorage == null ? null : new WrappedExternalStorage(externalStorage);
+        }
+
+        private final ILongEnergyStorage externalStorage;
+
+        private WrappedExternalStorage(ILongEnergyStorage externalStorage) {
+            this.externalStorage = externalStorage;
+        }
+
         @Override
         public boolean canConnect(CableTier cableTier) {
             return true;
         }
 
         @Override
-        public long receive(long maxAmount, boolean simulate) {
-            return trStorage.receive(maxAmount, simulate);
+        public long receive(long maxReceive, boolean simulate) {
+            long ratio = ratio();
+            maxReceive *= ratio;
+            if (ratio > 1) {
+                // Do a simulate insertion to round down to a multiple of ratio that should be accepted.
+                maxReceive = externalStorage.receive(maxReceive, true) / ratio * ratio;
+            }
+            return externalStorage.receive(maxReceive, simulate) / ratio;
+        }
+
+        @Override
+        public long extract(long maxExtract, boolean simulate) {
+            long ratio = ratio();
+            maxExtract *= ratio;
+            if (ratio > 1) {
+                // Do a simulate extraction to round down to a multiple of ratio that should be accepted.
+                maxExtract = externalStorage.extract(maxExtract, true) / ratio * ratio;
+            }
+            return externalStorage.extract(maxExtract, simulate) / ratio;
+        }
+
+        @Override
+        public long getAmount() {
+            return externalStorage.getAmount() / ratio();
+        }
+
+        @Override
+        public long getCapacity() {
+            return externalStorage.getCapacity() / ratio();
+        }
+
+        @Override
+        public boolean canExtract() {
+            return externalStorage.canExtract();
         }
 
         @Override
         public boolean canReceive() {
-            return trStorage.canReceive();
+            return externalStorage.canReceive();
+        }
+    }
+
+    private static class InsertOnlyExternalStorage extends WrappedExternalStorage {
+        @Nullable
+        private static InsertOnlyExternalStorage of(@Nullable ILongEnergyStorage externalStorage) {
+            return externalStorage == null || !externalStorage.canReceive() ? null : new InsertOnlyExternalStorage(externalStorage);
+        }
+
+        private InsertOnlyExternalStorage(ILongEnergyStorage externalStorage) {
+            super(externalStorage);
+        }
+
+        @Override
+        public long extract(long maxExtract, boolean simulate) {
+            return 0;
+        }
+
+        @Override
+        public boolean canExtract() {
+            return false;
+        }
+    }
+
+    /**
+     * An external storage that wraps an MI storage to apply the energy conversion ratio to it.
+     */
+    private static class WrappedMIStorage implements ILongEnergyStorage {
+        @Nullable
+        private static WrappedMIStorage of(@Nullable ILongEnergyStorage miStorage) {
+            return miStorage == null ? null : new WrappedMIStorage(miStorage);
+        }
+
+        private final ILongEnergyStorage miStorage;
+
+        private WrappedMIStorage(ILongEnergyStorage miStorage) {
+            this.miStorage = miStorage;
+        }
+
+        @Override
+        public long receive(long maxReceive, boolean simulate) {
+            long ratio = ratio();
+            return miStorage.receive(maxReceive / ratio, simulate) * ratio;
+        }
+
+        @Override
+        public long extract(long maxExtract, boolean simulate) {
+            long ratio = ratio();
+            return miStorage.extract(maxExtract / ratio, simulate) * ratio;
         }
 
         @Override
         public long getAmount() {
-            return trStorage.getAmount();
+            return miStorage.getAmount() * ratio();
         }
 
         @Override
         public long getCapacity() {
-            return trStorage.getCapacity();
+            return miStorage.getCapacity() * ratio();
+        }
+
+        @Override
+        public boolean canExtract() {
+            return miStorage.canExtract();
+        }
+
+        @Override
+        public boolean canReceive() {
+            return miStorage.canReceive();
         }
     }
 
-    private static class WrappedTrStorage extends DelegatingEnergyStorage implements MIEnergyStorage {
-        public WrappedTrStorage(ILongEnergyStorage backingStorage) {
-            super(backingStorage);
+    private static class ExtractOnlyMIStorage extends WrappedMIStorage {
+        @Nullable
+        private static EnergyApi.ExtractOnlyMIStorage of(@Nullable ILongEnergyStorage miStorage) {
+            return miStorage == null || !miStorage.canExtract() ? null : new ExtractOnlyMIStorage(miStorage);
+        }
+
+        private ExtractOnlyMIStorage(ILongEnergyStorage miStorage) {
+            super(miStorage);
         }
 
         @Override
-        public boolean canConnect(CableTier cableTier) {
-            return true;
+        public long receive(long maxReceive, boolean simulate) {
+            return 0;
+        }
+
+        @Override
+        public boolean canReceive() {
+            return false;
         }
     }
 }

src/main/java/aztech/modern_industrialization/config/MIServerConfig.java

@@ -35,6 +35,7 @@ public final class MIServerConfig {
         SPEC = builder.build();
     }
 
+    public final ModConfigSpec.IntValue forgeEnergyPerEu;
     public final ModConfigSpec.IntValue baseItemPipeTransfer;
     public final ModConfigSpec.BooleanValue spawnWithGuideBook;
     public final ModConfigSpec.BooleanValue respawnWithGuideBook;
@@ -43,7 +44,10 @@ public final class MIServerConfig {
     public final ModConfigSpec.BooleanValue stonecutterToCuttingMachine;
 
     private MIServerConfig(MIConfigBuilder builder) {
-        builder.pushSection("misc", "Miscellaneous");
+        this.forgeEnergyPerEu = builder.start("forgeEnergyPerEu",
+                "FE per EU",
+                "How many Forge Energy units a single EU from MI is worth.")
+                .defineInRange("forgeEnergyPerEu", 10, 1, 1000);
         this.baseItemPipeTransfer = builder.start("baseItemPipeTransfer",
                 "Base item pipe transfer",
                 "Base amount of items transferred by item pipes every 3 seconds.")
@@ -56,7 +60,6 @@ private MIServerConfig(MIConfigBuilder builder) {
                 "Respawn with guidebook",
                 "Grant guidebook when a player respawns after death.")
                 .define("respawnWithGuideBook", true);
-        builder.popSection();
 
         builder.pushSection("recipes", "Recipes");
         this.compostableToPlantOil = builder.start("compostableToPlantOil",