adding some stuff

Author: RealAntEngineer

build.gradle

@@ -13,6 +13,23 @@ plugins {
     id 'org.spongepowered.mixin' version '0.7.+'
 }
 
+import java.nio.file.Files
+import java.nio.file.Paths
+
+def loadEnv() {
+    def envFile = rootProject.file(".env")
+    if (envFile.exists()) {
+        envFile.eachLine { line ->
+            def matcher = line =~ /^\s*([\w\.]+)\s*=\s*(.*)\s*$/
+            if (matcher.matches()) {
+                def key = matcher[0][1]
+                def value = matcher[0][2]
+                System.setProperty(key, value)
+            }
+        }
+    }
+}
+loadEnv()
 version = mod_version
 group = mod_group_id
 
@@ -65,7 +82,6 @@ minecraft {
         gameTestServer {
             property 'forge.enabledGameTestNamespaces', mod_id
         }
-
         data {
             // example of overriding the workingDirectory set in configureEach above
             workingDirectory project.file('run-data')
@@ -136,10 +152,8 @@ dependencies {
     annotationProcessor "org.spongepowered:mixin:${mixin_version}:processor"
 
     //worldgen tool
-    //worldgen-devtools:4rikEHY9
-    //runtimeOnly fg.deobf("maven.modrinth:worldgen-devtools:1.0.0-bata.2+1.20.5") -> dependent on minecraft too high use it for 1.21.1
-    //runtimeOnly fg.deobf("maven.modrinth:connector:1.0.0-beta.46+1.20.1")
-    //runtimeOnly fg.deobf("maven.modrinth:forgified-fabric-api:0.92.2+1.11.12+1.20.1")
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
 
 
 }
@@ -188,6 +202,9 @@ tasks.named('jar', Jar).configure {
     finalizedBy 'reobfJar'
 }
 
+tasks.test {
+    useJUnitPlatform()
+}
 // 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'
@@ -209,8 +226,8 @@ publishing {
         maven {
             url = uri("https://maven.pkg.github.com/RealAntEngineer/Formic_API")
             credentials {
-                username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
-                password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
+                username = System.getProperty("USERNAME")
+                password = System.getProperty("TOKEN")
             }
         }
     }

gradle.properties

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

src/main/java/com/rae/formicapi/math/Solvers.java

@@ -0,0 +1,87 @@
+package com.rae.formicapi.math;
+
+import com.rae.formicapi.FormicAPI;
+
+import java.util.function.Function;
+
+import static java.lang.Math.abs;
+
+public class Solvers {
+    /**
+     *
+     * @param function the equation you want to solve
+     * @param a first boundaries
+     * @param b second boundaries
+     * @param epsilon tolerance
+     * @return the Solution if there is one or 0.
+     */
+    public static float dichotomy(Function<Float, Float> function, float a, float b, float epsilon) {
+        try {
+            if (function.apply(a) * function.apply(b) > 0) {  //Verification of the boundaries
+                throw new RuntimeException("Wrong boundaries in dichotomy solver : a=" + a + "f(a)=" + function.apply(a) + "| b=" + b + " f(b)=" + function.apply(b));
+            } else {
+                float m = (float) ((a + b) / 2.);
+                while (abs(a - b) > epsilon) {
+                    if (function.apply(m) == 0.0) {
+                        return m;
+                    } else if (function.apply(a) * function.apply(m) > 0) {
+                        a = m;
+                    } else {
+                        b = m;
+                    }
+                    m = (a + b) / 2;
+                }
+                return m;
+            }
+        } catch (RuntimeException e) {
+            FormicAPI.LOGGER.error(e.toString());
+            return 0;
+        }
+    }
+    //TODO complete a naive approach first
+
+    /**
+     * Uses gradient descent to find the minimum of a given function, with adaptive step size.
+     * (generated in part with chatgpt)
+     * @param function a function that has a minimum
+     * @param start starting point
+     * @param step initial learning rate
+     * @param dx small delta used to estimate the derivative
+     * @return the estimated x value at which the function has a minimum, return NaN if there is no solution found
+     */
+    public static float gradientDecent(Function<Float, Float> function, float start, float step, float dx) {
+        float x = start;
+        float learningRate = step;
+        int maxIterations = 10000;
+        float tolerance = 1e-6f;
+        float decay = 0.9f; // How fast the step shrinks when progress slows
+        float minStep = 1e-6f;
+
+        for (int i = 0; i < maxIterations; i++) {
+            float derivative = (function.apply(x + dx) - function.apply(x - dx)) / (2 * dx);
+            float newX = x - learningRate * derivative;
+
+            float currentValue = function.apply(x);
+            float newValue = function.apply(newX);
+
+            if (newValue < currentValue) {
+                // Improvement, keep going
+                x = newX;
+                // Optionally increase the step a little
+                learningRate *= 1.05f;
+            } else {
+                // No improvement, reduce step size
+                learningRate *= decay;
+                if (learningRate < minStep) {
+                    return x;
+                }
+            }
+
+            if (Math.abs(derivative) < tolerance) {
+                return x;
+            }
+        }
+
+        return Float.NaN;
+    }
+}

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

@@ -15,7 +15,7 @@
 
 public class MBShape {
     //make functions for every sizes
-    public static MBShape make3x1x1(DirectionalBlock structure){
+    public static MBShape make3x1x1(MBStructureBlock structure){
         return new MBShape(structure, new Vec3i(3, 1,1), new Vec3i(1,0,0),
                 new HashMap<>(Map.of(
                         Direction.UP, List.of(List.of(List.of(Direction.UP),List.of(),List.of(Direction.DOWN))),
@@ -27,7 +27,7 @@ public static MBShape make3x1x1(DirectionalBlock structure){
                 )
                 ));
     }
-    public static MBShape make2x1x1(DirectionalBlock structure){
+    public static MBShape make2x1x1(MBStructureBlock structure){
         return new MBShape(structure, new Vec3i(2, 1,1), new Vec3i(1,0,0),
                 new HashMap<>(Map.of(
                         Direction.UP, List.of(List.of(List.of(Direction.UP))),
@@ -39,12 +39,12 @@ public static MBShape make2x1x1(DirectionalBlock structure){
                 ));
     }
     //default is north
-    private final DirectionalBlock structure;
+    private final MBStructureBlock structure;
     private final HashMap<Direction, List<List<List<Direction>>>> shapes;// X, Y, Z
     private final Vec3i defaultOffset;
     private final Vec3i defaultSize;
 
-    public MBShape(DirectionalBlock structure,  Vec3i defaultSize,  Vec3i defaultOffset,HashMap<Direction, List<List<List<Direction>>>> shapes) {
+    public MBShape(MBStructureBlock structure,  Vec3i defaultSize,  Vec3i defaultOffset,HashMap<Direction, List<List<List<Direction>>>> shapes) {
         this.structure = structure;
         this.defaultOffset = defaultOffset;
         this.defaultSize = defaultSize;
@@ -96,7 +96,7 @@ public void repairStructure(Level level, BlockPos controlPos, Direction facing){
                                                 negative?-y:y,
                                                 negative?-z:z),
 
-                                        Blocks.DISPENSER.defaultBlockState().setValue(DirectionalBlock.FACING, shape.get(x + off.getX()).get(y + off.getY()).get(z + off.getZ()))
+                                        structure.defaultBlockState().setValue(DirectionalBlock.FACING, shape.get(x + off.getX()).get(y + off.getY()).get(z + off.getZ()))
                                 );
                             }
                         }

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

@@ -143,7 +143,7 @@ public static boolean stillValid(BlockGetter level, BlockPos pos, BlockState sta
         Direction direction = state.getValue(FACING);
         BlockPos targetedPos = pos.relative(direction);
         BlockState targetedState = level.getBlockState(targetedPos);
-        return targetedState.getBlock() instanceof MBStructureBlock ||
+        return //targetedState.getBlock() instanceof MBStructureBlock ||
                 (targetedState.getBlock() instanceof MBController mb && state.is(mb.getStructure()));
     }
 

src/test/java/com/rae/formicapi/TestSolvers.java

@@ -0,0 +1,22 @@
+package com.rae.formicapi;
+
+import com.rae.formicapi.math.Solvers;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestSolvers {
+
+    @Test
+    public void testGradientDescent1() {
+        float result = Solvers.gradientDecent((x)-> x*x,-1, 0.1f,0.01f);
+        float tolerance = 1e-6f;
+        assertTrue(result > 0- tolerance && result < 0 + tolerance);
+    }
+    @Test
+    public void testGradientDescent2() {
+        float result = Solvers.gradientDecent((x)-> (float) Math.abs(Math.cos(x)),0, 0.1f,0.01f);
+        float tolerance = 1e-6f;
+        double expected = Math.PI/2f;
+        assertTrue(result > expected- tolerance && result < expected + tolerance,() -> String.valueOf(result));
+    }
+}