A survey teaches the world it was made from

- report the bodies a look actually named, for a caller that can act
- the observatory teaches its own dimension and syncs it like a beacon
- only a resolved, unobscured, full-detail look may teach anything

Author: StannisMod

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

@@ -1,5 +1,10 @@
 package zmaster587.advancedRocketry.tile.multiblock;
 
+import java.util.HashSet;
+import java.util.Set;
+import zmaster587.advancedRocketry.dimension.DimensionManager;
+import zmaster587.advancedRocketry.dimension.DimensionProperties;
+import zmaster587.advancedRocketry.network.PacketDimInfo;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
@@ -901,6 +906,35 @@ public boolean beginPassiveSweep() {
         return true;
     }
 
+    /**
+     * Teach the world this observatory stands on what the survey just made out.
+     *
+     * <p>Server side only, and only what has a dimension. The set is a body's own, additive over the
+     * global known-set rather than a replacement for it, so a pack that authored its known planets
+     * keeps them and a world merely adds what it has learned since. Syncing goes through the same
+     * channel a beacon uses, because this is the same kind of fact.</p>
+     */
+    private void teachThisBody(Set<Integer> discovered) {
+        if (discovered.isEmpty() || world == null || world.isRemote) {
+            return;
+        }
+        DimensionProperties here = DimensionManager.getInstance()
+                .getDimensionPropertiesOrNull(world.provider.getDimension());
+        if (here == null) {
+            return; // a world the planet layer does not own - nothing here can learn
+        }
+        boolean learned = false;
+        for (int dimId : discovered) {
+            if (!here.isPlanetKnownHere(dimId)) {
+                here.discoverPlanet(dimId);
+                learned = true;
+            }
+        }
+        if (learned) {
+            PacketHandler.sendToAll(new PacketDimInfo(here.getId(), here));
+        }
+    }
+
     /** The observation in flight, or {@code null}. */
     @Nullable
     public RegionScan getActiveScan() {
@@ -1083,9 +1117,15 @@ private void completeRegionScanIfDue() {
         GalacticCoord origin = scanOrigin();
         UniverseRegistry registry = UniverseRegistry.get(world);
         lastScanObscured += countObscured(registry, origin, activeScan, activeScan.cellsDone(), cells);
+        // WHERE the instrument stands is what it teaches. A survey writes the crystal the operator
+        // will carry away, and it also teaches the body underneath: a launch pad here may afterwards
+        // be aimed at what this telescope made out, while a pad on the next world may not. Only a
+        // NAMED body can be taught - a bare address has no world to fly to.
+        Set<Integer> taughtHere = new HashSet<>();
         lastScanDiscoveries += TelescopeScan.resolveBatch(registry, activeScan,
                 activeScan.cellsDone(), cells, crystal, now, TelescopeScan.dimensionNames(), origin,
-                characteriseWholeSystem);
+                characteriseWholeSystem, taughtHere::add);
+        teachThisBody(taughtHere);
         activeScan = instant ? activeScan.completed(now) : activeScan.advanced(now, cells);
         if (activeScan.isComplete()) {
             activeScan = null;

src/main/java/zmaster587/advancedRocketry/universe/TelescopeScan.java

@@ -4,6 +4,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
+import java.util.function.IntConsumer;
 import java.util.function.IntFunction;
 
 import net.minecraft.item.ItemStack;
@@ -231,6 +232,20 @@ public static List<Detection> detect(UniverseRegistry registry, GalacticCoord lo
     public static int characterise(UniverseRegistry registry, Detection hit, CrystalMemory memory,
                                    long observedTick, IntFunction<String> nameOf,
                                    boolean wholeSystem) {
+        return characterise(registry, hit, memory, observedTick, nameOf, wholeSystem, null);
+    }
+
+    /**
+     * The same, telling {@code named} the dimension of every body this look actually made out.
+     *
+     * <p>The callback is a fact about the OBSERVATION - "this look named that world" - and nothing
+     * more; what a caller does with it belongs to the caller. It fires only for a body that has a
+     * dimension: an unrealized body has no world to fly to, and an address that names no body
+     * (unresolvable, obscured, or positions-only) reports nothing at all.</p>
+     */
+    public static int characterise(UniverseRegistry registry, Detection hit, CrystalMemory memory,
+                                   long observedTick, IntFunction<String> nameOf,
+                                   boolean wholeSystem, IntConsumer named) {
         if (registry == null || hit == null || memory == null) {
             return 0;
         }
@@ -244,6 +259,9 @@ public static int characterise(UniverseRegistry registry, Detection hit, Crystal
                 if (memory.record(entryFor(body, observedTick, nameOf))) {
                     written++;
                 }
+                if (named != null && body.dimId() != Constants.INVALID_PLANET) {
+                    named.accept(body.dimId());
+                }
             }
         }
         if (!namedSomething) {
@@ -269,12 +287,20 @@ public static int resolveBatch(UniverseRegistry registry, RegionScan scan, int f
     public static int resolveBatch(UniverseRegistry registry, RegionScan scan, int from, int count,
                                    ItemStack crystal, long observedTick, IntFunction<String> nameOf,
                                    GalacticCoord observer, boolean wholeSystem) {
+        return resolveBatch(registry, scan, from, count, crystal, observedTick, nameOf, observer,
+                wholeSystem, null);
+    }
+
+    /** The same, reporting every body the batch named to {@code named}. */
+    public static int resolveBatch(UniverseRegistry registry, RegionScan scan, int from, int count,
+                                   ItemStack crystal, long observedTick, IntFunction<String> nameOf,
+                                   GalacticCoord observer, boolean wholeSystem, IntConsumer named) {
         if (!ItemMemoryCrystal.isCrystal(crystal)) {
             return 0;
         }
         CrystalMemory memory = ItemMemoryCrystal.memoryOf(crystal);
         int written = resolveBatch(registry, scan, from, count, memory, observedTick, nameOf,
-                observer, wholeSystem);
+                observer, wholeSystem, named);
         if (written > 0) {
             ItemMemoryCrystal.writeMemory(crystal, memory);
         }
@@ -294,14 +320,22 @@ public static int resolveBatch(UniverseRegistry registry, RegionScan scan, int f
     public static int resolveBatch(UniverseRegistry registry, RegionScan scan, int from, int count,
                                    CrystalMemory memory, long observedTick, IntFunction<String> nameOf,
                                    GalacticCoord observer, boolean wholeSystem) {
+        return resolveBatch(registry, scan, from, count, memory, observedTick, nameOf, observer,
+                wholeSystem, null);
+    }
+
+    /** The same, reporting every body the batch named to {@code named}. */
+    public static int resolveBatch(UniverseRegistry registry, RegionScan scan, int from, int count,
+                                   CrystalMemory memory, long observedTick, IntFunction<String> nameOf,
+                                   GalacticCoord observer, boolean wholeSystem, IntConsumer named) {
         if (registry == null || scan == null || memory == null) {
             return 0;
         }
         double limit = limitMagnitude();
         int written = 0;
         for (int index = from; index < from + count && index < scan.totalCells(); index++) {
             written += resolveLook(registry, scan.cellAt(index), memory, observedTick, nameOf,
-                    observer, limit, wholeSystem);
+                    observer, limit, wholeSystem, named);
         }
         return written;
     }
@@ -320,9 +354,18 @@ public static int resolveLook(UniverseRegistry registry, GalacticCoord look, Cry
                                   long observedTick, IntFunction<String> nameOf,
                                   GalacticCoord observer, double limitMagnitude,
                                   boolean wholeSystem) {
+        return resolveLook(registry, look, memory, observedTick, nameOf, observer, limitMagnitude,
+                wholeSystem, null);
+    }
+
+    /** The same, reporting every body this look named to {@code named}. */
+    public static int resolveLook(UniverseRegistry registry, GalacticCoord look, CrystalMemory memory,
+                                  long observedTick, IntFunction<String> nameOf,
+                                  GalacticCoord observer, double limitMagnitude,
+                                  boolean wholeSystem, IntConsumer named) {
         int written = 0;
         for (Detection hit : detect(registry, look, observer, limitMagnitude)) {
-            written += characterise(registry, hit, memory, observedTick, nameOf, wholeSystem);
+            written += characterise(registry, hit, memory, observedTick, nameOf, wholeSystem, named);
         }
         return written;
     }

src/test/java/zmaster587/advancedRocketry/test/unit/TelescopeConeSurveyTest.java

@@ -1,5 +1,6 @@
 package zmaster587.advancedRocketry.test.unit;
 
+import java.util.Collections;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
@@ -607,4 +608,66 @@ public void aGeneratorWithNoStarsGivesAnInstrumentNothingToReach() {
                 empty.maxRangeLightYears(), 0d);
         assertEquals("which is still a pointing, of one territory", 1, empty.maxRangeSteps());
     }
+
+    // ── what a look may teach the ground it was made from ─────────────────────
+
+    @Test
+    public void aLookReportsOnlyTheBodiesItActuallyMadeOut() {
+        // The coupling that lets an observatory teach the world underneath it: the instrument may
+        // pass on a body only when it RESOLVED one. A star has no dimension of its own, so of the
+        // fixture's two objects exactly one can ever be taught.
+        double sunLike = StellarMagnitude.luminositySuns(1.15d, 100);
+        double near = StellarMagnitude.detectionRangeLightYears(sunLike, 12d - 6.5d) / 2d;
+        UniverseRegistry registry = oneStarAt(near, 1.15f, 100);
+        List<TelescopeScan.Detection> hits = TelescopeScan.detect(registry, seatAt(near), HOME, 12d);
+        assertEquals("arrangement: one system to look at", 1, hits.size());
+        assertTrue("arrangement: and it must be resolvable at this distance", hits.get(0).resolvable());
+
+        List<Integer> taught = new ArrayList<>();
+        TelescopeScan.characterise(registry, hits.get(0), new CrystalMemory(), 1_000L,
+                id -> "Body-" + id, true, taught::add);
+
+        assertEquals("exactly the planet, and not the star that has no world: " + taught,
+                Collections.singletonList(701), taught);
+    }
+
+    @Test
+    public void aLookThatOnlyREGISTEREDTeachesNothing() {
+        // Inside the aperture, outside what it can make out. The crystal still gets the address -
+        // that is the whole mechanic - but nothing about the system may reach the ground, because
+        // nothing about it was learned.
+        double sunLike = StellarMagnitude.luminositySuns(1.15d, 100);
+        double detectReach = StellarMagnitude.detectionRangeLightYears(sunLike, 12d);
+        double resolveReach = StellarMagnitude.detectionRangeLightYears(sunLike, 12d - 6.5d);
+        double far = (detectReach + resolveReach) / 2d;
+        UniverseRegistry registry = oneStarAt(far, 1.15f, 100);
+        List<TelescopeScan.Detection> hits = TelescopeScan.detect(registry, seatAt(far), HOME, 12d);
+        assertEquals("arrangement: it must still register", 1, hits.size());
+        assertFalse("arrangement: and must not be resolvable", hits.get(0).resolvable());
+
+        CrystalMemory memory = new CrystalMemory();
+        List<Integer> taught = new ArrayList<>();
+        TelescopeScan.characterise(registry, hits.get(0), memory, 1_000L, id -> "Body-" + id,
+                true, taught::add);
+
+        assertTrue("a point of light teaches the ground nothing: " + taught, taught.isEmpty());
+        assertEquals("but the address is still written down", 1, memory.size());
+    }
+
+    @Test
+    public void recordingPositionsOnlyTeachesNothingEither() {
+        // The operator's own choice, not the aperture's limit. Asking for less must also GIVE less
+        // to the ground, or "positions only" would quietly be a full survey for tier-1.
+        double sunLike = StellarMagnitude.luminositySuns(1.15d, 100);
+        double near = StellarMagnitude.detectionRangeLightYears(sunLike, 12d - 6.5d) / 2d;
+        UniverseRegistry registry = oneStarAt(near, 1.15f, 100);
+        List<TelescopeScan.Detection> hits = TelescopeScan.detect(registry, seatAt(near), HOME, 12d);
+        assertTrue("arrangement: the aperture must not be what limits this", hits.get(0).resolvable());
+
+        List<Integer> taught = new ArrayList<>();
+        TelescopeScan.characterise(registry, hits.get(0), new CrystalMemory(), 1_000L,
+                id -> "Body-" + id, false, taught::add);
+
+        assertTrue("an operator recording addresses teaches no world: " + taught, taught.isEmpty());
+    }
 }