diff --git a/JAVA_MIGRATION.md b/JAVA_MIGRATION.md index a6dc741..3732bbf 100644 --- a/JAVA_MIGRATION.md +++ b/JAVA_MIGRATION.md @@ -532,7 +532,7 @@ Each row keeps its existing descriptor for binary compatibility and gains a Java | `MicroMaterialRegistry.getIdMap(): scala.Tuple2[]` | `materialCount(): int` plus existing `materialName(int)` and `getMaterial(int)` | Implemented with static/companion deprecation; [guide and compiling example](docs/api/MATERIAL_ENUMERATION.md). Consumer release/adoption remains pending | | `TileMultipart.operate(scala.Function1)` | `forEachPart(java.util.function.Consumer)` | Implemented through the legacy virtual hook; preserves captured traversal, detached-part filtering and callback failures. Lifecycle still calls `operate` | | `TileMultipart.occlusionTest(scala.collection.Seq, TMultiPart)` | `testOcclusion(Collection, TMultiPart)` | Implemented with an input snapshot and legacy virtual dispatch, including generated partial occlusion; [guide](docs/api/OCCLUSION.md). Distinct Java name avoids Scala overload resolution | -| `NormalOcclusionTest.apply(scala.collection.Traversable, scala.collection.Traversable)` and companion entry | Java box-versus-box entry, with a distinct name to be chosen after characterization | Still used by ForgeRelocationFMP and OpenComputers. The existing Java `test(Iterable, Iterable)` loop is private; its public part-based sibling does not replace this box-list contract | +| `NormalOcclusionTest.apply(scala.collection.Traversable, scala.collection.Traversable)` and companion entry | `testBoxes(Iterable, Iterable)` | Implemented over the existing Java loop; both inputs snapshotted before geometry tests. [Guide and compiling example](docs/api/OCCLUSION.md#box-versus-box-queries). ForgeRelocationFMP/OpenComputers adoption remains pending | | `TileMultipart.loadParts(scala.collection.Iterable)` | `loadPartList(Collection)` | Implemented through the legacy virtual hook; binding, world notifications, input iteration and partial failure retained. [Loading guide](docs/api/PART_LOADING.md) | | `TileMultipart.partList_$eq(scala.collection.Seq)` | `setPartList(List)` | Implemented through the legacy setter; Java list copied without binding, null sentinel supported. GuideNH's old reflective name remains supported | | `TileMultipart.renderID()` / `renderID_$eq(int)` | `getRenderID()` / `setRenderID(int)` | | @@ -552,10 +552,12 @@ same-name overload there invites a silent wrong-overload bind. lifecycle contracts, and generated server/client tile checks; [guide](docs/api/PART_LOADING.md), [API index](docs/API.md). - [x] Add `testOcclusion(Collection, candidate)` with snapshot ownership, subtype inputs, legacy hook dispatch and generated partial-occlusion coverage; [guide and compiling example](docs/api/OCCLUSION.md). +- [x] Add direct `testBoxes(Iterable, Iterable)` with eager input snapshots, ordered intersection callbacks and retained + static/companion bridges; [migration guide](docs/api/OCCLUSION.md#box-versus-box-queries). - [ ] For remaining siblings, compile external Java examples with Scala excluded from the compile classpath before finalizing names. The proposed `loadParts(Collection)` overload required `scala.collection.Iterable` during javac overload resolution; the implemented `loadPartList(Collection)` avoids that dependency. Apply this gate to the - remaining occlusion and registration overloads as well as checking the emitted consumer bytecode. + remaining registration overloads as well as checking the emitted consumer bytecode. - [ ] Mark the remaining legacy entries above `@Deprecated` with javadoc naming a working replacement. - [ ] Confirm every original descriptor still exists in the ABI fixture after the change. - [ ] Document the supported API with compiling usage examples and an old-to-new migration guide. Validate Java diff --git a/JAVA_MIGRATION_ABI_INVENTORY.md b/JAVA_MIGRATION_ABI_INVENTORY.md index a4c5dcc..0d1cdaa 100644 --- a/JAVA_MIGRATION_ABI_INVENTORY.md +++ b/JAVA_MIGRATION_ABI_INVENTORY.md @@ -131,6 +131,11 @@ This is a much smaller surface than the plan assumed. `TileMultipart.jPartList() widely used accessor (ProjectBlue, WitchingGadgets, buildcraft-compat, extrautilities, gregtech, matter-manipulator), so the Java-first collection API mostly exists already and the Scala overloads are a thin retained shell. +The branch now supplies `NormalOcclusionTest.testBoxes(java.lang.Iterable, java.lang.Iterable)` for the box-list +contract. Both old `apply(Traversable, Traversable)` entries remain, with deprecations pointing to the Java entry. +The shipping ForgeRelocationFMP/OpenComputers companion calls still require their exact descriptor until adoption; +see the [migration guide](docs/api/OCCLUSION.md#box-versus-box-queries) and consumer ledger. + `IDWriter`, ported on this branch, has **zero** downstream references. Its four deprecated Scala function accessors are not load-bearing and can be dropped. diff --git a/JAVA_MIGRATION_CONSUMER_AUDIT.md b/JAVA_MIGRATION_CONSUMER_AUDIT.md index 6d32637..027af50 100644 --- a/JAVA_MIGRATION_CONSUMER_AUDIT.md +++ b/JAVA_MIGRATION_CONSUMER_AUDIT.md @@ -491,7 +491,7 @@ behavior: ## Java API adoption ledger This ledger tracks migration of a specific legacy contract, not completion of an entire consumer's migration. -Material enumeration, tile collection/traversal access, tile loading/storage assignment and collection occlusion queries are implemented on +Material enumeration, tile collection/traversal access, tile loading/storage assignment, tile occlusion and box queries are implemented on `algent/java`. The [API index](docs/API.md) links the guides and compiling Java examples. These additions are not yet tied to a released minimum dependency version. Unlisted contracts remain governed by the inventories above. @@ -505,6 +505,8 @@ tied to a released minimum dependency version. Unlisted contracts remain governe | `TileMultipart.partList(): scala.collection.Seq` | Extra Utilities 1.2.12: multipart renderer iterators | Iterate `jPartList()` without adding detached-part filtering | Retirement/replacement pending | Confirm absence or migration in the target pack before retiring the getter | | `TileMultipart.partList(): scala.collection.Seq` plus reflective getter/setter/loading | GuideNH `7d8fb44e77b9`: `Ae2ForgeMultipartBridge`, `ForgeMultipartHelpers` | `jPartList()` for reads, `setPartList(List)` for staging, `loadPartList(Collection)` for binding/cache reconstruction | Source patch and release pending; preserve world/position setup and following tile/render notifications | Retain the legacy getter/setter/loader until adoption; companion-only generator migration is separate | | `TileMultipart.loadParts(scala.collection.Iterable)` exact reflection | Schematica `3b03ee937953`: `nbt.ForgeMultipart` | Reflect `loadPartList(Collection.class)` and pass its existing Java part list directly | Source patch and release pending; registry map and generator reflection remain separate contracts | No migrated pack version verified; retain the Scala loader descriptor | +| `NormalOcclusionTest$.apply(Traversable, Traversable)` | OpenComputers `2c00f79be24b`: `common.block.Cable.canConnectFromSideFMP`, `server.network.Network.canConnectFromSideFMP` | `NormalOcclusionTest.testBoxes(ownBounds.asJava, otherBounds)`; `otherBounds` already comes from Java `getOcclusionBoxes()` | Source patch and release pending; retain side/color/face filtering | No migrated pack version verified; retain the companion and descriptor | +| `NormalOcclusionTest$.apply(Traversable, Traversable)` | ForgeRelocationFMP `49a810b8c63b`: `FramePart.occlusionTest` | `NormalOcclusionTest.testBoxes(boxes.asJava, getOcclusionBoxes)`; retain combined normal/partial/collision boxes and caller order | Source patch and release pending; preserve temporary face bounds and replacement protocol | No migrated pack version verified; retain the companion and descriptor | Evidence for the FMP addition is under ignored `run/migration-material-enumeration-reference/`. The original reference-compiled Scala consumer still exercises the companion and tuple-array descriptor. The new compiling Java @@ -548,9 +550,17 @@ likewise contains no direct reference to that tile descriptor. The legacy hook i ProjectRed and ForgeRelocationFMP's `canReplacePart` callers need no rename and must retain outgoing-part exclusion. The new collection query is not a blanket replacement for placement checks or the part-level `occlusionTest` hook. `NormalOcclusionTest$.apply(Traversable, Traversable)` remains a separate box-list bridge used by ForgeRelocationFMP -and OpenComputers. Its Java replacement is now explicit in the plan; completion of the tile query does not retire it. +and OpenComputers. Its `testBoxes(Iterable, Iterable)` replacement is now implemented; adoption of either query does +not retire the other contract. Evidence for this slice is under ignored `run/migration-part-occlusion-reference/`; reference checkouts remain unchanged. +The box-query slice retains eager left-then-right input collection, shallow snapshots, ordered/short-circuit intersection +calls, touching tolerance and original input/callback exceptions. Both legacy entries are deprecated without changing +their descriptors or bodies. The Java example compiles with Scala excluded; the shared private copy helper only widens +its generic input to accept box subclasses. The source check found the three box-list calls listed above and no +`testBoxes` collision. The installed `+719` rescan retains all 386 member/type/reflection rows from `+678` across 27 +consumers. Evidence: `run/migration-box-occlusion-reference/`; [guide](docs/api/OCCLUSION.md#box-versus-box-queries). + ## Practical priority for the current branch 1. Keep the existing `+678` ABI fixture as the exact binary floor and correct failures before source cleanup. diff --git a/JAVA_MIGRATION_HANDOFF.md b/JAVA_MIGRATION_HANDOFF.md index a39e6d2..609d339 100644 --- a/JAVA_MIGRATION_HANDOFF.md +++ b/JAVA_MIGRATION_HANDOFF.md @@ -17,7 +17,7 @@ migration checkout; `codex/tile-compatibility-fixes` was deleted after its fixes ## Current state and next target -**556 plain-JVM tests and 243 Java 8 Forge tests pass, with zero failures/errors/skips.** Sources total **224 Java +**563 plain-JVM tests and 243 Java 8 Forge tests pass, with zero failures/errors/skips.** Sources total **224 Java files and 9 Scala files / 747 nonblank Scala lines**. The packaged inventory has 443 classes. Review follow-up: restored packet-scheduler callback mutation behavior with the original Scala hash-map traversal, @@ -32,18 +32,17 @@ use, but no override triggering these three regressions was found. All 443 class payloads and 116 generated dumps are retained. The agreed next milestone is the documented consumer-facing Java API, followed by consumer release/adoption and final Scala removal; see the plan's API migration design and Phases 8–10. -Latest API addition: `TileMultipart.testOcclusion(Collection, TMultiPart)` copies the input -before dispatching through the legacy `occlusionTest(Seq, TMultiPart)` hook. Generated partial-occlusion checks remain -in that path; the query is not full placement approval. Three JVM baseline cases and stronger existing Forge -assertions were committed first as `6744f5b`. Four further JVM cases, a compiling shape example and one Forge -generated-partial case cover the new entry. All 552 pre-change compiled JVM tests pass with their recorded version. -All 443 class APIs retain their existing members, with one method added; 17 ScalaSignature payloads, 3,750 existing -method bodies and 116 generated dumps are unchanged apart from expected deprecation metadata and build-version -literals. Evidence: `run/migration-part-occlusion-reference/`; [guide](docs/api/OCCLUSION.md). +Latest API addition: `NormalOcclusionTest.testBoxes(Iterable, Iterable)` snapshots +both inputs before using the existing geometry loop. Three JVM baseline cases were committed first as `c7a3ed9`; +four more cases exercise the Java entry and compiling example. All 559 pre-change compiled JVM tests pass with their +recorded version. All 443 classes retain their existing members, with one method added and two legacy entries +deprecated; 17 ScalaSignature payloads, 3,751 existing method bodies and 116 generated dumps are unchanged apart from +expected deprecation metadata and build-version literals. The private copy helper's generic input alone widens to +accept box subclasses. Evidence: `run/migration-box-occlusion-reference/`; [guide](docs/api/OCCLUSION.md#box-versus-box-queries). Naming correction: the planned `loadParts(Collection)` overload made javac require `scala.collection.Iterable` even for Java arguments. The distinct `loadPartList` name allows compilation without Scala on the example's classpath. -Keep this compilation gate for remaining occlusion/registration APIs; checking only imports or bytecode is insufficient. +Keep this compilation gate for remaining registration APIs; checking only imports or bytecode is insufficient. Internal storage writes and reconstruction still dispatch through the old setter/loader hooks, not the Java siblings. The [API index](docs/API.md) orients consumers to entry points, compiling examples and migration status. Material @@ -57,11 +56,16 @@ adoption remain pending. Checkouts remain reference-only. The installed `+719` p Java surface; supply missing capabilities, precise contracts, migration guidance and compiling examples. Cover subclass/override behavior and generated extensions as well as ordinary calls. ProjectRed's illuminated microblocks are the representative external extension case. Consumer mods may remain Scala internally while adopting this API. -The next bounded API candidate is the direct box-versus-box `NormalOcclusionTest` contract. Its public box-list entry -still takes Scala `Traversable` on both the static class and companion, while the Java `test(Iterable, Iterable)` loop -is private. ForgeRelocationFMP and OpenComputers use the Scala descriptor. Characterize eager input collection, -ordering/failures and geometric boundaries before adding a distinctly named Java entry and deprecating the bridges. -Verify compilation without Scala. Registry registration guidance and bridges remain another pending slice. +The next bounded API candidate is multipart factory registration: characterize the `IPartFactory2`/Scala function +entries and their existing Java siblings, verify compilation without Scala before choosing names, and document factory +timing/registration semantics with an example and deprecations. Preserve static/companion descriptors for ProjectRed +and ForgeRelocationFMP. Registry lookup for Schematica is a separate capability to assess after registration. + +Progress: seven of the ten Phase 9.1 rows now have implemented/documented Java replacements. The remaining rows are +registration, render-ID accessors and the tuple-returning tile conversion result. That count excludes supported +registry/generator/reflection replacements, extension examples and internal-boundary documentation. Then consumer +patches, releases and pack adoption must precede final Scala removal and client/pack release validation; it is not +a percentage of the whole migration. Pause mechanical extraction of retained Scala shells unless it enables that API, fixes a demonstrated issue or has a measured benefit. `ScalaSignature.ClassSymbolRef.info` remains an optional bounded extraction, not the default next diff --git a/docs/API.md b/docs/API.md index 9da3f6f..54ef6aa 100644 --- a/docs/API.md +++ b/docs/API.md @@ -18,6 +18,7 @@ without converting the rest of its code to Java. | Rebuild parts on an already prepared composite tile | `loadPartList(Collection)` — [part loading](api/PART_LOADING.md) | | Assign stored parts during reconstruction, without binding or notifications | `setPartList(List)` — [storage assignment](api/PART_LOADING.md#storage-assignment) | | Test a candidate against a selected collection of parts | `testOcclusion(Collection, candidate)` — [occlusion queries and generated hooks](api/OCCLUSION.md) | +| Test two groups of bounding boxes directly | `NormalOcclusionTest.testBoxes(Iterable, Iterable)` — [box-versus-box queries](api/OCCLUSION.md#box-versus-box-queries) | Each guide explains ownership, lifecycle, legacy replacements and limitations, and links to a compiling Java example exercised by the test suite. The loading/setter APIs are advanced reconstruction operations; ordinary placement and @@ -47,7 +48,7 @@ Deprecated Scala-facing entry points remain callable, with their descriptors and Follow the method-specific guide: a Java sibling is not automatically a replacement override hook, and reflection must select the intended parameter types when a method is overloaded. -Direct box-versus-box Java occlusion access, remaining registry bridges/documentation, generator/reflection replacements +Remaining registry bridges/documentation, generator/reflection replacements and complete external microblock extension guidance are still pending. In particular, ProjectRed's Scala microblock traits remain a supported dependency; registration signatures alone do not prove a complete Java replacement. diff --git a/docs/api/OCCLUSION.md b/docs/api/OCCLUSION.md index 1d8e17e..8842f0e 100644 --- a/docs/api/OCCLUSION.md +++ b/docs/api/OCCLUSION.md @@ -1,10 +1,12 @@ -# Testing part occlusion from Java +# Testing occlusion from Java [API index](../API.md) The `algent/java` branch adds `TileMultipart.testOcclusion(Collection, TMultiPart)`. It tests a supplied collection of parts through the tile's existing occlusion hook, including generated partial-occlusion checks. This addition is not yet tied to a minimum published dependency version. +For raw geometry, `NormalOcclusionTest.testBoxes(Iterable, Iterable)` tests +two groups of bounding boxes without constructing parts. See [box-versus-box queries](#box-versus-box-queries). ## Example @@ -67,7 +69,54 @@ pair, following the [loader compilation finding](PART_LOADING.md#overrides-and-r No direct consumer calls or overrides of the two-argument tile hook were found in the supplied source/ABI audit. Consumers such as ProjectRed and ForgeRelocationFMP already use the Java-typed `canReplacePart` API and need no rename for that contract. Part-level `occlusionTest(TMultiPart)` remains supported as-is. The Scala `NormalOcclusionTest.apply` -box-versus-box entry is a separate, still-used contract whose Java replacement remains pending. +box-versus-box entry is a separate, still-used contract with the Java replacement below. + +## Box-versus-box queries + +Use `NormalOcclusionTest.testBoxes` when you already have box iterables, including `getOcclusionBoxes()` results: + +```java +public static boolean fitsBounds(Iterable occupied, Cuboid6 candidate) { + return NormalOcclusionTest.testBoxes(occupied, Collections.singletonList(candidate)); +} +``` + +The [complete example](../../src/test/java/codechicken/multipart/examples/BoxOcclusionExample.java) compiles without +Scala on its classpath. Both arguments accept box subclasses and need only implement Java `Iterable`. + +The query fully consumes the first input, then the second, requesting each input's iterator once. It takes shallow +snapshots before testing any pairs, even when one input is empty or the first pair will overlap. Iteration failures +therefore take precedence over geometry results; a failure in the first input prevents reading the second. Input +collections can change during intersection callbacks without changing the captured membership, but boxes themselves +are shared: coordinate changes remain visible. Supply finite iterables and use the game thread for live geometry. + +Each first-group box calls `intersects` on second-group boxes in encounter order. Duplicates participate; the first +intersection returns `false`. No intersections returns `true`. The existing `Cuboid6.intersects` tolerance is retained: +touching faces and sub-tolerance overlaps are allowed. Only cross-group pairs are tested, not pairs within one group. +Neither input nor its boxes is modified by the helper; custom iterators or `intersects` overrides can have side effects. + +Null inputs fail during copying. Null box entries are not eagerly rejected: an empty opposite group never uses them, +and an earlier intersection may avoid them. A reached intersection involving an ordinary null box fails. Iterator and +intersection exceptions propagate unchanged, without undoing callback side effects. + +This does not run part callbacks, generated aggregate partial-occlusion checks, slot checks or placement logic. +Use `tile.testOcclusion` for the tile's occlusion protocol, and the placement/replacement APIs for their wider checks. +The existing `NormalOcclusionTest.apply(JNormalOcclusion, TMultiPart)` part helper remains unchanged. + +Both Scala box-list `apply(Traversable, Traversable)` entries, static and companion, are deprecated with their original +descriptors and bodies retained. OpenComputers' cable/network checks can pass `getOcclusionBoxes()` directly as the +second argument; their Scala `ownBounds` collection needs a Java adapter: + +```scala +import scala.collection.JavaConverters._ +NormalOcclusionTest.testBoxes(ownBounds.asJava, otherBounds) +``` + +ForgeRelocationFMP can similarly adapt its assembled Scala `boxes` sequence and pass its existing Java +`getOcclusionBoxes` iterable directly. Keep its combined normal, partial and collision boxes and caller order intact. +These are migration directions, not changes to the reference checkouts. Consumer releases and pack adoption remain +pending, and the new method has no published minimum dependency version yet. Scala consumers can adopt this FMP API +while keeping their own Scala code. ## Validation @@ -76,3 +125,7 @@ subtype/non-list collections, override routing and the shape example. A Forge te partial trait rejects overlapping partial parts that plain pair tests accept. Existing descriptors, generated output, and frozen pre-change callers are checked separately. Actual client previews and full-pack adoption remain covered by the [manual release checks](../../JAVA_MIGRATION_MANUAL_CHECKS.md). + +Box-query tests run the same snapshot, input-failure, ordering, null and exception contracts against both legacy entries +and the Java entry. The compiling example also covers touching tolerance and containment; frozen pre-change tests +retain calls to both old descriptors. diff --git a/docs/migration/HISTORY.md b/docs/migration/HISTORY.md index 3348e3d..88a37f9 100644 --- a/docs/migration/HISTORY.md +++ b/docs/migration/HISTORY.md @@ -1806,3 +1806,22 @@ differences belong in the [divergence ledger](../../JAVA_MIGRATION_DIVERGENCES.m with the new name was found. The separately load-bearing Scala box-list `NormalOcclusionTest.apply` contract now has an explicit plan row and is the next candidate. Reference checkouts remain unchanged; client previews and consumer release/adoption remain separate gates. Evidence: `run/migration-part-occlusion-reference/`. + +### 2026-09-05 — Java box-versus-box occlusion query + +- Committed three JVM baseline cases as `c7a3ed9` before changing production code. Both static and companion entries + are checked for eager input collection, shallow snapshots, duplicate/callback order, short-circuiting, null handling + and original failures. Saved the pre-API jar, sources, all 559 compiled JVM tests, reports and 116 generated dumps. +- Added `NormalOcclusionTest.testBoxes(Iterable, Iterable)` over the existing + private Java copy/intersection helpers. The copy helper's private generic input now accepts subtypes; its body and + descriptor are unchanged. Both legacy Scala box entries are deprecated without changing their bodies/descriptors. +- Four further JVM cases run the same contracts against the new entry and exercise a compiling geometry example, + including touching tolerance and containment. The Java example compiles without Scala on its classpath. +- Normal/clean build and style checks pass: 563 JVM tests, 243 Forge tests and 559 frozen pre-change JVM tests. + All 443 existing classes, 17 ScalaSignature payloads, 3,751 existing method bodies and 116 generated dumps remain; + exactly one public method and two deprecations are added. Build versions and the private helper's generic widening + are the only other expected metadata differences. +- Updated the API guide/index, ABI notes and adoption ledger for OpenComputers' two connection checks and + ForgeRelocationFMP's combined geometry check. The installed `+719` rescan retains all 386 ABI/reflection rows across + 27 consumers. Reference checkouts are unchanged; consumer release/adoption and manual client/pack checks remain + pending. Next: multipart factory registration. Evidence: `run/migration-box-occlusion-reference/`. diff --git a/src/main/scala/codechicken/multipart/NormalOcclusionTest$.java b/src/main/scala/codechicken/multipart/NormalOcclusionTest$.java index ba89024..743aa96 100644 --- a/src/main/scala/codechicken/multipart/NormalOcclusionTest$.java +++ b/src/main/scala/codechicken/multipart/NormalOcclusionTest$.java @@ -12,6 +12,11 @@ public final class NormalOcclusionTest$ { private NormalOcclusionTest$() {} + /** + * @deprecated Use {@link NormalOcclusionTest#testBoxes(Iterable, Iterable)} with Java iterables. This companion + * entry remains available to previously compiled Scala callers. + */ + @Deprecated public boolean apply(Traversable boxes1, Traversable boxes2) { return NormalOcclusionTest.apply(boxes1, boxes2); } diff --git a/src/main/scala/codechicken/multipart/NormalOcclusionTest.java b/src/main/scala/codechicken/multipart/NormalOcclusionTest.java index af61acc..77d24f4 100644 --- a/src/main/scala/codechicken/multipart/NormalOcclusionTest.java +++ b/src/main/scala/codechicken/multipart/NormalOcclusionTest.java @@ -17,7 +17,35 @@ public final class NormalOcclusionTest { private NormalOcclusionTest() {} - /** Performs the test, returns true if the parts may coexist. */ + /** + * Tests two groups of boxes, returning true if no cross-group pair intersects according to + * {@link Cuboid6#intersects(Cuboid6)}, including its existing tolerance for touching bounds. + * + *

+ * Fully consumes the first input, then the second, once each, before testing any pairs. These shallow snapshots + * preserve order, duplicates, null entries and box identities. The first input is the outer loop; the first + * intersection returns false. Input and intersection exceptions propagate unchanged. Null inputs fail during + * copying; null entries fail only if an intersection call uses them. Empty inputs allow all boxes in the other + * group, but both inputs are still consumed. + * + *

+ * This only tests supplied geometry. It does not invoke part callbacks, perform aggregate partial-occlusion checks + * or approve placement. Boxes remain shared and mutable; changing their coordinates can affect the query. + */ + public static boolean testBoxes(Iterable boxes1, Iterable boxes2) { + List first = new ArrayList<>(); + addAll(first, boxes1); + List second = new ArrayList<>(); + addAll(second, boxes2); + return test(first, second); + } + + /** + * Performs the test, returns true if the parts may coexist. + * + * @deprecated Use {@link #testBoxes(Iterable, Iterable)} with Java iterables. Retained for existing Scala callers. + */ + @Deprecated public static boolean apply(Traversable boxes1, Traversable boxes2) { return test(collect(boxes1), collect(boxes2)); } @@ -54,7 +82,7 @@ public final class NormalOcclusionTest { return result; } - private static void addAll(List target, Iterable boxes) { + private static void addAll(List target, Iterable boxes) { for (Cuboid6 box : boxes) { target.add(box); } diff --git a/src/test/java/codechicken/multipart/NormalOcclusionBoxTest.java b/src/test/java/codechicken/multipart/NormalOcclusionBoxTest.java index 52d12a1..d21ce6a 100644 --- a/src/test/java/codechicken/multipart/NormalOcclusionBoxTest.java +++ b/src/test/java/codechicken/multipart/NormalOcclusionBoxTest.java @@ -16,6 +16,7 @@ import java.util.function.BiFunction; import org.junit.jupiter.api.Test; import codechicken.lib.vec.Cuboid6; +import codechicken.multipart.examples.BoxOcclusionExample; import scala.collection.JavaConversions; import scala.collection.Traversable; @@ -40,6 +41,31 @@ class NormalOcclusionBoxTest { LEGACY.forEach(NormalOcclusionBoxTest::assertNullsAndGeometryFailures); } + @Test + void javaEntrySnapshotsSinglePassInputsBeforeOrderedShortCircuiting() { + assertSnapshotAndOrder(NormalOcclusionTest::testBoxes); + } + + @Test + void javaEntryPropagatesInputFailuresBeforeTestingGeometry() { + assertInputFailures(NormalOcclusionTest::testBoxes); + } + + @Test + void javaEntryKeepsLazyNullBoxesAndOriginalGeometryFailures() { + assertNullsAndGeometryFailures(NormalOcclusionTest::testBoxes); + } + + @Test + void javaExampleKeepsTouchingToleranceAndOverlapRules() { + List occupied = Collections.singletonList(new Cuboid6(0, 0, 0, 0.5, 1, 1)); + assertTrue(BoxOcclusionExample.fitsBounds(occupied, new Cuboid6(0.5, 0, 0, 1, 1, 1))); + assertTrue(BoxOcclusionExample.fitsBounds(occupied, new Cuboid6(0.499995, 0, 0, 1, 1, 1))); + assertFalse(BoxOcclusionExample.fitsBounds(occupied, new Cuboid6(0.49998, 0, 0, 1, 1, 1))); + assertFalse(BoxOcclusionExample.fitsBounds(occupied, new Cuboid6(0.1, 0.1, 0.1, 0.2, 0.2, 0.2))); + assertTrue(BoxOcclusionExample.fitsBounds(Collections.emptyList(), occupied.get(0))); + } + private static void assertSnapshotAndOrder(BiFunction, Iterable, Boolean> query) { List calls = new ArrayList<>(); List left = new ArrayList<>(); diff --git a/src/test/java/codechicken/multipart/examples/BoxOcclusionExample.java b/src/test/java/codechicken/multipart/examples/BoxOcclusionExample.java new file mode 100644 index 0000000..08f6c67 --- /dev/null +++ b/src/test/java/codechicken/multipart/examples/BoxOcclusionExample.java @@ -0,0 +1,16 @@ +package codechicken.multipart.examples; + +import java.util.Collections; + +import codechicken.lib.vec.Cuboid6; +import codechicken.multipart.NormalOcclusionTest; + +/** Compiling example for docs/api/OCCLUSION.md; supplied bounds do not imply full placement approval. */ +public final class BoxOcclusionExample { + + private BoxOcclusionExample() {} + + public static boolean fitsBounds(Iterable occupied, Cuboid6 candidate) { + return NormalOcclusionTest.testBoxes(occupied, Collections.singletonList(candidate)); + } +}