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

import { describe, expect, test } from "bun:test";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { fallsBetween, marksOf, trimFeed, type Mark } from "./killfeed.ts";

import { newMatch } from "./match.ts";

process.env.FORGE_APP_DATA ??= mkdtempSync(join(tmpdir(), "app-"));

const mark = (id: string, over: Partial<Mark> = {}): Mark => ({

  id,

  name: id,

  side: "atk",

  alive: true,

  kills: 0,

  weapon: "vandal",

  ...over,

});

const context = (events: string[] = [], shooters: string[] = [], at = 10) => ({

  at,

  events,

  shooters: new Set(shooters),

});

describe("reading falls out of two instants", () => {

  test("a shot kill names the killer, the victim and the gun", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "def" })];

    const after = [mark("A", { side: "atk", kills: 1 }), mark("B", { side: "def", alive: false })];

    const falls = fallsBetween(before, after, context(["A killed B"], ["A"]));

    expect(falls).toEqual([{ killer: "A", victim: "B", weapon: "vandal", headshot: false, at: 10 }]);

  });

  test("a head shot is marked as one", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "def" })];

    const after = [mark("A", { side: "atk", kills: 1 }), mark("B", { side: "def", alive: false })];

    expect(fallsBetween(before, after, context(["A headshot B"], ["A"]))[0]!.headshot).toBe(true);

  });

  test("a kill with no shot behind it names no gun — a molly is not a Vandal", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "def" })];

    const after = [mark("A", { side: "atk", kills: 1 }), mark("B", { side: "def", alive: false })];

    expect(fallsBetween(before, after, context(["A killed B"]))[0]!.weapon).toBe(null);

  });

  test("dying to nobody — a molly of your own, a fall — has no killer", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "def" })];

    const after = [mark("A", { side: "atk" }), mark("B", { side: "def", alive: false })];

    const falls = fallsBetween(before, after, context(["B died"]));

    expect(falls.length).toBe(1);

    expect(falls[0]!.killer).toBe(null);

    expect(falls[0]!.weapon).toBe(null);

  });

  test("two kills in one tick go to the right killers, by what the loop said", () => {

    const before = [

      mark("A", { side: "atk" }),

      mark("C", { side: "atk" }),

      mark("B", { side: "def" }),

      mark("D", { side: "def" }),

    ];

    const after = [

      mark("A", { side: "atk", kills: 1 }),

      mark("C", { side: "atk", kills: 1 }),

      mark("B", { side: "def", alive: false }),

      mark("D", { side: "def", alive: false }),

    ];

    const falls = fallsBetween(before, after, context(["C killed B", "A killed D"], ["A", "C"]));

    expect(falls.find((f) => f.victim === "B")!.killer).toBe("C");

    expect(falls.find((f) => f.victim === "D")!.killer).toBe("A");

  });

  test("a killer is never somebody on the victim's own side", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "atk" }), mark("E", { side: "def" })];

    const after = [

      mark("A", { side: "atk", kills: 1 }),

      mark("B", { side: "atk", alive: false }),

      mark("E", { side: "def" }),

    ];

    expect(fallsBetween(before, after, context([]))[0]!.killer).toBe(null);

  });

  test("a kill with two victims and one killer only credits the one kill", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "def" }), mark("C", { side: "def" })];

    const after = [

      mark("A", { side: "atk", kills: 1 }),

      mark("B", { side: "def", alive: false }),

      mark("C", { side: "def", alive: false }),

    ];

    const falls = fallsBetween(before, after, context(["A killed B"], ["A"]));

    expect(falls.filter((f) => f.killer === "A").length).toBe(1);

    expect(falls.filter((f) => f.killer === null).length).toBe(1);

  });

  test("nothing happening is no falls", () => {

    const players = [mark("A"), mark("B", { side: "def" })];

    expect(fallsBetween(players, players, context())).toEqual([]);

  });

  test("a body that was already dead does not fall twice", () => {

    const before = [mark("B", { side: "def", alive: false })];

    expect(fallsBetween(before, before, context())).toEqual([]);

  });

  test("a fall never carries a position", () => {

    const before = [mark("A", { side: "atk" }), mark("B", { side: "def" })];

    const after = [mark("A", { side: "atk", kills: 1 }), mark("B", { side: "def", alive: false })];

    const fall = fallsBetween(before, after, context(["A killed B"], ["A"]))[0]!;

    expect(Object.keys(fall).sort()).toEqual(["at", "headshot", "killer", "victim", "weapon"]);

  });

  test("marks come off the real players of a real match", () => {

    const marks = marksOf(newMatch().players);

    expect(marks.length).toBe(10);

    expect(marks.every((m) => m.alive && m.kills === 0 && typeof m.name === "string")).toBe(true);

    expect(JSON.stringify(marks)).not.toContain('"x"');

  });

});

describe("the feed as it is shown", () => {

  const fall = (victim: string, at: number) => ({ killer: "A", victim, weapon: null, headshot: false, at });

  test("keeps the last few and drops the stale", () => {

    const feed = [fall("a", 1), fall("b", 2), fall("c", 9), fall("d", 10)];

    expect(trimFeed(feed, 10, 5, 8).map((f) => f.victim)).toEqual(["b", "c", "d"]);

  });

  test("never grows past its slots", () => {

    const feed = [1, 2, 3, 4, 5, 6, 7].map((n) => fall(String(n), 10));

    expect(trimFeed(feed, 10, 5, 8).map((f) => f.victim)).toEqual(["3", "4", "5", "6", "7"]);

  });

});

describe("the feed the arena sends", () => {

  test("bots killing each other reach the snapshot as names, with no positions", async () => {

    const { advance, match, snapshot } = await import("./arena.ts");

    const viewer = match().players[0]!.id;

    let feed: { k: string | null; v: string; w: string | null; h: boolean; t: number }[] = [];

    for (let seconds = 0; seconds < 400 && feed.length === 0; seconds += 10) {

      advance(10);

      feed = JSON.parse(snapshot(viewer)).feed;

    }

    expect(feed.length).toBeGreaterThan(0);

    const names = match().players.map((p) => p.name);

    for (const line of feed) {

      expect(names).toContain(line.v);

      if (line.k !== null) expect(names).toContain(line.k);

      expect(line.t).toBeLessThanOrEqual(8);

      // Names, a gun, an age. Nothing that says where anybody is.

      expect(Object.keys(line).sort()).toEqual(["h", "k", "t", "v", "w"]);

    }

  }, 30000);

});