feat: seat 1 to 4 players in the World with co-op's rules

The World held one player, so a co-op room had nothing to run but the
stand-in. Phase 1 of MULTIPLAYER.md needs players keyed by slot, each
with their own hearts, guns, boosts, wallet, traps, and shop.

The World gains a party: Solo is single player exactly as before, and
a Crew keeps one seat (the lead) in the World's own per-player fields
and the rest as mates. Every per-player system runs on each seat in
turn by swapping it in (src/party.ts), so the systems still read
world.player. Zombies hunt the nearest standing player, with one flow
field from every player's tile; the boss, Big Leaguers, and Ankle
Biters fight the player nearest them; blasts and landings hurt every
player they reach; pickups go to whoever touches them. Bullets carry
their shooter in co-op, and a kill pays and is credited to the shooter.
stepWorld applies each slot's intent, and SeatAction and
applySeatAction carry a player's presses (swap, reload, traps, buys,
the exit, leaving the counter, READY) to their own seat.

The decided co-op rules land in the step, only for a Crew: the wave
clear bonus and kills with no single killer are split evenly; a manor
door is paid by the one player at it; each player places one Plank
Pile and one Grumpy Gnome; at zero hearts a player goes down, crawls,
cannot fire, and bleeds out in 10 s unless a teammate standing still
beside them for 2 s revives them with 2 hearts; the fallen return at
the next break; the run ends when everyone is down; friendly fire only
on Nightmare; waves grow by 1.6, 2.2, and 2.8 and health by 1.1 to
1.3 for 2 to 4 players; the break and the World never pause for a
player at the stall or for hit-stop, and the break ends once everyone
here has pressed READY; away players stand frozen and can be hurt.

Single player is unchanged: determinism:diff against origin/main finds
no difference over 30,000 campaign frames (to wave 10) and 7,200
endless frames with mixed steps. The gameplay hash skips the party
while it is Solo. src/party.story.test.ts covers each rule with two
and four players.

Author: Tanner-Scadden

src/chucker.ts

@@ -5,6 +5,7 @@ import { type Level, hasLineOfSight, levelOf } from './arena'
 import { woundPlayer } from './combat'
 import { MS_PER_SECOND, PLAYER_RADIUS, ZOMBIE_HIT_PULSE_MS } from './constants'
 import { directionBetween, normalize } from './geometry'
