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

/**

 * Coming into sight and going out of it, as arithmetic. The case that

 * matters is a bot crossing a doorway: it should arrive over a tenth of a

 * second from the side it came from, and leave a mark where it went.

 */

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

import {

  ENTRY,

  FADE,

  forget,

  GHOST,

  ghosts,

  makePresence,

  REACH,

  shown,

  sighted,

  slide,

  SMALL,

  swell,

} from "../static/presence.js";

const body = (over: Record<string, unknown> = {}) => ({

  id: "them",

  x: 400,

  y: 200,

  angle: 0,

  alive: true,

  mate: false,

  agent: "sable",

  ...over,

});

const here = (x: number, y: number) => ({ x, y, angle: 0 });

test("a body just in sight is drawn in over a tenth of a second", () => {

  const p = makePresence();

  sighted(p, [body()], 10);

  expect(shown(p, "them", 10)).toBe(0);

  expect(shown(p, "them", 10 + FADE / 2)).toBeCloseTo(0.5, 5);

  expect(shown(p, "them", 10 + FADE * 1.01)).toBe(1);

  expect(shown(p, "them", 30)).toBe(1);

  // It starts small and reaches its own size, never past it.

  expect(swell(0)).toBe(SMALL);

  expect(swell(1)).toBe(1);

  expect(swell(4)).toBe(1);

});

test("a body already in sight is not faded in again by the next snapshot", () => {

  const p = makePresence();

  sighted(p, [body()], 10);

  sighted(p, [body({ x: 420 })], 10.03);

  sighted(p, [body({ x: 440 })], 10.06);

  expect(shown(p, "them", 10.06)).toBeCloseTo(0.5, 5);

  expect(shown(p, "them", 10.2)).toBe(1);

});

test("somebody nobody has ever seen is solid, not invisible", () => {

  const p = makePresence();

  expect(shown(p, "nobody", 10)).toBe(1);

  expect(slide(p, "nobody", here(1, 2), 10, here(0, 0))).toEqual(here(1, 2));

});

test("a body that steps back into view slides in from the way it came", () => {

  const p = makePresence();

  sighted(p, [body({ x: 400, y: 200 })], 10); // seen at the door

  sighted(p, [], 10.1); // and gone behind the wall

  sighted(p, [body({ x: 500, y: 200 })], 11); // back, further along

  const out = here(0, 0);

  // It begins a stride back down the line it walked, not at its destination.

  const start = slide(p, "them", here(500, 200), 11, out);

  expect(start.x).toBeCloseTo(500 - ENTRY, 5);

  expect(start.y).toBeCloseTo(200, 5);

  // Half way through the fade it is half way in.

  const half = slide(p, "them", here(500, 200), 11 + FADE / 2, out);

  expect(half.x).toBeCloseTo(500 - ENTRY / 2, 5);

  // And once it is in, the drawing is the interpolation's, untouched.

  const done = slide(p, "them", here(500, 200), 11 + FADE * 1.01, out);

  expect(done).toEqual(here(500, 200));

});

test("a body that turns up across the map does not slide across it", () => {

  const p = makePresence();

  sighted(p, [body({ x: 100, y: 100 })], 10);

  sighted(p, [], 10.1);

  sighted(p, [body({ x: 100 + REACH + 10, y: 100 })], 12);

  const out = here(0, 0);

  const at = here(100 + REACH + 10, 100);

  expect(slide(p, "them", at, 12, out)).toEqual(at);

  // It still fades in: an arrival, just not a walk from anywhere.

  expect(shown(p, "them", 12)).toBe(0);

});

test("a body that has not moved since has no direction to come from", () => {

  const p = makePresence();

  sighted(p, [body({ x: 300, y: 300 })], 10);

  sighted(p, [], 10.1);

  sighted(p, [body({ x: 300.5, y: 300 })], 11);

  const at = here(300.5, 300);

  expect(slide(p, "them", at, 11, here(0, 0))).toEqual(at);

});

test("where somebody was last seen is marked, and the mark dims away", () => {

  const p = makePresence();

  sighted(p, [body({ x: 640, y: 480, agent: "veil" })], 10);

  expect(ghosts(p, 10)).toEqual([]);

  sighted(p, [], 10.5);

  const fresh = ghosts(p, 10.5);

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

  expect(fresh[0]).toMatchObject({ id: "them", x: 640, y: 480, agent: "veil", fade: 1 });

  expect(ghosts(p, 10.5 + GHOST / 2)[0]!.fade).toBeCloseTo(0.5, 5);

  expect(ghosts(p, 10.5 + GHOST)).toEqual([]);

  // And it is forgotten, not kept for ever.

  expect(p.last.size).toBe(0);

});

test("a body last seen dead leaves no mark: a corpse is not a question", () => {

  const p = makePresence();

  sighted(p, [body({ alive: false })], 10);

  sighted(p, [], 10.2);

  expect(ghosts(p, 10.2)).toEqual([]);

});

test("coming back into sight takes the mark away at once", () => {

  const p = makePresence();

  sighted(p, [body({ x: 400 })], 10);

  sighted(p, [], 10.2);

  expect(ghosts(p, 10.3).length).toBe(1);

  sighted(p, [body({ x: 430 })], 10.4);

  expect(ghosts(p, 10.4)).toEqual([]);

});

test("a body in sight the whole time is never marked and never re-faded", () => {

  const p = makePresence();

  for (let i = 0; i < 20; i++) sighted(p, [body({ x: 400 + i * 5 })], 10 + i * 0.033);

  expect(ghosts(p, 10.7)).toEqual([]);

  expect(shown(p, "them", 10.7)).toBe(1);

});

test("a new round forgets everybody", () => {

  const p = makePresence();

  sighted(p, [body()], 10);

  sighted(p, [], 10.2);

  forget(p);

  expect(ghosts(p, 10.3)).toEqual([]);

  expect(p.live.size).toBe(0);

  // And the next sighting is a first sighting, with nothing to slide from.

  sighted(p, [body({ x: 900 })], 11);

  expect(shown(p, "them", 11)).toBe(0);

  const at = here(900, 200);

  expect(slide(p, "them", at, 11, here(0, 0))).toEqual(at);

});

test("two bodies are tracked apart", () => {

  const p = makePresence();

  sighted(p, [body({ id: "a" }), body({ id: "b", x: 800 })], 10);

  sighted(p, [body({ id: "a" })], 10.2);

  expect(shown(p, "a", 10.2)).toBe(1);

  const marks = ghosts(p, 10.2);

  expect(marks.map((m) => m.id)).toEqual(["b"]);

});