Initial structure files, switch to full neo instance instead of vanilla

Author: robotgryphon

.gitignore

@@ -39,4 +39,9 @@ bin/
 .vscode/
 
 ### Mac OS ###
-.DS_Store
+.DS_Store
+runs/
+
+run/
+
+logs/

build.gradle.kts

@@ -1,19 +1,31 @@
 plugins {
     id("java")
+    id("net.neoforged.gradle.userdev") version "7.0.96"
 }
 
-group = "dev.compactmods"
-version = "1.0-SNAPSHOT"
+base {
+    archivesName = "spatial"
+    group = "dev.compactmods"
+    version = "0.1.0"
+}
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(17))
+}
 
 repositories {
     mavenCentral()
 }
 
-dependencies {
-    testImplementation(platform("org.junit:junit-bom:5.9.1"))
-    testImplementation("org.junit.jupiter:junit-jupiter")
+runs.create("gameTestServer") {
+    this.gameTest()
+    systemProperty("forge.enabledGameTestNamespaces", "spatial")
+    modSource(sourceSets.main.get())
 }
 
-tasks.test {
-    useJUnitPlatform()
+dependencies {
+    // compileOnly("net.minecraft:neoform_joined:1.20.4-20231207.154220")
+
+    implementation(libraries.neoforge)
+    testImplementation(libraries.neoforge)
 }

settings.gradle.kts

@@ -1,2 +1,39 @@
 rootProject.name = "spatial"
 
+dependencyResolutionManagement {
+    versionCatalogs.create("libraries") {
+        library("neoforge", "net.neoforged", "neoforge")
+                .versionRef("neoforge")
+
+        version("minecraft", "1.20.4")
+        version("neoforge", "20.4.189")
+    }
+}
+
+pluginManagement {
+    repositories {
+        mavenCentral()
+        mavenLocal()
+        gradlePluginPortal()
+
+        maven("https://libraries.minecraft.net") {
+            name = "Minecraft"
+        }
+
+        maven("https://maven.parchmentmc.org") {
+            name = "ParchmentMC"
+            content {
+                includeGroup("org.parchmentmc.data")
+            }
+        }
+
+        maven("https://maven.neoforged.net/releases") {
+            name = "NeoForged"
+        }
+    }
+}
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
+}
+

src/main/java/dev/compactmods/spatial/aabb/AABBHelper.java

@@ -1,2 +1,45 @@
-package dev.compactmods.spatial.aabb;public class AABBHelper {
-}
+package dev.compactmods.spatial.aabb;
+
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+
+public abstract class AABBHelper {
+
+    public static Vec3 minCorner(AABB aabb) {
+        return new Vec3(aabb.minX, aabb.minY, aabb.minZ);
+    }
+
+    public static Vec3 maxCorner(AABB aabb) {
+        return new Vec3(aabb.maxX, aabb.maxY, aabb.maxZ);
+    }
+
+    /**
+     * Given an area, normalizes the bounds so that the minimum coordinates
+     * all equal zero. (i.e. 5,5,5 to 11,11,11 becomes 0,0,0 to 6,6,6)
+     * @param boundaries Original AABB instance.
+     * @return A new instance of AABB, normalized to zero coordinates.
+     */
+    public static AABB normalize(AABB boundaries) {
+        Vec3 offset = minCorner(boundaries).reverse();
+        return boundaries.move(offset);
+    }
+
+    public static AABB normalizeWithin(AABB source, AABB within) {
+        Vec3 offset = minCorner(source).subtract(minCorner(within)).reverse();
+        return source.move(offset);
+    }
+
+    public static AABB alignFloor(AABB source, AABB within) {
+        double targetY = within.minY;
+        return alignFloor(source, targetY);
+    }
+
+    public static AABB alignFloor(AABB source, double targetY) {
+        double offset = source.minY - targetY;
+        return source.move(0, offset * -1, 0);
+    }
+
+    public static String toString(AABB aabb) {
+        return "%s,%s,%s".formatted(aabb.getXsize(), aabb.getYsize(), aabb.getZsize());
+    }
+}

src/test/java/dev/compactmods/spatial/tests/AABBHelperTests.java

@@ -0,0 +1,122 @@
+package dev.compactmods.spatial.tests;
+
+import com.google.common.math.DoubleMath;
+import dev.compactmods.spatial.aabb.AABBHelper;
+import net.minecraft.core.Direction;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestGenerator;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.gametest.framework.TestFunction;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.Rotation;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+
+@GameTestHolder("spatial")
+@PrefixGameTestTemplate(false)
+public class AABBHelperTests {
+    private static final String BATCH = "aabb-helper";
+
+    @GameTest(template = "empty_1x1", batch = BATCH)
+    public static void canFloorToY0(final GameTestHelper test) {
+        // Source minY = 5
+        AABB before = AABB.ofSize(new Vec3(0, 7.5, 0), 5, 5, 5);
+
+        // Align to Y-0
+        final var after = AABBHelper.alignFloor(before, 0);
+
+        test.assertTrue(before.minY == 5, "Before was modified in-place rather than immutably moved.");
+        test.assertTrue(after.minY == 0, "After y level should be zero. (was: %s)".formatted(after.minY));
+        test.assertTrue(after.getYsize() == 5, "AABB size was modified; should have remained the same.");
+        test.succeed();
+    }
+
+    @GameTest(template = "empty_1x1", batch = BATCH)
+    public static void canFloorToAnotherAABB(final GameTestHelper test) {
+        // Source minY = 5
+        AABB before = AABB.ofSize(Vec3.ZERO.relative(Direction.UP, 7.5), 5, 5, 5);
+
+        // Target minY = 1 (bounds are Y 1-11)
+        AABB bounds = AABB.ofSize(Vec3.ZERO.relative(Direction.UP, 6), 10, 10, 10);
+
+        // Align to Y-0
+        final var after = AABBHelper.alignFloor(before, bounds);
+
+        test.assertTrue(before.minY == 5, "Before was modified in-place rather than immutably moved.");
+        test.assertTrue(after.minY == 1, "After y level should be 1. (was: %s)".formatted(after.minY));
+
+        test.assertTrue(after.getYsize() == 5, "AABB size was modified; should have remained the same.");
+        test.succeed();
+    }
+
+    @GameTest(template = "empty_1x1", batch = BATCH)
+    public static void normalizeToZero(final GameTestHelper test) {
+        AABB before = AABB.ofSize(Vec3.ZERO.relative(Direction.UP, 7.5), 5, 5, 5);
+
+        // Align to Y-0
+        final var after = AABBHelper.normalize(before);
+
+        test.assertTrue(before.minY == 5, "Before was modified in-place rather than immutably moved.");
+
+        test.assertTrue(after.minX == 0, "After x level was not zero (was: %s)".formatted(after.minX));
+        test.assertTrue(after.minY == 0, "After y level was not zero (was: %s)".formatted(after.minY));
+        test.assertTrue(after.minZ == 0, "After z level was not zero (was: %s)".formatted(after.minZ));
+
+        test.assertTrue(after.getYsize() == 5, "AABB size was modified; should have remained the same.");
+        test.succeed();
+    }
+
+    @GameTestGenerator
+    public static Collection<TestFunction> normalizeBoundaryTests() {
+        final var random = RandomSource.create();
+        return Stream.concat(
+                        TestUtils.randomVec3Stream(random).limit(10),
+
+                        // Ensure at least one negative and one positive bound are part of the test
+                        Stream.of(
+                                Vec3.ZERO.subtract(-3, -2, 5),
+                                Vec3.ZERO.add(2, 5, 1)
+                        )
+                ).map(randomOffset -> new TestFunction(
+                        BATCH,
+                        "normalize_boundaries_%s".formatted(randomOffset.hashCode()),
+                        "spatial:empty_1x1",
+                        Rotation.NONE,
+                        5,
+                        0,
+                        true,
+                        testHelper -> normalizeIntoBoundaries(testHelper, randomOffset)
+                ))
+                .toList();
+    }
+
+    private static void assertVec3Equals(final GameTestHelper testHelper, Vec3 actual, Vec3 expected) {
+        if(!DoubleMath.fuzzyEquals(actual.x, expected.x, 0.001))
+            testHelper.fail("X did not match expected value (was: %s; expected: %s)".formatted(actual.x, expected.x));
+
+        if(!DoubleMath.fuzzyEquals(actual.y, expected.y, 0.001))
+            testHelper.fail("Y did not match expected value (was: %s; expected: %s)".formatted(actual.y, expected.y));
+
+        if(!DoubleMath.fuzzyEquals(actual.z, expected.z, 0.001))
+            testHelper.fail("Z did not match expected value (was: %s; expected: %s)".formatted(actual.z, expected.z));
+    }
+
+    public static void normalizeIntoBoundaries(final GameTestHelper test, Vec3 randomOffset) {
+        AABB before = AABB.ofSize(Vec3.ZERO.relative(Direction.UP, 7.5), 5, 5, 5);
+        AABB bounds = AABB.ofSize(randomOffset, 5, 5, 5);
+
+        final var after = AABBHelper.normalizeWithin(before, bounds);
+
+        test.assertTrue(before.minY == 5, "Before was modified in-place rather than immutably moved.");
+
+        assertVec3Equals(test, AABBHelper.minCorner(after), AABBHelper.minCorner(bounds));
+
+        test.assertTrue(after.getYsize() == 5, "AABB size was modified; should have remained the same.");
+        test.succeed();
+    }
+}

src/test/java/dev/compactmods/spatial/tests/TestUtils.java

@@ -0,0 +1,13 @@
+package dev.compactmods.spatial.tests;
+
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.stream.Stream;
+
+public class TestUtils {
+
+    public static Stream<Vec3> randomVec3Stream(RandomSource random) {
+        return Stream.generate(() -> new Vec3(random.nextDouble(), random.nextDouble(), random.nextDouble()));
+    }
+}

src/test/resources/test_pack/data/spatial/structures/empty_15x15.nbt

@@ -0,0 +1,6 @@
+{
+  "pack": {
+    "description": "Spatial test resources",
+    "pack_format": 18
+  }
+}