fix: stop zombies standing on the player and land point-blank shots

Zombies had no hard stop at the player, only a bite range. After a bite
the player is invulnerable for a second, and in that window a zombie kept
steering at the player's center. A Hotfoot, at up to 52 px/s, reached it
in a few frames (a Story test measured 0.2 px from center). Crowd
separation could also push zombies inward. Bullets spawn at the muzzle,
6 to 9 px out, and their first sweep started there, so a zombie whose
center sat inside the player was behind the start of every shot and could
not be hit.

Now a free zombie's step ends with a hold-off: if its body sinks more
than CONTACT_ALLOWANCE_PX (1 px) into the player's, it is moved back out
along the line from the player to where it stood before the step, through
moveCircle so walls and traps still hold it. Only the zombie moves. It
uses each kind's body radius, so big zombies and the boss stay
consistent, and it still overlaps, so bites, bombers, and clinging work
as before. Shots fired this frame sweep from the player's center instead
of the muzzle, so a zombie hugging the player is the first thing they
hit, and shotgun pellets and knockback apply as usual.

Author: Tanner-Scadden

CHANGELOG.md

@@ -9,7 +9,7 @@ One entry per day, newest first. Only things a player would notice, a handful of
 - ✈️ Play on a plane: once you've visited, the game starts and saves with no internet at all, and wakes up faster with no nap at the end of the loading bar. SETTINGS can link your phone and computer to play from one save.
 - 📱 Play holding your phone upright: the manor zooms in up close, and your guns sit on the wall right under your thumbs. Turn it sideways any time to see the whole room.
 - 🔥 The parlour got cozy: a crackling fire, a comfy sofa, a big rug (something bit it), and smashed-in doors zombies now shuffle through. Rattles' shop got big pictures, chunky price tags, and a skeleton who cheers when you buy and sulks when you can't.
-- 🎯 Lost your cursor on the dark floor? It's big and yellow now (SETTINGS switches it back), and Rattles sells a pricey Laser Sight that shows every shot before you take it.
+- 🎯 Lost your cursor on the dark floor? It's big and yellow now (SETTINGS switches it back), and Rattles sells a pricey Laser Sight that shows every shot before you take it. Hotfoots can't hide inside you anymore either: point-blank shots always land.
 
 ## October 28, 2026: Opening night
 

src/constants.ts

@@ -8,6 +8,9 @@ export const MS_PER_SECOND = 1000
 export const MAX_FRAME_DELTA_MS = 50
 
 export const PLAYER_RADIUS = 4
+// NOTE: how far a zombie's body may sink into the player's. It stays above
+// zero so a zombie held at the edge still overlaps the player and bites.
+export const CONTACT_ALLOWANCE_PX = 1
 export const PLAYER_SPEED = 72
 export const PLAYER_MAX_HP = 5
 export const MUZZLE_DISTANCE = 6

src/contact.story.test.ts

