update multiblock API

Author: RealAntEngineer

.gitignore

@@ -27,3 +27,4 @@ forge*changelog.txt
 # personnal info
 .env
 /logs/
+/run-data/

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RealAntEngineer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

build.gradle

@@ -154,14 +154,19 @@ dependencies {
     runtimeOnly fg.deobf("top.theillusivec4.curios:curios-forge:${curios_version}")
     compileOnly fg.deobf("top.theillusivec4.curios:curios-forge:${curios_version}:api")
 
-    annotationProcessor "org.spongepowered:mixin:${mixin_version}:processor"
 
     //unit test tool
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
     //x chart to plot things
     implementation("org.knowm.xchart:xchart:3.2.2")
 
+    // Prevent Mixin annotation processor from getting into IntelliJ's annotation processor settings
+    // This allows 'Settings > Build, Execution, and Deployment > Build Tools > Gradle > Build and run using' set to IntelliJ to work correctly
+    if (!Boolean.getBoolean('idea.sync.active')) {
+        annotationProcessor "org.spongepowered:mixin:${mixin_version}:processor"
+    }
+
 }
 mixin {
     add sourceSets.main, 'formicapi.refmap.json'
@@ -190,7 +195,8 @@ tasks.named('processResources', ProcessResources).configure {
 }
 
 // Example for how to get properties into the manifest for reading at runtime.
-tasks.named('jar', Jar).configure {
+jar {
+    archiveClassifier = 'slim'
     manifest {
         attributes([
                 'Specification-Title'     : mod_id,
@@ -203,24 +209,30 @@ tasks.named('jar', Jar).configure {
                 'MixinConfig':'formicapi.mixins.json'
         ])
     }
-
-    // This is the preferred method to reobfuscate your jar file
-    finalizedBy 'reobfJar'
+}
+task jarJarRelease {
+    group = 'jarjar'
+    doLast {
+        tasks.jarJar {
+            archiveClassifier = ''
+        }
+    }
+    finalizedBy tasks.jarJar
 }
 
-tasks.named('build').configure {
-    dependsOn 'reobfJar'
+java {
+    withSourcesJar()
+    withJavadocJar()
 }
 
 tasks.test {
     useJUnitPlatform()
     //debug = true;
 }
-// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing:
 
-tasks.named('publish').configure {
-     dependsOn 'reobfJar'
-}
+jar.finalizedBy('reobfJar')
+tasks.jarJar.finalizedBy('reobfJarJar')
+// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing:
 
 // Example configuration to allow publishing using the maven-publish plugin
 
@@ -232,11 +244,15 @@ tasks.named('publish').configure {
 publishing {
     publications {
         mavenJava(MavenPublication) {
-            from components.java
             artifactId = "FormicAPI" // ✅ no spaces or invalid chars
+
+            from components.java
+            fg.component(it)
+            jarJar.component(it)
         }
     }
 }
+/*
 tasks.register("fixModuleMetadata") {
     dependsOn("publishMavenJavaPublicationToMavenLocal")
     doLast {
@@ -274,7 +290,7 @@ afterEvaluate {
             }
         }
     }
-}
+}*/
 tasks.withType(JavaCompile).configureEach {
     options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
 }

gradle.properties

@@ -20,7 +20,7 @@ mod_id=formicapi
 mod_name=Formic API
 mod_license=MIT
 
-mod_version=1.4.2
+mod_version=1.4.3
 
 create_version = 6.0.2-50
 flywheel_version = 1.0.1

src/main/java/com/rae/formicapi/FormicAPI.java

@@ -1,18 +1,13 @@
 package com.rae.formicapi;
 
 import com.rae.formicapi.config.FormicAPIConfigs;
-import com.rae.formicapi.data.managers.FloatMapDataLoader;
 import com.rae.formicapi.data.managers.TwoDTabulatedFunctionLoader;
 import com.rae.formicapi.data.providers.TwoDTabulatedFunctionProvider;
 import com.rae.formicapi.math.data.StepMode;
-import com.rae.formicapi.thermal_utilities.EOSLibrary;
-import com.rae.formicapi.thermal_utilities.eos.CubicEOS;
 import com.rae.formicapi.thermal_utilities.helper.WaterCubicEOS;
-import com.rae.formicapi.thermal_utilities.helper.WaterTableBased;
 import net.minecraft.data.DataGenerator;
 import net.minecraft.data.PackOutput;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.block.Block;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.data.event.GatherDataEvent;
 import net.minecraftforge.event.AddReloadListenerEvent;
@@ -21,7 +16,6 @@
 import net.minecraftforge.fml.ModLoadingContext;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
-import net.minecraftforge.registries.ForgeRegistries;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -81,8 +75,7 @@ output, resource("water/pressure_entropy_to_temperature"),
                             float x = WaterCubicEOS.get_x(P, initialH, initialT);
                             return WaterCubicEOS.getT(initialT, x, P, S);
                         }
-                        ,1e2f,1e-3f, 2e7f, 10e3f,30,100,StepMode.LOGARITHMIC, StepMode.LINEAR, true
-
+                        ,1e2f,1e-3f, 2e7f, 10e3f,300,1000,StepMode.LOGARITHMIC, StepMode.LINEAR, true
                 )
         );
         /*generator.addProvider(event.includeServer(), new TwoDTabulatedFunctionProvider(

src/main/java/com/rae/formicapi/math/data/OneDTabulatedFunction.java

@@ -22,11 +22,29 @@ public OneDTabulatedFunction(TreeMap<Float, Float> table, float step, StepMode m
         this.clamp = clamp;
     }
 
-    private float evaluate(double input, TreeMap<Float, Float> table) {
+    public float evaluate(float input) {
         if (table.isEmpty()) {
             throw new IllegalStateException("Function table is empty");
         }
 
+        // Handle out-of-bounds
+        if (input <= table.firstKey()) {
+            if (clamp) {
+                return table.firstEntry().getValue();
+            }
+            return extrapolateBelow(input);
+        } else if (input >= table.lastKey()) {
+            if (clamp) {
+                return table.lastEntry().getValue();
+            }
+            return extrapolateAbove(input);
+        }
+
+        // Interpolation inside the range
+        return interpolate(input);
+    }
+
+    private float interpolate(double input) {
         float index = (float) (mode.forward.applyAsDouble(input) / step);
         int lowerIndex = (int) Math.floor(index);
         float frac = index - lowerIndex;
@@ -40,16 +58,15 @@ private float evaluate(double input, TreeMap<Float, Float> table) {
             Map.Entry<Float, Float> upper = table.ceilingEntry((float) input);
 
             if (lower == null || upper == null) {
-                return table.get(table.firstKey());
+                return table.get(table.firstKey()); // fallback
             }
 
             float T_lower = lower.getKey();
             float T_upper = upper.getKey();
             if (T_lower == T_upper) {
-                return table.get(T_lower);
+                return lower.getValue();
             }
             float fracAlt = (float) ((input - T_lower) / (T_upper - T_lower));
-
             return lower.getValue() * (1 - fracAlt) + upper.getValue() * fracAlt;
         }
 
@@ -59,33 +76,27 @@ private float evaluate(double input, TreeMap<Float, Float> table) {
         return P1 * (1 - frac) + P2 * frac;
     }
 
-    public float evaluate(float output) {
-        return evaluate(output, table);
-    }
-
-    private float extrapolateBelow(TreeMap<Float, Float> searchMap) {
-        Map.Entry<Float, Float> lower = searchMap.firstEntry();
-        Map.Entry<Float, Float> upper = searchMap.higherEntry(lower.getKey());
-        if (upper == null) return lower.getValue();
-        return linear(searchMap, lower, upper);
+    private float extrapolateBelow(float query) {
+        Map.Entry<Float, Float> lower = table.firstEntry();
+        Map.Entry<Float, Float> upper = table.higherEntry(lower.getKey());
+        if (upper == null) return lower.getValue(); // only one point in table
+        return linear(query, lower, upper);
     }
 
-    private float extrapolateAbove(TreeMap<Float, Float> searchMap) {
-        Map.Entry<Float, Float> upper = searchMap.lastEntry();
-        Map.Entry<Float, Float> lower = searchMap.lowerEntry(upper.getKey());
-        if (lower == null) return upper.getValue();
-        return linear(searchMap, lower, upper);
+    private float extrapolateAbove(float query) {
+        Map.Entry<Float, Float> upper = table.lastEntry();
+        Map.Entry<Float, Float> lower = table.lowerEntry(upper.getKey());
+        if (lower == null) return upper.getValue(); // only one point in table
+        return linear(query, lower, upper);
     }
 
-    private float linear(TreeMap<Float, Float> map, Map.Entry<Float, Float> a, Map.Entry<Float, Float> b) {
+    private float linear(float query, Map.Entry<Float, Float> a, Map.Entry<Float, Float> b) {
         float x1 = a.getKey();
         float x2 = b.getKey();
         float y1 = a.getValue();
         float y2 = b.getValue();
-        float query = map.firstKey(); // doesn't matter in this context
         float t = (query - x1) / (x2 - x1);
         return y1 * (1 - t) + y2 * t;
     }
-
-
 }
+

src/main/java/com/rae/formicapi/math/data/TwoDTabulatedFunction.java

@@ -31,16 +31,6 @@ public class TwoDTabulatedFunction {
             Codec.BOOL.fieldOf("clamp").forGetter(f -> f.clamp)
     ).apply(instance, TwoDTabulatedFunction::new));
 
-    // StreamCodec example (Fabric API style)
-    /*public static final StreamCodec<TwoDTabulatedFunction> STREAM_CODEC = StreamCodec.composite(
-            StreamCodec.map(StreamCodec.FLOAT, StreamCodec.map(StreamCodec.FLOAT, StreamCodec.FLOAT)).fieldOf(TwoDTabulatedFunction::getTable),
-            StreamCodec.FLOAT.fieldOf(f -> f.xStep),
-            StreamCodec.FLOAT.fieldOf(f -> f.yStep),
-            StepMode.STREAM_CODEC.fieldOf(f -> f.xMode),
-            StepMode.STREAM_CODEC.fieldOf(f -> f.yMode),
-            StreamCodec.BOOL.fieldOf(f -> f.clamp),
-            TwoDTabulatedFunction::new
-    );*/
     public TwoDTabulatedFunction(TreeMap<Float, TreeMap<Float, Float>> table, float xStep, float yStep, StepMode xMode, StepMode yMode, boolean clamp) {
         this.table = table;
         this.xStep = xStep;

src/main/java/com/rae/formicapi/multiblock/IMBController.java

@@ -0,0 +1,98 @@
+package com.rae.formicapi.multiblock;
+
+import com.rae.crowns.CROWNS;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Vec3i;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.DirectionalBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+import java.util.ArrayDeque;
+import java.util.HashSet;
+import java.util.Queue;
+import java.util.Set;
+
+public interface IMBController {
+    Vec3i getDefaultOffset();
+    Vec3i getDefaultSize();
+    VoxelShape getGlobalShape(BlockState state, BlockGetter worldIn, BlockPos pos, CollisionContext context);
+    MBStructureBlock getStructure();
+    default Vec3i getOffset(Direction facing, boolean mirrorOnDir){
+        final int dirMultiply = facing.getAxisDirection() == Direction.AxisDirection.NEGATIVE && mirrorOnDir ? -1 : 1;
+        Vec3i defaultOffset = getDefaultOffset();
+        return switch (facing.getAxis()){
+            case Z -> new Vec3i( defaultOffset.getZ(), defaultOffset.getY(), dirMultiply *defaultOffset.getX());
+            case Y -> new Vec3i( defaultOffset.getY(), dirMultiply *defaultOffset.getX(),defaultOffset.getZ());
+            default -> new Vec3i( dirMultiply *defaultOffset.getX(),defaultOffset.getY(), defaultOffset.getZ());
+        };
+    }
+
+    default Vec3i getSize(Direction facing){
+        Vec3i defaultSize = getDefaultSize();
+        return switch (facing.getAxis()){
+            case Z -> new Vec3i(defaultSize.getZ(), defaultSize.getY(), defaultSize.getX());
+            case Y -> new Vec3i(defaultSize.getY(), defaultSize.getX(),defaultSize.getZ());
+            default -> defaultSize;
+        };
+    }
+
+
+    default void repairStructure(Level level, BlockPos controlPos, Direction facing) {
+        if (level.isClientSide()) return;
+        MBStructureBlock structure = getStructure();
+        Set<BlockPos> visited = new HashSet<>();
+        Queue<Node> toVisit = new ArrayDeque<>();
+
+        Vec3i off = getOffset(facing, false);
+        Vec3i size = getSize(facing);
+        BlockPos minCorner = controlPos.offset(off);
+
+        for (Direction dir : Direction.values()) {
+            BlockPos neighborPos = controlPos.relative(dir);
+
+            if (isInsideBounds(neighborPos, minCorner, size)) {
+                toVisit.add(new Node(dir, neighborPos));
+            }
+        }
+        int i = 0;
+        while (!toVisit.isEmpty()) {
+            Node node = toVisit.poll();
+            BlockState current = level.getBlockState(node.pos);
+
+
+            if (!current.is(structure)) {
+                level.setBlockAndUpdate(node.pos, structure.defaultBlockState().setValue(DirectionalBlock.FACING, node.fromDir.getOpposite()));
+                visited.add(node.pos);
+
+                for (Direction dir : Direction.values()) {
+                    BlockPos neighborPos = node.pos.relative(dir);
+                    //System.out.println(neighborPos);
+
+                    if (isInsideBounds(neighborPos, minCorner, size) && !neighborPos.equals(controlPos) && !visited.contains(neighborPos)) {
+                        toVisit.add(new Node(dir, neighborPos));
+                    }
+                }
+            }
+            i++;
+            if (i > 100) {
+                CROWNS.LOGGER.warn("More than 100 blocks");
+                break;
+            }
+        }
+    }
+
+    default boolean isInsideBounds(BlockPos pos, BlockPos minCorner, Vec3i size) {
+        int dx = minCorner.getX() - pos.getX();
+        int dy = minCorner.getY() - pos.getY() ;
+        int dz = minCorner.getZ() - pos.getZ();
+        return dx >= 0 && dx < size.getX() &&
+                dy >= 0 && dy < size.getY() &&
+                dz >= 0 && dz < size.getZ();
+    }
+    record Node(Direction fromDir, BlockPos pos){
+    }
+}