Pin the loop: an address deposited here is one a pad here can aim at

- probe the production gate through a real rocket in the standing world
- probe the Deposit path and report which worlds landed, not just how many
- mint the target for the negative case so nothing else can satisfy it

Author: StannisMod

src/main/java/zmaster587/advancedRocketry/command/test/TestProbeCommand.java

@@ -2548,6 +2548,34 @@ private void handleTelescope(MinecraftServer server, ICommandSender sender, Stri
             return;
         }
 
+        if ("deposit".equalsIgnoreCase(verb)) {
+            // The Deposit button's own path: read the crystal in the machine into what THIS world
+            // knows. Reported as landed/total because an address of a world nobody has landed on has
+            // nothing for tier-1 to fly to and is skipped.
+            java.util.List<Integer> before = new java.util.ArrayList<>();
+            for (zmaster587.advancedRocketry.navigation.CrystalEntry entry
+                    : zmaster587.advancedRocketry.item.ItemMemoryCrystal.memoryOf(
+                            scope.getStackInSlot(
+                                    zmaster587.advancedRocketry.tile.multiblock.TileObservatory
+                                            .SLOT_CRYSTAL)).list()) {
+                if (entry.namesBody()) {
+                    before.add(entry.dimId());
+                }
+            }
+            int[] result = scope.uploadCrystalHere();
+            StringBuilder dims = new StringBuilder("[");
+            for (int i = 0; i < before.size(); i++) {
+                if (i > 0) dims.append(',');
+                dims.append(before.get(i));
+            }
+            dims.append(']');
+            // The dims are reported, not just the count: a test that could only read "3 landed" would
+            // have to guess WHICH worlds a pad here may now be aimed at.
+            send(sender, "{\"ok\":true,\"landed\":" + result[0] + ",\"total\":" + result[1]
+                    + ",\"dims\":" + dims + "}");
+            return;
+        }
+
         if ("abort".equalsIgnoreCase(verb)) {
             boolean stopped = scope.abortRegionScan();
             send(sender, "{\"ok\":" + stopped + telescopeScanFields(scope, scope.getActiveScan(), world) + "}");
@@ -6007,6 +6035,36 @@ private void handleDim(ICommandSender sender, String[] args) {
     // Planet/weather probes ----------------------------------------------
 
     private void handlePlanet(ICommandSender sender, String[] args) {
+        // What a TIER-1 launch pad standing on one world may be aimed at, asked of the production
+        // gate rather than re-derived here: a real rocket in the standing world answers
+        // IPlanetDefiner.isPlanetKnown, and the two halves are reported beside it so a red test says
+        // WHICH of them moved - the pack's floor or what this body has learned.
+        if (args.length >= 3 && "knowledge".equalsIgnoreCase(args[0])) {
+            int standingDim = parseIntOr(args[1], Integer.MIN_VALUE);
+            int targetDim = parseIntOr(args[2], Integer.MIN_VALUE);
+            net.minecraft.world.World here = net.minecraftforge.common.DimensionManager
+                    .getWorld(standingDim);
+            DimensionProperties target = DimensionManager.getInstance()
+                    .getDimensionPropertiesOrNull(targetDim);
+            DimensionProperties standing = DimensionManager.getInstance()
+                    .getDimensionPropertiesOrNull(standingDim);
+            if (here == null || target == null) {
+                send(sender, "{\"error\":\"standing world not loaded or unknown target\"}");
+                return;
+            }
+            zmaster587.advancedRocketry.entity.EntityRocket rocket =
+                    new zmaster587.advancedRocketry.entity.EntityRocket(here);
+            send(sender, "{\"standing\":" + standingDim + ",\"target\":" + targetDim
+                    + ",\"known\":" + rocket.isPlanetKnown(target)
+                    + ",\"global\":" + DimensionManager.getInstance().isPlanetKnown(targetDim)
+                    + ",\"local\":" + (standing != null && standing.isPlanetKnownHere(targetDim))
+                    + ",\"research\":"
+                    + zmaster587.advancedRocketry.api.ARConfiguration.getCurrentConfig()
+                            .planetsMustBeDiscovered
+                    + "}");
+            return;
+        }
+
         if (args.length >= 2 && "info".equalsIgnoreCase(args[0])) {
             int dim = parseIntOr(args[1], Integer.MIN_VALUE);
             DimensionProperties props = DimensionManager.getInstance().getDimensionProperties(dim);

src/main/java/zmaster587/advancedRocketry/tile/multiblock/TileObservatory.java

@@ -1215,7 +1215,7 @@ public void onInventoryButtonPressed(int buttonId) {
      *
      * @return {@code {landed, total}}
      */
-    private int[] uploadCrystalHere() {
+    public int[] uploadCrystalHere() {
         ItemStack crystal = getStackInSlot(SLOT_CRYSTAL);
         if (!ItemMemoryCrystal.isCrystal(crystal)) {
             return new int[] {0, 0};

src/test/java/zmaster587/advancedRocketry/test/server/Tier1AimsAtWhatThisWorldKnowsE2ETest.java

@@ -0,0 +1,159 @@
+package zmaster587.advancedRocketry.test.server;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * The loop the two discovery systems exist to close, driven on a real server: an address is carried
+ * to a world, deposited there, and a tier-1 launch pad standing on that world may then be aimed at
+ * it.
+ *
+ * <p>The unit and integration tiers pin the pieces - a body carries its own known-set, one body's
+ * finds never reach its neighbour, a beacon teaches its own system. What only a server can answer is
+ * whether the PRODUCTION gate a rocket asks agrees: `IPlanetDefiner.isPlanetKnown` reading the world
+ * it is standing in, with the pack's authored set as the floor beneath it.</p>
+ *
+ * <p>Both assertions here are stated against dims the probe itself reports, never against a literal
+ * this test wrote down: which worlds a survey resolves depends on the server's own sky.</p>
+ *
+ * <p>Position-isolated at x=4900-4960 (clear of the survey fixtures at 4300-4660 and the observatory
+ * multiblock fixtures at 4000-4060).</p>
+ */
+public class Tier1AimsAtWhatThisWorldKnowsE2ETest extends AbstractSharedServerTest {
+
+    private static final int CY = 64;
+    private static final int CZ = 4900;
+    private static final int X = 4900;
+
+    private String exec(String command) throws Exception {
+        return String.join("\n", client().execute(command));
+    }
+
+    private String where() {
+        return "0 " + X + " " + CY + " " + CZ;
+    }
+
+    /** Whether the gate a rocket standing in {@code standing} asks says {@code target} is known. */
+    private boolean known(int standing, int target) throws Exception {
+        String reply = exec("artest planet knowledge " + standing + " " + target);
+        assertTrue("the knowledge probe failed: " + reply, reply.contains("\"known\":"));
+        return reply.contains("\"known\":true");
+    }
+
+    /** The same reply's two halves, so a red test says WHICH source moved. */
+    private String halves(int standing, int target) throws Exception {
+        return exec("artest planet knowledge " + standing + " " + target);
+    }
+
+    /** A numeric field of a probe reply. */
+    private static int intField(String json, String name) {
+        String key = "\"" + name + "\":";
+        int at = json.indexOf(key);
+        assertTrue("probe reply has no field " + name + ": " + json, at >= 0);
+        int from = at + key.length();
+        int to = from;
+        while (to < json.length() && "-0123456789".indexOf(json.charAt(to)) >= 0) {
+            to++;
+        }
+        return Integer.parseInt(json.substring(from, to));
+    }
+
+    private static List<Integer> ints(String json, String field) {
+        String key = "\"" + field + "\":[";
+        int at = json.indexOf(key);
+        assertTrue("probe reply has no array " + field + ": " + json, at >= 0);
+        int end = json.indexOf(']', at);
+        String body = json.substring(at + key.length(), end).trim();
+        List<Integer> out = new ArrayList<>();
+        if (!body.isEmpty()) {
+            for (String piece : body.split(",")) {
+                out.add(Integer.parseInt(piece.trim()));
+            }
+        }
+        return out;
+    }
+
+    @Test
+    public void withResearchOnAPadIsNotOfferedAWorldNobodyHasFoundHere() throws Exception {
+        exec("artest config set planetsMustBeDiscovered true");
+
+        assertTrue("the overworld must always be known - it is the floor every pack starts from",
+                known(0, 0));
+
+        // The target is MINTED for this test rather than picked out of the server's planet list: a
+        // world that has just come into existence cannot be in anybody's known-set, so the assertion
+        // below cannot be quietly satisfied by whatever another test taught this world earlier.
+        try {
+            String installed = exec("artest space gen-install 0.9 2000000 987654321");
+            assertTrue("the procedural generator must install: " + installed,
+                    installed.contains("\"ok\":true"));
+            String found = exec("artest space find-procedural 4");
+            assertTrue("a dense procedural galaxy must offer a landable body: " + found,
+                    found.contains("\"ok\":true"));
+            String cell = intField(found, "sx") + " " + intField(found, "sy") + " "
+                    + intField(found, "sz");
+            String realized = exec("artest space realize " + cell);
+            assertTrue("realization must mint a world to ask about: " + realized,
+                    realized.contains("\"ok\":true"));
+            int fresh = intField(realized, "dim");
+
+            String reply = halves(0, fresh);
+            assertTrue("a freshly minted world must be in nobody's global set: " + reply,
+                    reply.contains("\"global\":false"));
+            assertTrue("nor known on the world we are standing on: " + reply,
+                    reply.contains("\"local\":false"));
+            assertFalse("and a pad here must therefore not be offered it: " + reply,
+                    known(0, fresh));
+        } finally {
+            exec("artest space gen-reset");
+        }
+    }
+
+    @Test
+    public void anAddressDepositedHereBecomesSomethingAPadHereCanBeAimedAt() throws Exception {
+        // The sweep runs with research OFF, where what the instrument reaches is resolved outright -
+        // the pacing is a different mechanic with its own test, and waiting for it here would only
+        // make this fixture slower and flakier. The GATE is then asked with research ON, which is
+        // the mode the whole question exists in.
+        exec("artest config set planetsMustBeDiscovered false");
+        exec("artest config set telescopeLimitingMagnitude 30");
+        exec("artest config set telescopePassiveRadiusSteps 1");
+
+        String placed = exec("artest telescope place " + where());
+        assertTrue("could not place an observatory: " + placed, placed.contains("\"ok\":true"));
+        String crystal = exec("artest telescope crystal " + where());
+        assertTrue("the crystal must start blank: " + crystal, crystal.contains("\"addresses\":0"));
+
+        // The instrument watching its own neighbourhood: what it resolves are the bodies of the
+        // system this observatory is standing in, which are the ones that have worlds to fly to.
+        String swept = exec("artest telescope passive " + where());
+        assertTrue("the passive sweep did not start: " + swept, swept.contains("\"ok\":true"));
+        String afterSweep = exec("artest telescope info " + where());
+        assertFalse("the sweep must be finished with research off: " + afterSweep,
+                afterSweep.contains("\"scanning\":true"));
+        exec("artest config set planetsMustBeDiscovered true");
+
+        String deposited = exec("artest telescope deposit " + where());
+        List<Integer> landed = ints(deposited, "dims");
+        assertFalse("the sweep resolved nothing with a world in it, so there is nothing to deposit"
+                + " and this fixture proves nothing: " + deposited, landed.isEmpty());
+
+        for (int dim : landed) {
+            String reply = halves(0, dim);
+            assertTrue("a deposited address must be known to a pad standing here: " + reply,
+                    reply.contains("\"known\":true"));
+            assertTrue("and it must be known LOCALLY - the deposit may not touch the global floor: "
+                    + reply, reply.contains("\"local\":true"));
+        }
+
+        String depositedAgain = exec("artest telescope deposit " + where());
+        assertEquals("depositing the same crystal twice must land the same addresses, not more",
+                landed, ints(depositedAgain, "dims"));
+    }
+}