@@ -0,0 +1,218 @@
+import { Array, Option } from 'effect'
+import { given, model, story } from 'foldkit/story'
+import { modifyFields } from 'foldkit/struct'
+import { describe, expect, test } from 'vitest'
+
+import { CONTACT_ALLOWANCE_PX, PLAYER_RADIUS } from './constants'
+import { update } from './main'
+import {
+  Arsenal,
+  Frenzy,
+  GameEvent,
+  Invulnerability,
+  type Model,
+  Phase,
+  type PlannedSpawn,
+  type Zombie,
+  ZombieAction,
+  initialModel,
+} from './model'
+import { holdFire, ticks, zombieOf } from './testing'
+import { WEAPONS } from './weapons'
+import { ZOMBIE_KINDS, bodyRadiusOf } from './zombies'
+
+const FRAME_MS = 16
+const LONG_FRAME_MS = 50
+const PLAYER_X = 150
+const PLAYER_Y = 104
+const EPSILON = 1e-6
+
+const DISTANT_SPAWN: PlannedSpawn = {
+  atMs: 1e9,
+  kind: 'Shambler',
+  door: 'North',
+  offset: 0,
+  speedScale: 1,
+  hpScale: 1,
+  pack: 0,
+  formation: 'Squad',
+}
+
+const fightingBase: Model = modifyFields(initialModel, {
+  maybeSurface: () => Option.some({ left: 0, top: 0, width: 800, height: 400 }),
+  phase: () => Phase.Wave({ wave: 1, elapsedMs: 0, spawns: [DISTANT_SPAWN] }),
+})
+
+const STEADFAST = Invulnerability.Invulnerable({
+  remainingMs: 1e9,
+  durationMs: 1e9,
+})
+
+const sceneOf = (
+  zombies: ReadonlyArray<Zombie>,
+  { isSteadfast = false }: Readonly<{ isSteadfast?: boolean }> = {},
+): Model =>
+  modifyFields(fightingBase, {
+    zombies: () => zombies,
+    player: player =>
+      modifyFields(player, {
+        x: () => PLAYER_X,
+        y: () => PLAYER_Y,
+        facing: () => ({ x: 1, y: 0 }),
+        hp: hp => hp + 50,
+        invulnerability: invulnerability =>
+          isSteadfast ? STEADFAST : invulnerability,
+      }),
+  })
+
+const contactOf = (zombie: Zombie): number =>
+  bodyRadiusOf(zombie) + PLAYER_RADIUS - CONTACT_ALLOWANCE_PX
+
+const gapOf = (current: Model, zombie: Zombie): number =>
+  Math.hypot(zombie.x - current.player.x, zombie.y - current.player.y) -
+  contactOf(zombie)
+
+// NOTE: the smallest gap any free zombie left to its contact distance over
+// every frame. Below zero means a zombie stood deeper inside the player than
+// the allowance.
+const closestGap = (frames: ReadonlyArray<Model>): number =>
+  Array.reduce(frames, Infinity, (closest, frame) =>
+    Array.reduce(frame.zombies, closest, (inner, zombie) =>
+      Math.min(inner, gapOf(frame, zombie)),
+    ),
+  )
+
+const playFrames = (
+  start: Model,
+  count: number,
+  deltaTime: number,
+  before: ReadonlyArray<typeof holdFire> = [],
+): ReadonlyArray<Model> => {
+  const frames: Array<Model> = []
+  story(
+    update,
+    given(start),
+    ...before,
+    ...Array.flatMap(ticks(count, deltaTime), frame => [
+      frame,
+      model((current: Model) => {
+        frames.push(current)
+      }),
+    ]),
+  )
+  return frames
+}
+
+const runnerMaxSpeed = ZOMBIE_KINDS.Runner.speedMax
+
+describe('zombies stop at the player', () => {
+  test('a Hotfoot charging at full speed stops at the player instead of standing on them', () => {
+    const runner = zombieOf('Runner', 1, PLAYER_X - 60, PLAYER_Y, {
+      speed: runnerMaxSpeed,
+    })
+    const frames = playFrames(sceneOf([runner]), 150, FRAME_MS)
+
+    expect(
+      Array.some(frames, frame =>
+        Array.some(frame.zombies, zombie => gapOf(frame, zombie) < 1),
+      ),
+    ).toBe(true)
+    expect(closestGap(frames)).toBeGreaterThanOrEqual(-EPSILON)
+  })
+
+  test('a frenzied Hotfoot on long frames never ends a frame past the allowance', () => {
+    const runner = zombieOf('Runner', 1, PLAYER_X - 40, PLAYER_Y + 3, {
+      speed: runnerMaxSpeed,
+      frenzy: Frenzy.Frenzied({ pack: 1, apartMs: 0 }),
+    })
+    const frames = playFrames(
+      sceneOf([runner], { isSteadfast: true }),
+      60,
+      LONG_FRAME_MS,
+    )
+
+    expect(closestGap(frames)).toBeGreaterThanOrEqual(-EPSILON)
+  })
+
+  test('a crowd pushing from behind does not stack onto the player', () => {
+    const crowd = Array.makeBy(8, index =>
+      zombieOf(
+        index % 2 === 0 ? 'Runner' : 'Shambler',
+        index + 1,
+        PLAYER_X - 20 - (index % 4) * 7,
+        PLAYER_Y - 6 + Math.floor(index / 4) * 12,
+        {
+          speed: index % 2 === 0 ? runnerMaxSpeed : 20,
+        },
+      ),
+    )
+    const frames = playFrames(
+      sceneOf(crowd, { isSteadfast: true }),
+      200,
+      FRAME_MS,
+    )
+
+    expect(closestGap(frames)).toBeGreaterThanOrEqual(-EPSILON)
+  })
+
+  test('a bite still lands and still bumps the Hotfoot back', () => {
+    const runner = zombieOf('Runner', 1, PLAYER_X - 30, PLAYER_Y, {
+      speed: runnerMaxSpeed,
+    })
+    const frames = playFrames(sceneOf([runner]), 60, FRAME_MS)
+    const bitten = Array.findFirstIndex(frames, frame =>
+      Array.some(frame.frameEvents, GameEvent.guards.PlayerHurt),
+    )
+
+    expect(Option.isSome(bitten)).toBe(true)
+    const biteFrame = Option.getOrElse(bitten, () => 0)
+    const knockback = frames[biteFrame]?.zombies[0]?.knockback.x ?? 0
+    expect(knockback).toBeLessThan(0)
+  })
+})
+
+describe('point-blank shots', () => {
+  test('a pistol shot kills a zombie standing on the player', () => {
+    const dazed = modifyFields(
+      zombieOf('Shambler', 1, PLAYER_X - 1, PLAYER_Y, { hp: 1 }),
+      {
+        action: () => ZombieAction.Dazed({ remainingMs: 1e9, durationMs: 1e9 }),
+      },
+    )
+    const frames = playFrames(
+      sceneOf([dazed], { isSteadfast: true }),
+      10,
+      FRAME_MS,
+      [holdFire],
+    )
+
+    expect(
+      Array.some(frames, frame =>
+        Array.some(frame.frameEvents, GameEvent.guards.ZombieKilled),
+      ),
+    ).toBe(true)
+  })
+
+  test('every Barn Buster pellet hits a zombie on the player and knocks it away', () => {
+    const dazed = modifyFields(
+      zombieOf('Shambler', 1, PLAYER_X, PLAYER_Y, { hp: 50 }),
+      {
+        action: () => ZombieAction.Dazed({ remainingMs: 1e9, durationMs: 1e9 }),
+      },
+    )
+    const start = modifyFields(sceneOf([dazed], { isSteadfast: true }), {
+      player: player =>
+        modifyFields(player, {
+          arsenal: () =>
+            Arsenal.HoldingSpare({
+              spare: { kind: 'Shotgun', rounds: 16, loaded: 6, tier: 0 },
+            }),
+        }),
+    })
+    const frames = playFrames(start, 1, FRAME_MS, [holdFire])
+    const shot = frames[0]?.zombies[0]
+
+    expect(shot?.hp).toBe(50 - WEAPONS.Shotgun.pellets * WEAPONS.Shotgun.damage)
+    expect(shot?.knockback.x ?? 0).toBeGreaterThan(0)
+  })
+})

