Boss gate: a boss zone spawns its faction's boss, and RunGoal derives whether the exit gate is open

EntityPack.Boss (key 21) carries Entity.IsBoss through save and Continue. GenerateZone adds one boss
per BossZones entry before the ambient return, flying the faction's BossHull or, with the gap logged,
its most expensive available ship hull. RunGoal (ServerShared) is the one owner of boss life and exit
state, derived from Zone.Entities.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Assets/Scripts/ServerShared/Entity.cs

@@ -16,6 +16,8 @@ public abstract class Entity
 {
     public Zone Zone;
     public Faction Faction;
+    // The mark of a zone's boss, written only by ZoneGenerator and restored from the pack. RunGoal reads it.
+    public bool IsBoss;
     public EquippableItem Hull;
     public EquippedItem EquippedHull;
     

Assets/Scripts/ServerShared/EntitySerializer.cs

@@ -28,6 +28,7 @@ public static class EntitySerializer
         else throw new ArgumentException("Attempted to pack an instance of abstract class Entity!");
 
         pack.Settings = entity.Settings;
+        pack.Boss = entity.IsBoss;
 
         pack.Hull = entity.Hull;
         pack.Name = entity.Name;
@@ -81,6 +82,7 @@ public static class EntitySerializer
     private static void Restore(ItemManager itemManager, Zone zone, EntityPack pack, Entity entity)
     {
         entity.Name = pack.Name;
+        entity.IsBoss = pack.Boss;
         entity.Faction = itemManager.ItemData.Get(pack.Faction);
         entity.Children = pack.Children.Select(c =>
         {
@@ -187,6 +189,8 @@ public abstract class EntityPack
     [Key(14)] public EntitySettings Settings;
     [Key(15)] public CultRecordRef<Faction> Faction;
     [Key(16)] public int[][] WeaponGroups;
+    // Keys 17-20 belong to the subclasses; the base's next free key is 21.
+    [Key(21)] public bool Boss;
 
     private int _price;
 

Assets/Scripts/ServerShared/LoadoutGenerator.cs

@@ -140,6 +140,18 @@ public class LoadoutGenerator
     // required item falls back to any manufacturer when none of those make one, which means the product table
     // lacks variety, so it is logged rather than hidden.
     public (FactionProductData product, T design)[] RandomProducts<T>(int count, float sizeExponent, Predicate<T> filter = null, bool required = false) where T : EquippableItemData
+    {
+        var (available, preferManufacturers) = AvailableProducts(filter, required);
+        return available.WeightedRandomElements(ref Random, entry =>
+                (preferManufacturers ? ManufacturerPreference(entry.product.Manufacturer) : 1) *
+                pow(entry.design.Shape.Coordinates.Length, sizeExponent) / // Prioritize larger items
+                pow(entry.design.Price, PriceExponent), // Penalize item price to a controllable degree
+            count);
+    }
+
+    // The products this faction can be offered for a design kind, and whether manufacturer preference applies (it does
+    // not once a required item has fallen back to any manufacturer). The one availability rule for every selection.
+    private ((FactionProductData product, T design)[] available, bool preferManufacturers) AvailableProducts<T>(Predicate<T> filter, bool required) where T : EquippableItemData
     {
         var hulls = ItemManager.ItemData.GetAll<HullData>().ToArray();
         var candidates = ItemManager.ItemData.GetAll<FactionProductData>()
@@ -160,11 +172,27 @@ public class LoadoutGenerator
             preferManufacturers = false;
         }
 
-        return available.WeightedRandomElements(ref Random, entry =>
-                (preferManufacturers ? ManufacturerPreference(entry.product.Manufacturer) : 1) *
-                pow(entry.design.Shape.Coordinates.Length, sizeExponent) / // Prioritize larger items
-                pow(entry.design.Price, PriceExponent), // Penalize item price to a controllable degree
-            count);
+        return (available, preferManufacturers);
+    }
+
+    // A faction's boss: its BossHull when the faction sets one and a product sells it, else the most expensive ship hull
+    // the faction can be offered, with the gap logged. Null only when no ship hull is on offer at all.
+    public EntityPack GenerateBossLoadout()
+    {
+        var bossHull = Faction != null && Faction.BossHull.IsSet() ? ItemManager.ItemData.Get(Faction.BossHull) : null;
+        if (bossHull != null)
+        {
+            var boss = GenerateShipLoadout(hull => hull == bossHull);
+            if (boss != null) return boss;
+            ItemManager.Log($"{Faction.Name}'s BossHull {bossHull.Name} is not sold by any product; its boss flies the most expensive ship hull instead.");
+        }
+        else
+            ItemManager.Log($"{Faction?.Name ?? "This faction"} has no BossHull; its boss flies the most expensive ship hull instead.");
+
+        var (available, _) = AvailableProducts<HullData>(hull => hull.HullType == HullType.Ship, required: true);
+        if (available.Length == 0) return null;
+        var priciest = available.OrderByDescending(entry => entry.design.Price).ThenBy(entry => entry.design.Name, StringComparer.Ordinal).First().design;
+        return GenerateShipLoadout(hull => hull == priciest);
     }
 
     // Hardpoint gear that no hull in the catalog can mount has no home (operator, 2026-09-30: "we'll need to author a

Assets/Scripts/ServerShared/RunGoal.cs

@@ -0,0 +1,41 @@
+using System.Linq;
+using CultMath;
+using static CultMath.math;
+
+// The run's goal: whether a zone's boss lives, and so whether the exit gate is open. Engine-free and stateless; the
+// answer is derived from Zone.Entities (the death path removes the dead, Zone.cs), so no "boss defeated" flag exists to
+// disagree with it, and no presentation decides it.
+public static class RunGoal
+{
+    public static Entity Boss(Zone zone) => zone.Entities.FirstOrDefault(entity => entity.IsBoss);
+
+    public static bool BossAlive(Zone zone) => Boss(zone) != null;
+
+    // The exit gate is open in the galaxy's exit zone once that zone holds no living boss.
+    public static bool ExitOpen(Zone zone) =>
+        zone.Galaxy?.Exit != null && zone.GalaxyZone == zone.Galaxy.Exit && !BossAlive(zone);
+
+    // Where the exit gate sits: at the adjacency wormholes' radius (the zone's radius times the ratio), in the middle of
+    // the widest angular gap between them, so it shares a point with none. A zone with no neighbours gets the +x axis.
+    public static float2 ExitGatePosition(Zone zone, float wormholeDistanceRatio)
+    {
+        var radius = zone.Pack.Radius * wormholeDistanceRatio;
+        var angles = zone.GalaxyZone.AdjacentZones
+            .Select(adjacent => normalize(adjacent.Position - zone.GalaxyZone.Position))
+            .Select(direction => atan2(direction.y, direction.x))
+            .OrderBy(angle => angle)
+            .ToArray();
+        if (angles.Length == 0) return float2(radius, 0);
+
+        var bestAngle = 0f;
+        var bestGap = -1f;
+        for (var i = 0; i < angles.Length; i++)
+        {
+            var next = i + 1 < angles.Length ? angles[i + 1] : angles[0] + 2 * PI;
+            if (next - angles[i] <= bestGap) continue;
+            bestGap = next - angles[i];
+            bestAngle = angles[i] + bestGap / 2;
+        }
+        return float2(cos(bestAngle), sin(bestAngle)) * radius;
+    }
+}

Assets/Scripts/ServerShared/RunGoal.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: de03c3545cb04ce38bf85b713dc5df74

Assets/Scripts/ServerShared/Wormhole.cs

@@ -4,4 +4,6 @@ public class Wormhole
 {
     public float2 Position;
     public GalaxyZone Target;
+    // The run's exit gate: it leads nowhere (Target is null) and ends the run when RunGoal.ExitOpen.
+    public bool Exit;
 }

Assets/Scripts/ServerShared/ZoneGenerator.cs

@@ -337,6 +337,20 @@ public static class ZoneGenerator
 	        if (ambient) PlaceTurrets(lagrangeOrbit, GetLoadoutGenerator(nearestFaction), 2);
         }
 
+        // A boss zone gets its faction's boss whether or not the zone is ambient: the boss is the run's goal, not
+        // wandering traffic. RunGoal reads the mark; nothing else decides whether a boss lives.
+        foreach (var bossFaction in galaxy.BossZones.Where(entry => entry.Value == galaxyZone).Select(entry => entry.Key))
+        {
+	        var boss = GetLoadoutGenerator(bossFaction).GenerateBossLoadout();
+	        if (boss == null)
+	        {
+		        itemManager.Log($"No boss could be generated for {bossFaction.Name}; its boss zone has no boss to kill!");
+		        continue;
+	        }
+	        boss.Boss = true;
+	        pack.Entities.Add(boss);
+        }
+
         if (!ambient) return pack;
 
         var enemyCount = (int)(random.NextFloat() * factionPresence * 2) + baseStationCount;