A beacon announces itself to its own system, not to the galaxy

- teach every body of the beacon's system, moons included
- stop re-announcing to the global set on load; the local sets hold it
- return who learned, so the caller owns the syncing

Author: StannisMod

src/main/java/zmaster587/advancedRocketry/dimension/DimensionProperties.java

@@ -767,11 +767,64 @@ public void setHasRings(boolean value) {
     //Adds a beacon location to the planet's surface
     public void addBeaconLocation(World world, HashedBlockPosition pos) {
         beaconLocations.add(pos);
-        DimensionManager.getInstance().knownPlanets.add(getId());
 
         //LAAZZY
-        if (!world.isRemote)
+        if (!world.isRemote) {
+            for (DimensionProperties taught : teachOwnSystem()) {
+                PacketHandler.sendToAll(new PacketDimInfo(taught.getId(), taught));
+            }
             PacketHandler.sendToAll(new PacketDimInfo(getId(), this));
+        }
+    }
+
+    /**
+     * Tell the bodies of this body's own system that this place exists, and return the ones that
+     * did not already know.
+     *
+     * <p><b>A beacon is a local announcement, not a galactic one.</b> It used to add this planet to
+     * the GLOBAL known-set, so planting one anywhere made the place selectable from every launch pad
+     * in the game. What is true is narrower and more interesting: the neighbours know, because they
+     * can see it. So the beacon writes into the known-set of every body of its own system, and
+     * nothing outside that system learns anything.</p>
+     *
+     * <p>It can never be the thing that first reveals a place - a beacon is planted by hand, so
+     * somebody already flew here, which means the destination was already reachable. That is why
+     * scoping it costs nothing: a beacon spreads knowledge inside reach and never creates reach.</p>
+     */
+    public List<DimensionProperties> teachOwnSystem() {
+        List<DimensionProperties> taught = new ArrayList<>();
+        discoverPlanet(getId()); // the body it stands on, always - the degenerate system of one
+        StellarBody star = getStar();
+        if (star == null) {
+            return taught; // a world with no star of its own: the beacon teaches only its own ground
+        }
+        for (IDimensionProperties sibling : star.getPlanets()) {
+            DimensionProperties props = DimensionManager.getInstance()
+                    .getDimensionPropertiesOrNull(sibling.getId());
+            if (props == null) {
+                continue;
+            }
+            teach(props, taught);
+            // A moon is a child of its planet rather than of the star, so the star's list alone
+            // would leave every moon of the system ignorant of a beacon in it.
+            for (int childId : props.getChildPlanets()) {
+                DimensionProperties child = DimensionManager.getInstance()
+                        .getDimensionPropertiesOrNull(childId);
+                if (child != null) {
+                    teach(child, taught);
+                }
+            }
+        }
+        return taught;
+    }
+
+    /** Teach {@code body} about this place, collecting it when that changed anything. */
+    private void teach(DimensionProperties body, List<DimensionProperties> taught) {
+        if (body.getId() == getId() || body.isPlanetKnownHere(getId())) {
+            return;
+        }
+        body.discoverPlanet(getId());
+        taught.add(body);
     }
 
     public HashSet<HashedBlockPosition> getBeacons() {
@@ -1692,7 +1745,10 @@ private void readFromTechnicalNBT(NBTTagCompound nbt) {
                 int[] location = list.getIntArrayAt(i);
                 beaconLocations.add(new HashedBlockPosition(location[0], location[1], location[2]));
             }
-            DimensionManager.getInstance().knownPlanets.add(getId());
+            // No global add on load any more. What a beacon taught is held by the bodies it taught,
+            // in their own saved known-sets, so re-announcing this place to the whole game at every
+            // load would put back exactly the reach the scoping removed. A world whose beacons
+            // predate the local sets simply has nothing recorded - 3.0.0 carries no old saves.
         } else
             beaconLocations.clear();
 

src/test/java/zmaster587/advancedRocketry/test/integration/LocalKnowledgeBelongsToABodyTest.java

@@ -1,8 +1,12 @@
 package zmaster587.advancedRocketry.test.integration;
 
+import java.util.List;
+
 import net.minecraft.nbt.NBTTagCompound;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import zmaster587.advancedRocketry.api.dimension.solar.StellarBody;
+import zmaster587.advancedRocketry.dimension.DimensionManager;
 import zmaster587.advancedRocketry.dimension.DimensionProperties;
 import zmaster587.advancedRocketry.test.MinecraftBootstrap;
 
@@ -34,6 +38,47 @@ public static void bootstrap() {
         MinecraftBootstrap.ensure();
     }
 
+    @Test
+    public void aBeaconTeachesItsOwnSystemAndNothingBeyondIt() {
+        // A beacon used to add its planet to the GLOBAL known-set, so planting one made the place
+        // selectable from every launch pad in the game. What is actually true is narrower: the
+        // neighbours know, because they are the ones who can see it.
+        StellarBody star = new StellarBody();
+        star.setId(910);
+        star.setName("Beacon-Test");
+        star.setTemperature(100);
+        DimensionManager.getInstance().addStar(star);
+
+        DimensionProperties beaconed = registerBody(9101, star);
+        DimensionProperties sibling = registerBody(9102, star);
+        DimensionProperties elsewhere = registerBody(9201, null);
+
+        List<DimensionProperties> taught = beaconed.teachOwnSystem();
+
+        assertTrue("the body the beacon stands on must know itself",
+                beaconed.isPlanetKnownHere(9101));
+        assertTrue("a body of the same system must learn it", sibling.isPlanetKnownHere(9101));
+        assertFalse("a body outside the system must learn nothing",
+                elsewhere.isPlanetKnownHere(9101));
+        assertTrue("and the sibling must be reported as changed, so it can be synced",
+                taught.contains(sibling));
+
+        List<DimensionProperties> again = beaconed.teachOwnSystem();
+        assertTrue("a second beacon in the same system teaches nobody twice", again.isEmpty());
+    }
+
+    /** A body registered with the planet layer, optionally orbiting {@code star}. */
+    private static DimensionProperties registerBody(int dimId, StellarBody star) {
+        DimensionProperties props = new DimensionProperties(dimId);
+        props.setName("Body-" + dimId);
+        if (star != null) {
+            props.setStar(star);
+            star.addPlanet(props);
+        }
+        DimensionManager.getInstance().registerDimNoUpdate(props, false);
+        return props;
+    }
+
     @Test
     public void whatOneBodyLearnsIsNotKnownOnAnother() {
         DimensionProperties here = new DimensionProperties(101);