src/simulation.ts

@@ -29,6 +29,7 @@ import {
 import {
   BULLET_MAX,
   BULLET_RADIUS,
+  CONTACT_ALLOWANCE_PX,
   DRY_FIRE_DELAY_MS,
   KNOCKBACK_REST_SPEED,
   MAX_FRAME_DELTA_MS,
@@ -695,6 +696,42 @@ const tickZombieState = (state: ZombieState, deltaMs: number): ZombieState =>
       ZombieState.Dying({ remainingMs: remainingMs - deltaMs, direction }),
   })
 
+const OUTWARD: Vector = { x: 1, y: 0 }
+
+// NOTE: a free zombie stops at the player's body, at most
+// CONTACT_ALLOWANCE_PX deep, so it bites from the edge instead of standing on
+// the player where a shot cannot find it. Only the zombie moves, out along
+// the line from the player to where it stood before this step, so one fast
+// enough to cross the player's center lands back on the side it came from.
+// It moves through moveCircle, so walls and traps still hold it.
+const holdOffPlayer = (
+  zombie: Zombie,
+  moved: Vector,
+  player: Vector,
+  obstacles: Obstacles,
+): Vector => {
+  const reach = bodyRadiusOf(zombie) + PLAYER_RADIUS - CONTACT_ALLOWANCE_PX
+  const deltaX = moved.x - player.x
+  const deltaY = moved.y - player.y
+  if (!isFree(zombie) || deltaX * deltaX + deltaY * deltaY >= reach * reach) {
+    return moved
+  }
+
+  const away = pipe(
+    directionBetween(player, zombie),
+    Option.orElse(() => directionBetween(player, moved)),
+    Option.getOrElse(() => OUTWARD),
+  )
+  const edge = addVectors(player, scaleVector(away, reach))
+  return moveCircle(
+    obstacles.level,
+    moved,
+    { x: edge.x - moved.x, y: edge.y - moved.y },
+    radiusOf(zombie),
+    obstacles.blockers,
+  )
+}
+
 const advanceZombie = (
   zombie: Zombie,
   separation: Vector,
@@ -718,12 +755,17 @@ const advanceZombie = (
     ),
     scaleVector(separation, SEPARATION_SPEED),
   )
