wren/val Public Public: anyone can read this; nobody can change it.

/**

 * Who killed whom, read off the match rather than written into it.

 *

 * The round loop counts kills and deaths on the players and says a line

 * about it; it keeps no list. Rather than change the rules to carry one,

 * the arena compares the players before and after a tick: somebody who was

 * alive and is not is a victim, somebody whose kill count went up is a

 * killer, and the line the loop said settles which of them did it when two

 * fall in the same thirtieth of a second.

 *

 * Pure functions over plain marks. Nothing here knows a position, and a fall

 * never carries one — the feed must not be a way to learn where anybody is.

 */

import type { Player, Side } from "./state.ts";

import type { WeaponId } from "./weapons.ts";

/** Everything about a player this module needs, taken at one instant. */

export type Mark = {

  id: string;

  name: string;

  side: Side;

  alive: boolean;

  kills: number;

  weapon: WeaponId;

};

export type Fall = {

  killer: string | null;

  victim: string;

  /** The killer's gun when the kill came from a shot; null when it did not. */

  weapon: WeaponId | null;

  headshot: boolean;

  /** The match clock when it happened. */

  at: number;

};

export const marksOf = (players: Player[]): Mark[] =>

  players.map((p) => ({ id: p.id, name: p.name, side: p.side, alive: p.alive, kills: p.kills, weapon: p.weapon }));

export type Context = {

  at: number;

  /** The lines the round loop said this tick, or the most recent few. */

  events: string[];

  /** Players whose shot landed on this tick, so a molly is not called a gun. */

  shooters: Set<string>;

};

/**

 * The falls between two instants. Killers are matched to victims by the line

 * the loop said, and by side and a spare kill when there is no line.

 */

export function fallsBetween(before: Mark[], after: Mark[], context: Context): Fall[] {

  const was = new Map(before.map((m) => [m.id, m]));

  const falls: Fall[] = [];

  const credit = new Map<string, number>();

  for (const mark of after) {

    const old = was.get(mark.id);

    if (old && mark.kills > old.kills) credit.set(mark.id, mark.kills - old.kills);

  }

  const named = (killer: Mark, victim: Mark): boolean =>

    context.events.includes(`${killer.name} killed ${victim.name}`) ||

    context.events.includes(`${killer.name} headshot ${victim.name}`);

  for (const mark of after) {

    const old = was.get(mark.id);

    if (!old || !old.alive || mark.alive) continue;

    const able = after.filter((m) => (credit.get(m.id) ?? 0) > 0 && m.side !== mark.side);

    const killer = able.find((m) => named(m, mark)) ?? able[0] ?? null;

    if (killer) credit.set(killer.id, (credit.get(killer.id) ?? 1) - 1);

    falls.push({

      killer: killer ? killer.name : null,

      victim: mark.name,

      weapon: killer && context.shooters.has(killer.id) ? killer.weapon : null,

      headshot: killer ? context.events.includes(`${killer.name} headshot ${mark.name}`) : false,

      at: context.at,

    });

  }

  return falls;

}

/** The feed as it is shown: the last few falls, and only the recent ones. */

export const trimFeed = (feed: Fall[], now: number, keep = 5, life = 8): Fall[] =>

  feed.filter((f) => now - f.at <= life).slice(-keep);