+import { facingNearest, forEachSeatWhere, isStanding } from './party'
 import type { World } from './world'
 import {
   GameEvent,
@@ -412,17 +413,25 @@ const landings = (
 
 const OUTWARD: Vector = { x: 1, y: 0 }
 
-const land = (model: World, landing: Landing): World => {
-  const { player } = model
-  const landed = modifyFields(model, {
-    frameEvents: Array.append(
-      GameEvent.ZombieLanded({
-        x: landing.at.x,
-        y: landing.at.y,
-        radius: CHUCKER_RULES.landRadius,
-      }),
-    ),
-  })
+// NOTE: a thrown zombie lands on whoever stands under it: every standing
+// player in co-op.
+const land = (model: World, landing: Landing): World =>
+  forEachSeatWhere(
+    modifyFields(model, {
+      frameEvents: Array.append(
+        GameEvent.ZombieLanded({
+          x: landing.at.x,
+          y: landing.at.y,
+          radius: CHUCKER_RULES.landRadius,
+        }),
+      ),
+    }),
+    isStanding,
+    landed => landOn(landed, landing),
+  )
+
+const landOn = (landed: World, landing: Landing): World => {
+  const { player } = landed
   const isHit =
     Invulnerability.isAnyOf(['Vulnerable'])(player.invulnerability) &&
     distanceBetween(landing.at, player) <=
@@ -647,7 +656,9 @@ export const advanceChuckers = (model: World, deltaMs: number): World => {
       Option.match(findZombie(current.zombies, chucker.id), {
         onNone: () => current,
         onSome: latest =>
-          stepShield(stepHeft(current, latest, deltaMs), latest, deltaMs),
+          facingNearest(current, latest, fight =>
+            stepShield(stepHeft(fight, latest, deltaMs), latest, deltaMs),
+          ),
       }),
   )
   const thrownAt = landings(heaved.zombies, deltaMs)
@@ -664,13 +675,14 @@ export const advanceChuckers = (model: World, deltaMs: number): World => {
     (current, chucker) =>
       Option.match(findZombie(current.zombies, chucker.id), {
         onNone: () => current,
-        onSome: latest => {
-          const shielded = tryShield(current, latest)
-          return Option.match(findZombie(shielded.zombies, latest.id), {
-            onNone: () => shielded,
-            onSome: after => tryGrab(shielded, after),
-          })
-        },
+        onSome: latest =>
+          facingNearest(current, latest, fight => {
+            const shielded = tryShield(fight, latest)
+            return Option.match(findZombie(shielded.zombies, latest.id), {
+              onNone: () => shielded,
+              onSome: after => tryGrab(shielded, after),
+            })
+          }),
       }),
   )
 }

src/combat.ts

@@ -11,7 +11,7 @@ import {
   ZOMBIE_HIT_PULSE_MS,
 } from './constants'
 import { circlesOverlap, directionBetween, scaleVector } from './geometry'
-import { earn } from './shop'
+import { forEachSeatWhere, isStanding, payShared } from './party'
 import { trapBlastTarget } from './traps'
 import type { World } from './world'
 import {
@@ -236,25 +236,48 @@ const detonate = (model: World, bomberId: number): World => {
     onNone: () => modifyFields(model, { zombies: () => rest }),
     onSome: blast => {
       const zombieOutcome = blastAll(blast, rest, ZOMBIE_BLAST_TARGET)
-      const playerOutcome = blastOne(blast, PLAYER_BLAST_TARGET)(model.player)
       const trapOutcome = blastAll(
         blast,
         model.traps,
         trapBlastTarget(levelOf(model)),
       )
-      return modifyFields(model, {
-        zombies: () => zombieOutcome.targets,
-        player: () => playerOutcome.target,
-        traps: () => trapOutcome.targets,
-        wallet: wallet => earn(wallet, bountyOf(zombieOutcome.events)),
-        frameEvents: frameEvents => [
-          ...frameEvents,
-          GameEvent.Exploded({ x: blast.x, y: blast.y, radius: blast.radius }),
-          ...playerOutcome.events,
-          ...zombieOutcome.events,
-          ...trapOutcome.events,
-        ],
-      })
+      const scorched = forEachSeatWhere(
+        modifyFields(model, {
+          frameEvents: Array.append(
+            GameEvent.Exploded({
+              x: blast.x,
+              y: blast.y,
+              radius: blast.radius,
+            }),
+          ),
+        }),
+        isStanding,
+        seatWorld => {
+          const playerOutcome = blastOne(
+            blast,
+            PLAYER_BLAST_TARGET,
+          )(seatWorld.player)
+          return modifyFields(seatWorld, {
+            player: () => playerOutcome.target,
+            frameEvents: frameEvents => [
+              ...frameEvents,
+              ...playerOutcome.events,
+            ],
+          })
+        },
+      )
+      return payShared(
+        modifyFields(scorched, {
+          zombies: () => zombieOutcome.targets,
+          traps: () => trapOutcome.targets,
+          frameEvents: frameEvents => [
+            ...frameEvents,
+            ...zombieOutcome.events,
+            ...trapOutcome.events,
+          ],
+        }),
+        bountyOf(zombieOutcome.events),
+      )
     },
   })
 }

src/crawler.ts

@@ -4,6 +4,7 @@ import { modifyFields } from 'foldkit/struct'
 import { type Level, distanceToBox, isSolidAt } from './arena'
 import { PLAYER_RADIUS } from './constants'
 import { circlesOverlap } from './geometry'
+import { nearestOf, targetsOf } from './party'
 import { type Seeded, between, nextRandom } from './prng'
 import { STALL_BOX } from './shop'
 import { trapBlockers } from './traps'
@@ -251,11 +252,12 @@ const cling = (zombie: Zombie, player: Vector, deltaMs: number): Step => {
 }
 
 const stepCrawler =
-  (player: Vector, deltaMs: number) =>
+  (targetFor: (zombie: Zombie) => Vector, deltaMs: number) =>
   (zombie: Zombie): Step => {
     if (zombie.kind !== CRAWLER_KIND || !isWalking(zombie)) {
       return stay(zombie)
     }
+    const player = targetFor(zombie)
     const surfaced = surface(zombie, player, deltaMs)
     const clung = cling(surfaced.zombie, player, deltaMs)
     return {
@@ -272,7 +274,11 @@ export const advanceCrawlers = (model: World, deltaMs: number): World => {
     return model
   }
 
-  const steps = Array.map(model.zombies, stepCrawler(model.player, deltaMs))
+  const targets = targetsOf(model)
+  const steps = Array.map(
+    model.zombies,
+    stepCrawler(zombie => nearestOf(targets, zombie), deltaMs),
+  )
   return modifyFields(model, {
     zombies: () => Array.map(steps, ({ zombie }) => zombie),
     frameEvents: frameEvents => [
@@ -293,6 +299,28 @@ export const ankleSlowAt = (zombies: ReadonlyArray<Zombie>): number =>
     ? CRAWLER_RULES.clingSlow
     : 1
 
+const ANKLE_REACH_PX = 4
+
+// NOTE: in co-op an Ankle Biter slows only the player whose ankles it holds.
+export const ankleSlowNear = (
+  zombies: ReadonlyArray<Zombie>,
+  player: Vector,
+): number =>
+  Array.some(
+    zombies,
+    zombie =>
+      isWalking(zombie) &&
+      ZombieAction.isAnyOf(['Clinging'])(zombie.action) &&
+      circlesOverlap(
+        zombie,
+        bodyRadiusOf(zombie) + ANKLE_REACH_PX,
+        player,
+        PLAYER_RADIUS,
+      ),
+  )
+    ? CRAWLER_RULES.clingSlow
+    : 1
+
 export const surfacingProgress = (zombie: Zombie): number =>
   ZombieAction.isAnyOf(['Burrowed'])(zombie.action)
     ? 1 - zombie.action.remainingMs / Math.max(1, zombie.action.durationMs)

src/difficulty.ts

@@ -1,7 +1,8 @@
-import { Array } from 'effect'
+import { Array, Option } from 'effect'
 import { modifyFields } from 'foldkit/struct'
 
 import type { Model } from './model'
+import { COOP_RULES } from './party'
 import {
   type Difficulty,
   type DifficultyBests,
@@ -85,6 +86,46 @@ export const toughenSpawns = (
   )
 }
 
+// NOTE: co-op's crowd (decided 3): every planned zombie comes with copies
+// spread evenly through the wave, so the count scales by the player count's
+// waveCountScale, each a little after the one it copies, and every one is
+// tougher by its healthScale. One player keeps the wave exactly as rolled.
+const CROWD_GAP_MS = 450
+const CROWD_OFFSET_PX = 5
+
+const scaleAt = (scales: ReadonlyArray<number>, players: number): number =>
+  Option.getOrElse(
+    Option.orElse(Array.get(scales, players - 1), () => Array.last(scales)),
+    () => 1,
+  )
+
+export const crowdSpawns = (
+  players: number,
+  spawns: ReadonlyArray<PlannedSpawn>,
+): ReadonlyArray<PlannedSpawn> => {
+  if (players <= 1) {
+    return spawns
+  }
+  const countScale = scaleAt(COOP_RULES.waveCountScale, players)
+  const healthScale = scaleAt(COOP_RULES.healthScale, players)
+  return Array.flatMap(spawns, (spawn, index) => {
+    const copies =
+      Math.floor((index + 1) * countScale) - Math.floor(index * countScale)
+    const tougher = modifyFields(spawn, {
+      hpScale: scale => scale * healthScale,
+    })
+    return Array.makeBy(copies, copy =>
+      copy === 0
+        ? tougher
+        : modifyFields(tougher, {
+            atMs: atMs => atMs + copy * CROWD_GAP_MS,
+            offset: offset =>
+              offset + (copy % 2 === 1 ? 1 : -1) * CROWD_OFFSET_PX,
+          }),
+    )
+  })
+}
+
 export const difficultySpeedScale = (difficulty: Difficulty): number =>
   DIFFICULTIES[difficulty].speedScale
 

src/frenzy.ts

@@ -1,7 +1,7 @@
 import { Array, Option, Result, pipe } from 'effect'
 import { modifyFields } from 'foldkit/struct'
 
-import { earn } from './shop'
+import { payShared } from './party'
 import type { World } from './world'
 import {
   Frenzy,
@@ -209,12 +209,12 @@ export const payWipedPacks = (before: World, after: World): World => {
     entry => (entry.left <= 0 ? Result.succeed(entry) : Result.fail(entry)),
   )
   const bonus = Array.reduce(wiped, 0, (sum, entry) => sum + entry.bonus)
-  return modifyFields(after, {
+  const tallied = modifyFields(after, {
     frenzyPacks: () => standing,
-    wallet: wallet => (bonus > 0 ? earn(wallet, bonus) : wallet),
     frameEvents: frameEvents => [
       ...frameEvents,
       ...Array.getSomes(Array.map(wiped, wipeEvent(kills))),
     ],
   })
+  return bonus > 0 ? payShared(tallied, bonus) : tallied
 }

src/juice.ts

@@ -195,6 +195,9 @@ const eventTrauma = (event: GameEvent): number =>
     PackWiped: () => 0,
     OvenBelched: () => SHAKE_TRAUMA_BURP,
     ZombieSlipped: () => 0,
+    PlayerDowned: () => SHAKE_TRAUMA_HURT,
+    PlayerRevived: () => 0,
+    FriendlyFire: () => SHAKE_TRAUMA_HURT,
   })
 
 const shakeAxis = (roll: number, trauma: number): number => {
@@ -345,6 +348,9 @@ const eventPopups = (
       generateMany(state, 1, popup('Wipe', bonus, x, y - PAYDAY_POPUP_LIFT_PX)),
     OvenBelched: () => noPopups(state),
     ZombieSlipped: () => noPopups(state),
+    PlayerDowned: () => noPopups(state),
+    PlayerRevived: () => noPopups(state),
+    FriendlyFire: () => noPopups(state),
   })
 
 const agePopups = (

src/kitchen.ts

@@ -16,7 +16,7 @@ import {
 import { ZOMBIE_BLAST_TARGET, bountyOf } from './combat'
 import { BULLET_STEP_PX } from './constants'
 import { KITCHEN_EXIT, boxAround } from './exits'
-import { earn } from './shop'
+import { payShared } from './party'
 import type { World } from './world'
 import {
   GameEvent,
@@ -186,11 +186,13 @@ const scorch = (model: World, oven: Box): World => {
   const events = Array.flatMap(outcomes, ({ events }) => events)
   return Array.isReadonlyArrayEmpty(events)
     ? model
-    : modifyFields(model, {
-        zombies: () => Array.map(outcomes, ({ target }) => target),
-        wallet: wallet => earn(wallet, bountyOf(events)),
-        frameEvents: frameEvents => [...frameEvents, ...events],
-      })
+    : payShared(
+        modifyFields(model, {
+          zombies: () => Array.map(outcomes, ({ target }) => target),
+          frameEvents: frameEvents => [...frameEvents, ...events],
+        }),
+        bountyOf(events),
+      )
 }
 
 type Heat = Readonly<{ oven: Oven; ticksDue: number }>

src/model.ts

@@ -50,6 +50,7 @@ import {
   OrientationLock,
   PageVisibility,
   Particle,
+  Party,
   Phase,
   PickupKind,
   PlayerBests,
@@ -178,6 +179,9 @@ export const Model = Schema.Struct({
   shakeSetting: ShakeSetting,
   rotationSetting: RotationSetting,
   orientationLock: OrientationLock,
+  // NOTE: players sharing this keyboard, from a dev-only `?local=N` link
+  // (MULTIPLAYER.md, "What Phase 1 built"). 1 in every shipped build.
+  localPlayers: Schema.Number,
   shareStats: ShareStatsSetting,
   cursorSetting: CursorSetting,
   maybeVisitId: Schema.Option(Schema.String),
@@ -329,6 +333,8 @@ export const initialModel: Model = {
   shakeSetting: 'On',
   rotationSetting: 'Landscape',
   orientationLock: 'Unsupported',
+  localPlayers: 1,
+  party: Party.Solo(),
   shareStats: 'On',
   cursorSetting: 'Bold',
   maybeVisitId: Option.none(),

src/pacing.ts

@@ -444,15 +444,15 @@ export const delayCampedPacks = (
   routed: ReadonlyArray<PlannedSpawn>,
   clockMs: number,
   worldMs: number,
-  player: Vector,
+  players: ReadonlyArray<Vector>,
 ): ReadonlyArray<PlannedSpawn> => {
   const campedPacks = pipe(
     routed,
     Array.filter(
       spawn =>
         isDue(clockMs)(spawn) &&
         isThroughDoor(spawn) &&
-        isCampingDoor(level, player, spawn.door),
+        Array.some(players, player => isCampingDoor(level, player, spawn.door)),
     ),
     Array.map(({ pack }) => pack),
     Array.dedupe,