-  const moved = moveCircle(
-    obstacles.level,
+  const moved = holdOffPlayer(
     zombie,
-    scaleVector(velocity, seconds),
-    radiusOf(zombie),
-    obstacles.blockers,
+    moveCircle(
+      obstacles.level,
+      zombie,
+      scaleVector(velocity, seconds),
+      radiusOf(zombie),
+      obstacles.blockers,
+    ),
+    target,
+    obstacles,
   )
   return modifyFields(zombie, {
     x: () => moved.x,
@@ -884,19 +926,34 @@ const shieldedTarget = (bullet: Bullet, zombie: Zombie): number =>
       )
     : zombie.id
 
+// NOTE: the player's shots fired this frame. Their sweep starts at the
+// player's center, not the muzzle, so a zombie hugging the player, closer than
+// the muzzle, is still the first thing a point-blank shot hits.
+type FreshShots = Readonly<{ firstId: number; endId: number; from: Vector }>
+
+const sweepStart = (
+  bullet: Bullet,
+  seconds: number,
+  freshShots: FreshShots,
+): Vector =>
+  bullet.id >= freshShots.firstId && bullet.id < freshShots.endId
+    ? freshShots.from
+    : {
+        x: bullet.x - bullet.velocityX * seconds,
+        y: bullet.y - bullet.velocityY * seconds,
+      }
+
 const findBulletHits = (
   bullets: ReadonlyArray<Bullet>,
   zombies: ReadonlyArray<Zombie>,
   boss: Boss,
   seconds: number,
+  freshShots: FreshShots,
 ): ReadonlyArray<BulletHit> => {
   const targets = Array.filter(zombies, isGrounded)
   return Array.getSomes(
     Array.map(bullets, bullet => {
-      const from = {
-        x: bullet.x - bullet.velocityX * seconds,
-        y: bullet.y - bullet.velocityY * seconds,
-      }
+      const from = sweepStart(bullet, seconds, freshShots)
       return pipe(
         targetsFor(bullet, targets),
         Array.map(zombie => maybeContact(from, bullet, zombie)),
@@ -994,8 +1051,22 @@ const skewer =
       },
     )
 
-const resolveBulletHits = (model: Model, seconds: number): Model => {
-  const hits = findBulletHits(model.bullets, model.zombies, model.boss, seconds)
+const resolveBulletHits = (
+  model: Model,
+  seconds: number,
+  firstFreshId: number,
+): Model => {
+  const hits = findBulletHits(
+    model.bullets,
+    model.zombies,
+    model.boss,
+    seconds,
+    {
+      firstId: firstFreshId,
+      endId: model.nextEntityId,
+      from: model.player,
+    },
+  )
   if (Array.isReadonlyArrayEmpty(hits)) {
     return model
   }
@@ -1115,8 +1186,6 @@ const resolvePlayerContact = (model: Model): Model =>
 
 // WEAR
 
-const OUTWARD: Vector = { x: 1, y: 0 }
-
 const shedDirection = (zombie: Zombie, player: Player): Vector =>
   pipe(
     normalize(zombie.knockback),
@@ -1226,7 +1295,7 @@ const advanceWorld = (model: Model, deltaMs: number): Model => {
 
   return pipe(
     recordFootfalls(advanced, deltaMs),
-    footed => resolveBulletHits(footed, seconds),
+    footed => resolveBulletHits(footed, seconds, routed.nextEntityId),
     trapped => advanceTraps(trapped, seconds, deltaMs),
     resolvePlayerContact,
     contacted => recoverActions(contacted, deltaMs),