Co-Op Layer

Assets/_Project/Scripts/Simulation/Spawning/PlayerSpawnMath.cs

@@ -0,0 +1,41 @@
+using Unity.Mathematics;
+
+namespace ProjectM.Simulation
+{
+    /// <summary>
+    /// Deterministic spawn-position math for co-op. Pure and side-effect-free — no RNG, no wall-clock —
+    /// so the same NetworkId always yields the same planar offset. The server places each connecting
+    /// player at a stable ring slot keyed by its NetworkId, so players never stack. Unit-tested in
+    /// EditMode (no netcode world required).
+    /// </summary>
+    public static class PlayerSpawnMath
+    {
+        /// <summary>
+        /// Planar (XZ) offset from the base spawn point for a connection's NetworkId. NetworkIds start at
+        /// 1, so id 1 maps to slot 0. Slots are evenly spaced around a ring of <paramref name="radius"/>;
+        /// once a ring's slots are full, further players spill onto an outer ring (radius * (ring + 1)),
+        /// keeping every position distinct. Returns zero when <paramref name="radius"/> &lt;= 0 (degenerate
+        /// or unbaked spawner) so behaviour falls back to the single shared spawn point.
+        /// </summary>
+        public static float3 SpawnOffset(int networkId, float radius, int slots)
+        {
+            if (radius <= 0f)
+                return float3.zero;
+            if (slots < 1)
+                slots = 1;
+
+            int idx = networkId - 1;
+            if (idx < 0)
+                idx = 0;
+
+            int ring = idx / slots;
+            int slotInRing = idx % slots;
+
+            float angle = (2f * math.PI * slotInRing) / slots;
+            float r = radius * (ring + 1);
+
+            math.sincos(angle, out float s, out float c);
+            return new float3(c * r, 0f, s * r);
+        }
+    }
+}