@johnmorrisdotca/kyogijo-stadiums 0.61.0 → 0.62.0

package/dist/replay.hockey.d.ts

@@ -0,0 +1,143 @@
+import type { DeadTimeRules } from "./replay.deadtime.ts";
+/** Why play stopped, in hockey: each says where it starts again. */
+export type HockeyStop = "goal" | "save" | "frozen" | "icing" | "offside" | "penalty" | "whistle" | "period-start" | "period-end";
+/** The nine face-off spots, feet from centre ice (NHL Rule 1.9): centre, the four in the neutral zone (5 feet outside the blue lines, 44 feet apart) and the four in the end zones (20 feet out from the goal lines, 44 feet apart). */
+export declare const HOCKEY_DOTS: readonly (readonly [number, number])[];
+/** The blue lines are 25 feet either side of centre: past one, play is in an end zone. */
+export declare const HOCKEY_BLUE_LINE = 25;
+/** Is a place one of the nine face-off spots (to a tenth of a foot)? */
+export declare const isHockeyDot: (x: number, y: number) => boolean;
+/** Where play stopped and why, to say where it starts again. */
+export interface HockeyStopAt {
+    reason: HockeyStop | string;
+    /** Where play stopped: the puck's place, or for a save the place the shot came from. Centre ice when not given. */
+    x?: number;
+    y?: number;
+    /** For icing, offside and a penalty: the end the side it was called against defends, as the sign of its goal line's x (-1 for the left end, 1 for the right). */
+    defends?: 1 | -1;
+}
+/**
+ * The face-off spot play starts again at after a stoppage, by NHL rule: centre ice after a goal and at the start of a period; after a save or a frozen puck, the end-zone spot of that end on the side
+ * the puck was (the nearest spot in the zone); after icing and after a penalty, an end-zone spot of the end the offending side defends (Rules 81 and 76); after offside, the
+ * neutral-zone spot just outside the zone the offending side attacks (Rule 83); after any other whistle, the nearest spot in the zone where play stopped (an end-zone spot in an end, a neutral-zone
+ * spot between the blue lines, never centre ice). An end-zone spot's side is the side of the rink the puck was on.
+ * @example
+ * ```ts
+ * import { hockeyFaceoffDot } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyFaceoffDot({ reason: "goal", x: 88, y: 2 }).join(), hockeyFaceoffDot({ reason: "save", x: 60, y: -18 }).join());
+ * console.log(hockeyFaceoffDot({ reason: "icing", x: 80, y: 30, defends: -1 }).join(), hockeyFaceoffDot({ reason: "offside", x: 26, y: 5, defends: -1 }).join());
+ * // 0,0 69,-22
+ * // -69,22 20,22
+ * ```
+ */
+export declare function hockeyFaceoffDot(stop: HockeyStopAt): readonly [number, number];
+/** The places of a face-off's line-up. */
+export type HockeyRole = "C" | "LW" | "RW" | "LD" | "RD" | "G";
+/**
+ * Where a side lines up for a face-off at a spot (NHL Rule 76), as `[x, y]` in feet from centre ice: `attacks` is the end it attacks (1 for the right). The centre stands on the dot a step back on his
+ * own side; the wingers on their own side of the circle's hash marks, outside it; the defence behind them (at the blue line when the spot is in the end the side attacks, in front of its own net when it
+ * is in its own end, a stride back from the wingers at centre and in the neutral zone); the goaltender in the crease. A left winger is on the left of a player facing the end his side attacks.
+ * @example
+ * ```ts
+ * import { hockeyFormation } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const at = hockeyFormation([0, 0], 1);
+ * console.log(at.C.join(), at.LW.join(), at.G.join());
+ * // -2.5,0 -5,17 -85,0
+ * ```
+ */
+export declare function hockeyFormation(dot: readonly [number, number], attacks: 1 | -1): Record<HockeyRole, [number, number]>;
+/** The speeds and seconds of hockey's dead time in a replay, and where each side's bench is. */
+export declare const HOCKEY_DEAD_TIME: {
+    /** The fastest a player glides to his place, feet a second (about 12 miles an hour: a glide, not a sprint). */
+    readonly speed: 18;
+    /** Seconds before the players head for the face-off: a goal is celebrated. */
+    readonly pause: {
+        readonly goal: 2.5;
+        readonly other: 0.6;
+    };
+    /** Seconds the dead puck is seen where it stopped (in the net after a goal), then out of sight until the drop. */
+    readonly shown: {
+        readonly goal: 2.5;
+        readonly other: 1.2;
+    };
+    /** The least time the players take to their places, and the seconds they stand in them before the puck is dropped. */
+    readonly least: 2;
+    readonly hold: 1;
+    /** The line-up before the opening face-off of a period, seconds: the clock reads the period's full time until the drop. */
+    readonly lineUp: 1.5;
+    /** The players' benches' gates, on the side of negative y (the side the benches are on, as the arenas draw them): the home side's nearer the left end, the away side's the right. */
+    readonly bench: Record<"home" | "away", readonly [number, number]>;
+};
+/** Hockey's dead time as `addDeadTime` reads it: the puck is the dead one, and a player going off or coming on goes by his side's bench. */
+export declare const HOCKEY_RULES: DeadTimeRules;
+/**
+ * The stoppage a play of an NHL-style play-by-play is (`typeDescKey` and, for a `stoppage`, `details.reason`): `goal`, `penalty`, the rule set's word for the stoppage's reason, or `undefined` for a
+ * play that does not stop play (a shot, a hit, a delayed penalty, which play goes on through until the side it is against touches the puck).
+ * @example
+ * ```ts
+ * import { hockeyStopOf } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyStopOf("stoppage", "icing"), hockeyStopOf("stoppage", "puck-in-netting"), hockeyStopOf("goal"), hockeyStopOf("delayed-penalty"));
+ * // icing whistle goal undefined
+ * ```
+ */
+export declare function hockeyStopOf(typeDescKey: string, reason?: string): HockeyStop | undefined;
+/** The kinds of penalty, and their minutes on the game clock (NHL Rules 16 to 21: a minor 2, a double minor 4, a major 5, a misconduct 10; a bench minor is a minor served by a player the coach names). */
+export declare const HOCKEY_PENALTY_MINUTES: {
+    readonly minor: 2;
+    readonly "bench-minor": 2;
+    readonly "double-minor": 4;
+    readonly major: 5;
+    readonly misconduct: 10;
+};
+export type HockeyPenaltyKind = keyof typeof HOCKEY_PENALTY_MINUTES;
+/**
+ * The kind of a penalty of an NHL-style play-by-play (`details.typeCode` and `details.duration` of a `penalty`): `MIN` a minor (4 minutes of it a double minor), `BEN` a bench minor, `MAJ` a major,
+ * `MIS` and `GMIS` a misconduct; else by its minutes. `undefined` for a penalty shot or a match penalty, which this rule set does not play.
+ * @example
+ * ```ts
+ * import { hockeyPenaltyKind } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyPenaltyKind("MIN", 2), hockeyPenaltyKind("MIN", 4), hockeyPenaltyKind("BEN", 2), hockeyPenaltyKind("MAJ", 5), hockeyPenaltyKind("MIS", 10), hockeyPenaltyKind("PS", 0));
+ * // minor double-minor bench-minor major misconduct undefined
+ * ```
+ */
+export declare function hockeyPenaltyKind(typeCode?: string, duration?: number): HockeyPenaltyKind | undefined;
+/**
+ * Where a side's penalty box is, the seat its penalized player sits on, in the `nhl-api` frame: across the ice from the players' benches (NHL Rule 1: the two penalty boxes on the side opposite the
+ * benches, one each side of the off-ice officials' box at centre), the home side's on the left, behind the boards. A stand-in for the rink's own figures (the benches and boxes of the rink, KYOGIJO-
+ * STADIUMS-47) until they are in the package: then this reads them, and nothing that calls it changes.
+ */
+export declare function hockeyPenaltyBox(team: "home" | "away"): readonly [number, number];
+/** A call of a penalty, on the game clock: when (seconds of game played since the start), against which side, what kind. */
+export interface HockeyCall {
+    team: "home" | "away";
+    kind: HockeyPenaltyKind;
+    at: number;
+}
+/** When a penalty's time begins and ends on the game clock, and whether its side plays short. */
+export interface HockeyServed {
+    /** When its time begins: the call, or, for a side already two short, when one of those ends (it never plays with fewer than three skaters). */
+    from: number;
+    /** When the player leaves the box: his time ran out, or a power-play goal ended his minor. */
+    to: number;
+    short: boolean;
+    /** Ended by a power-play goal. */
+    byGoal: boolean;
+}
+/**
+ * How a game's penalties are served, by NHL rule, all on the game clock (seconds played since the start): each penalty's player sits from the call; a minor is 2 minutes, a double minor 4, a major 5 and a
+ * misconduct 10; his side plays a skater short (not for a misconduct, served by a substitute, nor for coincidental penalties, called on both sides at once and as many each, which leave the strength
+ * even); a side is never more than two short, so a third penalty's time waits for one of the first two to end; a goal by the side with more skaters ends the scored-on side's minor with the least time
+ * left (a double minor loses the part it is in; a major is served in full). Pure.
+ * @example
+ * ```ts
+ * import { hockeyPenaltyEnds } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const calls = [{ team: "away" as const, kind: "minor" as const, at: 100 }, { team: "home" as const, kind: "major" as const, at: 400 }];
+ * const goals = [{ team: "home" as const, at: 160 }, { team: "away" as const, at: 500 }];
+ * console.log(hockeyPenaltyEnds(calls, goals).map((s) => `${s.from}-${s.to} ${s.short} ${s.byGoal}`).join(", "));
+ * // 100-160 true true, 400-700 true false
+ * ```
+ */
+export declare function hockeyPenaltyEnds(calls: readonly HockeyCall[], goals: readonly {
+    team: "home" | "away";
+    at: number;
+}[]): HockeyServed[];

package/dist/replay.hockey.js

@@ -0,0 +1,276 @@
+/** The nine face-off spots, feet from centre ice (NHL Rule 1.9): centre, the four in the neutral zone (5 feet outside the blue lines, 44 feet apart) and the four in the end zones (20 feet out from the goal lines, 44 feet apart). */
+export const HOCKEY_DOTS = [
+    [0, 0],
+    [20, 22],
+    [20, -22],
+    [-20, 22],
+    [-20, -22],
+    [69, 22],
+    [69, -22],
+    [-69, 22],
+    [-69, -22],
+];
+/** The blue lines are 25 feet either side of centre: past one, play is in an end zone. */
+export const HOCKEY_BLUE_LINE = 25;
+/** Is a place one of the nine face-off spots (to a tenth of a foot)? */
+export const isHockeyDot = (x, y) => HOCKEY_DOTS.some(([dx, dy]) => Math.abs(dx - x) < 0.05 && Math.abs(dy - y) < 0.05);
+const side = (n) => ((n ?? 0) >= 0 ? 1 : -1);
+/**
+ * The face-off spot play starts again at after a stoppage, by NHL rule: centre ice after a goal and at the start of a period; after a save or a frozen puck, the end-zone spot of that end on the side
+ * the puck was (the nearest spot in the zone); after icing and after a penalty, an end-zone spot of the end the offending side defends (Rules 81 and 76); after offside, the
+ * neutral-zone spot just outside the zone the offending side attacks (Rule 83); after any other whistle, the nearest spot in the zone where play stopped (an end-zone spot in an end, a neutral-zone
+ * spot between the blue lines, never centre ice). An end-zone spot's side is the side of the rink the puck was on.
+ * @example
+ * ```ts
+ * import { hockeyFaceoffDot } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyFaceoffDot({ reason: "goal", x: 88, y: 2 }).join(), hockeyFaceoffDot({ reason: "save", x: 60, y: -18 }).join());
+ * console.log(hockeyFaceoffDot({ reason: "icing", x: 80, y: 30, defends: -1 }).join(), hockeyFaceoffDot({ reason: "offside", x: 26, y: 5, defends: -1 }).join());
+ * // 0,0 69,-22
+ * // -69,22 20,22
+ * ```
+ */
+export function hockeyFaceoffDot(stop) {
+    const x = Number.isFinite(stop.x) ? stop.x : 0;
+    const y = Number.isFinite(stop.y) ? stop.y : 0;
+    const across = 22 * side(y);
+    switch (stop.reason) {
+        case "goal":
+        case "period-start":
+        case "period-end":
+            return [0, 0];
+        case "save":
+        case "frozen":
+            return [69 * side(x), across];
+        case "icing":
+        case "penalty":
+            return stop.defends === undefined ? hockeyFaceoffDot({ reason: "whistle", x, y }) : [69 * stop.defends, across];
+        case "offside":
+            return stop.defends === undefined ? hockeyFaceoffDot({ reason: "whistle", x: 20 * side(x), y }) : [-20 * stop.defends, across];
+        default:
+            return Math.abs(x) > HOCKEY_BLUE_LINE ? [69 * side(x), across] : [20 * side(x), across];
+    }
+}
+/**
+ * Where a side lines up for a face-off at a spot (NHL Rule 76), as `[x, y]` in feet from centre ice: `attacks` is the end it attacks (1 for the right). The centre stands on the dot a step back on his
+ * own side; the wingers on their own side of the circle's hash marks, outside it; the defence behind them (at the blue line when the spot is in the end the side attacks, in front of its own net when it
+ * is in its own end, a stride back from the wingers at centre and in the neutral zone); the goaltender in the crease. A left winger is on the left of a player facing the end his side attacks.
+ * @example
+ * ```ts
+ * import { hockeyFormation } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const at = hockeyFormation([0, 0], 1);
+ * console.log(at.C.join(), at.LW.join(), at.G.join());
+ * // -2.5,0 -5,17 -85,0
+ * ```
+ */
+export function hockeyFormation(dot, attacks) {
+    const [dx, dy] = dot;
+    const back = -attacks;
+    const left = attacks;
+    const G = [85 * back, 0];
+    const C = [dx + 2.5 * back, dy];
+    if (Math.abs(dx) < 50) {
+        // Centre ice and the neutral zone: the wingers wide of the circle, the defence a stride back.
+        const LW = [dx + 5 * back, clampY(dy + 17 * left)];
+        const RW = [dx + 5 * back, clampY(dy - 17 * left)];
+        const d = Math.abs(dx) < 1 ? 30 : 22;
+        return { C, LW, RW, LD: [dx + d * back, clampY(dy + 12 * left)], RD: [dx + d * back, clampY(dy - 12 * left)], G };
+    }
+    // An end-zone spot: the wingers on the hash marks either side of the circle, the defence at the points or in front of their own net.
+    const LW = [dx + 3.5 * back, clampY(dy + 17 * left)];
+    const RW = [dx + 3.5 * back, clampY(dy - 17 * left)];
+    const own = Math.sign(dx) === back;
+    if (own) {
+        const toward = -Math.sign(dy) || 1;
+        return { C, LW, RW, LD: [78 * back, clampY(dy * 0.4)], RD: [80 * back, 8 * toward], G };
+    }
+    return { C, LW, RW, LD: [(HOCKEY_BLUE_LINE + 3) * attacks, clampY(18 * left)], RD: [(HOCKEY_BLUE_LINE + 3) * attacks, clampY(-18 * left)], G };
+}
+const clampY = (y) => Math.max(-39, Math.min(39, y));
+/** The speeds and seconds of hockey's dead time in a replay, and where each side's bench is. */
+export const HOCKEY_DEAD_TIME = {
+    /** The fastest a player glides to his place, feet a second (about 12 miles an hour: a glide, not a sprint). */
+    speed: 18,
+    /** Seconds before the players head for the face-off: a goal is celebrated. */
+    pause: { goal: 2.5, other: 0.6 },
+    /** Seconds the dead puck is seen where it stopped (in the net after a goal), then out of sight until the drop. */
+    shown: { goal: 2.5, other: 1.2 },
+    /** The least time the players take to their places, and the seconds they stand in them before the puck is dropped. */
+    least: 2,
+    hold: 1,
+    /** The line-up before the opening face-off of a period, seconds: the clock reads the period's full time until the drop. */
+    lineUp: 1.5,
+    /** The players' benches' gates, on the side of negative y (the side the benches are on, as the arenas draw them): the home side's nearer the left end, the away side's the right. */
+    bench: { home: [-36, -41], away: [36, -41] },
+};
+/** Hockey's dead time as `addDeadTime` reads it: the puck is the dead one, and a player going off or coming on goes by his side's bench. */
+export const HOCKEY_RULES = {
+    speed: HOCKEY_DEAD_TIME.speed,
+    pause: (reason) => (reason === "goal" ? HOCKEY_DEAD_TIME.pause.goal : HOCKEY_DEAD_TIME.pause.other),
+    shown: (reason) => (reason === "goal" ? HOCKEY_DEAD_TIME.shown.goal : HOCKEY_DEAD_TIME.shown.other),
+    least: HOCKEY_DEAD_TIME.least,
+    hold: HOCKEY_DEAD_TIME.hold,
+    bench: (o) => (o.team === "home" || o.team === "away" ? HOCKEY_DEAD_TIME.bench[o.team] : undefined),
+    dead: (o) => o.team === "puck" || o.team === "ball",
+};
+/** The words of the NHL's public play-by-play for why play stopped (`details.reason` of a `stoppage`), as the rule set's. Any other word is a plain whistle. */
+const NHL_REASONS = {
+    "goalie-stopped-after-sog": "save",
+    "puck-frozen": "frozen",
+    icing: "icing",
+    offside: "offside",
+};
+/**
+ * The stoppage a play of an NHL-style play-by-play is (`typeDescKey` and, for a `stoppage`, `details.reason`): `goal`, `penalty`, the rule set's word for the stoppage's reason, or `undefined` for a
+ * play that does not stop play (a shot, a hit, a delayed penalty, which play goes on through until the side it is against touches the puck).
+ * @example
+ * ```ts
+ * import { hockeyStopOf } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyStopOf("stoppage", "icing"), hockeyStopOf("stoppage", "puck-in-netting"), hockeyStopOf("goal"), hockeyStopOf("delayed-penalty"));
+ * // icing whistle goal undefined
+ * ```
+ */
+export function hockeyStopOf(typeDescKey, reason) {
+    if (typeDescKey === "goal")
+        return "goal";
+    if (typeDescKey === "penalty")
+        return "penalty";
+    if (typeDescKey === "period-end")
+        return "period-end";
+    if (typeDescKey !== "stoppage")
+        return undefined;
+    return NHL_REASONS[reason ?? ""] ?? "whistle";
+}
+/** The kinds of penalty, and their minutes on the game clock (NHL Rules 16 to 21: a minor 2, a double minor 4, a major 5, a misconduct 10; a bench minor is a minor served by a player the coach names). */
+export const HOCKEY_PENALTY_MINUTES = { minor: 2, "bench-minor": 2, "double-minor": 4, major: 5, misconduct: 10 };
+/**
+ * The kind of a penalty of an NHL-style play-by-play (`details.typeCode` and `details.duration` of a `penalty`): `MIN` a minor (4 minutes of it a double minor), `BEN` a bench minor, `MAJ` a major,
+ * `MIS` and `GMIS` a misconduct; else by its minutes. `undefined` for a penalty shot or a match penalty, which this rule set does not play.
+ * @example
+ * ```ts
+ * import { hockeyPenaltyKind } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * console.log(hockeyPenaltyKind("MIN", 2), hockeyPenaltyKind("MIN", 4), hockeyPenaltyKind("BEN", 2), hockeyPenaltyKind("MAJ", 5), hockeyPenaltyKind("MIS", 10), hockeyPenaltyKind("PS", 0));
+ * // minor double-minor bench-minor major misconduct undefined
+ * ```
+ */
+export function hockeyPenaltyKind(typeCode, duration) {
+    const code = (typeCode ?? "").toUpperCase();
+    if (code === "MIN")
+        return duration === 4 ? "double-minor" : "minor";
+    if (code === "BEN")
+        return "bench-minor";
+    if (code === "MAJ")
+        return "major";
+    if (code === "MIS" || code === "GMIS")
+        return "misconduct";
+    if (code !== "")
+        return undefined;
+    return duration === 2 ? "minor" : duration === 4 ? "double-minor" : duration === 5 ? "major" : duration === 10 ? "misconduct" : undefined;
+}
+/**
+ * Where a side's penalty box is, the seat its penalized player sits on, in the `nhl-api` frame: across the ice from the players' benches (NHL Rule 1: the two penalty boxes on the side opposite the
+ * benches, one each side of the off-ice officials' box at centre), the home side's on the left, behind the boards. A stand-in for the rink's own figures (the benches and boxes of the rink, KYOGIJO-
+ * STADIUMS-47) until they are in the package: then this reads them, and nothing that calls it changes.
+ */
+export function hockeyPenaltyBox(team) {
+    return team === "home" ? HOCKEY_BOXES.home : HOCKEY_BOXES.away;
+}
+const HOCKEY_BOXES = { home: [-14, 45], away: [14, 45] };
+/**
+ * How a game's penalties are served, by NHL rule, all on the game clock (seconds played since the start): each penalty's player sits from the call; a minor is 2 minutes, a double minor 4, a major 5 and a
+ * misconduct 10; his side plays a skater short (not for a misconduct, served by a substitute, nor for coincidental penalties, called on both sides at once and as many each, which leave the strength
+ * even); a side is never more than two short, so a third penalty's time waits for one of the first two to end; a goal by the side with more skaters ends the scored-on side's minor with the least time
+ * left (a double minor loses the part it is in; a major is served in full). Pure.
+ * @example
+ * ```ts
+ * import { hockeyPenaltyEnds } from "@johnmorrisdotca/kyogijo-stadiums/replay";
+ * const calls = [{ team: "away" as const, kind: "minor" as const, at: 100 }, { team: "home" as const, kind: "major" as const, at: 400 }];
+ * const goals = [{ team: "home" as const, at: 160 }, { team: "away" as const, at: 500 }];
+ * console.log(hockeyPenaltyEnds(calls, goals).map((s) => `${s.from}-${s.to} ${s.short} ${s.byGoal}`).join(", "));
+ * // 100-160 true true, 400-700 true false
+ * ```
+ */
+export function hockeyPenaltyEnds(calls, goals) {
+    const out = calls.map((c) => ({
+        from: c.at,
+        to: c.at + HOCKEY_PENALTY_MINUTES[c.kind] * 60,
+        short: c.kind !== "misconduct",
+        byGoal: false,
+        left: HOCKEY_PENALTY_MINUTES[c.kind] * 60,
+        part: c.kind === "double-minor" ? 2 : 1,
+        kind: c.kind,
+        team: c.team,
+        started: false,
+    }));
+    // Coincidental: at one moment, the same number of penalties that would make each side short are served without making either short.
+    const moments = [...new Set(calls.map((c) => c.at))];
+    for (const at of moments) {
+        const here = out.filter((p) => p.from === at && p.short);
+        const home = here.filter((p) => p.team === "home");
+        const away = here.filter((p) => p.team === "away");
+        const pairs = Math.min(home.length, away.length);
+        for (let i = 0; i < pairs; i += 1)
+            [home[i].short, away[i].short] = [false, false];
+    }
+    // Walk the game clock: calls start their time (or wait while their side is two short), goals end minors, time runs out.
+    const marks = [...new Set([...calls.map((c) => c.at), ...goals.map((g) => g.at)])].sort((a, b) => a - b);
+    const running = (team) => out.filter((p) => p.team === team && p.started && p.short && p.left > 0);
+    let now = Number.NEGATIVE_INFINITY;
+    const advance = (to) => {
+        // Time runs for every started penalty; one that runs out lets a waiting one of its side begin.
+        for (;;) {
+            const live = out.filter((p) => p.started && p.left > 0);
+            const first = live.reduce((best, p) => Math.min(best, now + p.left), Infinity);
+            if (first > to || first === Infinity) {
+                if (Number.isFinite(to))
+                    for (const p of live)
+                        p.left -= to - now;
+                now = to;
+                return;
+            }
+            for (const p of live)
+                p.left -= first - now;
+            now = first;
+            for (const p of live)
+                if (p.left <= 1e-9)
+                    [p.left, p.to] = [0, now];
+            start(now);
+        }
+    };
+    const start = (at) => {
+        for (const p of out) {
+            if (p.started || p.from > at)
+                continue;
+            if (p.short && running(p.team).length >= 2)
+                continue;
+            p.started = true;
+            p.from = Math.max(p.from, at);
+            p.to = p.from + p.left;
+        }
+    };
+    for (const m of marks) {
+        if (now === Number.NEGATIVE_INFINITY)
+            now = m;
+        advance(m);
+        // A goal at the moment of a call ends none of that call's penalties (the call came after it): goals first, then the calls begin.
+        for (const g of goals.filter((one) => one.at === m)) {
+            const other = g.team === "home" ? "away" : "home";
+            const theirs = running(other);
+            if (theirs.length <= running(g.team).length)
+                continue;
+            const minors = theirs.filter((p) => p.kind === "minor" || p.kind === "bench-minor" || p.kind === "double-minor").sort((a, b) => a.left - b.left);
+            const ended = minors[0];
+            if (ended === undefined)
+                continue;
+            if (ended.kind === "double-minor" && ended.left > 120) {
+                ended.left = 120;
+                ended.to = m + 120;
+            }
+            else {
+                [ended.left, ended.to, ended.byGoal] = [0, m, true];
+            }
+        }
+        start(m);
+    }
+    advance(Infinity);
+    return out.map(({ from, to, short, byGoal }) => ({ from, to, short, byGoal }));
+}

package/dist/replay.js

@@ -217,7 +217,7 @@ export function interpolate(timeline, t, options = {}) {
 }
 /**
  * The path each object took over the last `seconds` before `t`, oldest place first and ending at its place at `t`: the frames in between, and the places at the two ends.
- * Only objects that are there at `t` have a trail. `teams` and `ids` choose whose; all by default.
+ * Only objects that are there at `t` have a trail, and it begins after the last frame the object was not in (a dead puck out of sight). `teams` and `ids` choose whose; all by default.
  * @example
  * ```ts
  * import { trails } from "@johnmorrisdotca/kyogijo-stadiums/replay";
@@ -246,7 +246,7 @@ export function trails(timeline, t, seconds, options = {}) {
         const end = positionAt(p, id, now, smooth);
         if (end === undefined)
             continue;
-        const points = [];
+        let points = [];
         const start = positionAt(p, id, from, smooth);
         if (start !== undefined)
             points.push(start);
@@ -254,7 +254,10 @@ export function trails(timeline, t, seconds, options = {}) {
             if (p.times[k] <= from || p.times[k] >= now)
                 continue;
             const o = mapOf(p, k)?.get(id);
-            if (o !== undefined)
+            // Out of sight in a frame (a dead puck between the whistle and the drop): the trail begins again after it, and never joins where it went out to where it came back.
+            if (o === undefined)
+                points = [];
+            else
                 points.push([o.x, o.y]);
         }
         const last = points[points.length - 1];
@@ -343,7 +346,7 @@ export function eventsBetween(timeline, from, to) {
     return prepare(timeline).events.filter((e) => e.t > from && e.t <= to);
 }
 const wordsOf = (language) => KYOGIJO_STRINGS[language === "ja" ? "ja" : "en"].replay;
-const KINDS = ["pass", "shot", "goal", "whistle"];
+const KINDS = ["pass", "shot", "goal", "whistle", "faceoff"];
 const kindWord = (w, kind) => (KINDS.includes(kind) ? w[kind] : kind);
 /**
  * What is said of an event, for a live region and a tooltip: its `label`, else the word for its kind and its team, then the time.
@@ -427,7 +430,8 @@ export function replayGroups(timeline, snap, look = {}, language = "en") {
         const e = a.event;
         const title = describeEvent(e, language, start);
         const team = e.team === "home" || e.team === "away" ? e.team : undefined;
-        if (!isNum(a.x) || !isNum(a.y))
+        // A face-off is the puck on the dot: it is said, and the puck itself marks it.
+        if (!isNum(a.x) || !isNum(a.y) || e.kind === "faceoff")
             continue;
         const ended = isNum(a.x2) && isNum(a.y2) && (a.x2 !== a.x || a.y2 !== a.y);
         if (ended && (e.kind === "pass" || e.kind === "shot" || e.kind === "goal")) {
@@ -483,7 +487,9 @@ export function replayGroups(timeline, snap, look = {}, language = "en") {
         });
     }
     const balls = pick(["ball", "puck"]);
-    if (balls.length > 0) {
+    // The ball's layer is there whenever the timeline tracks a ball or a puck, empty while it is dead and out of sight (between a whistle and the drop), so that it comes back in its own place and
+    // nothing else of the drawing is written again.
+    if (balls.length > 0 || replayCast(timeline).some((o) => o.team === "ball" || o.team === "puck")) {
         out.push({
             id: "replay-ball",
             kind: "points",

package/dist/replay.types.d.ts

@@ -60,6 +60,43 @@ export interface ReplayPeriod {
     /** How long the period is on the game clock, in seconds, when the replay is re-timed (a made-up game played in minutes: 1200 for a hockey period). The board's clock runs through it from start to end. Else the clock runs in the timeline's own seconds. */
     length?: number;
 }
+/**
+ * A stoppage: play is dead from `start` to `end` (the drop of the puck, a throw-in, a snap), in seconds on the timeline's clock. The game clock stands still in it while the replay's own clock (the
+ * slider) moves on: the players skate to their places for the restart, and the ball or the puck is dead.
+ */
+export interface ReplayStoppage {
+    /** When play stopped. */
+    start: number;
+    /** When play starts again: the game clock runs from here. */
+    end: number;
+    /** Why: a word of the sport's rule set (in hockey `goal`, `save`, `frozen`, `icing`, `offside`, `penalty`, `whistle`, `period-start`, `period-end`), or one of your own. */
+    reason?: string;
+    /** Where play starts again (the face-off dot), in the timeline's frame. */
+    x?: number;
+    y?: number;
+    /** The side the stoppage was called against (the side that iced the puck, went offside or took the penalty), when there is one. */
+    team?: "home" | "away";
+}
+/**
+ * A penalty: a player in the penalty box from `start` (the call, a stoppage) to `end` (when he leaves it: his time ran out on the game clock, or a power-play goal ended a minor), in seconds on the
+ * timeline's clock. His side plays a skater short in that time unless `short` is `false` (a misconduct, or coincidental penalties, which leave the strength even).
+ */
+export interface ReplayPenalty {
+    team: "home" | "away";
+    /** The player who serves it: the id of his object, which the frames put in the box. */
+    by?: string;
+    start: number;
+    /** When he leaves the box. Without it, the penalty runs for its `minutes` of game clock from the drop after the call. */
+    end?: number;
+    /** Its length on the game clock: 2 for a minor, 4 for a double minor, 5 for a major, 10 for a misconduct. */
+    minutes: number;
+    /** A word of the sport's rule set (in hockey `minor`, `double-minor`, `major`, `misconduct`, `bench-minor`), or one of your own. */
+    kind?: string;
+    /** Whether his side plays short while he sits: `true` unless said otherwise. */
+    short?: boolean;
+    /** `goal` when a power-play goal ended it before its time was up: until that goal the board counts its minutes down as if it would run them all. */
+    endedBy?: "goal";
+}
 /** Tracking data over time on a surface. Do not change a timeline after it has been used: make a new one. */
 export interface ReplayTimeline {
     /** The positions, from the first moment to the last. */
@@ -83,6 +120,10 @@ export interface ReplayTimeline {
     periods?: readonly ReplayPeriod[];
     /** Whether a scoreboard's game clock counts the time left in the period (`down`, the default: hockey, basketball, football) or the time gone (`up`: soccer). */
     clock?: "down" | "up";
+    /** The stoppages, in order. The game clock stands still in each, from its `start` to its `end`, and the board shows the same time all through it. */
+    stoppages?: readonly ReplayStoppage[];
+    /** The penalties, in order of their calls: who sits in the box, and for how long on the game clock. The board shows each side's strength and the time left of each penalty. */
+    penalties?: readonly ReplayPenalty[];
 }
 /** How a frame is drawn. */
 export interface ReplayLook {

package/dist/strings.core.d.ts

@@ -978,6 +978,7 @@ export interface KyogijoWords {
         shot: string;
         goal: string;
         whistle: string;
+        faceoff: string;
         /** What is said when an event goes by: {what}, {team} and {time}. */
         announce: string;
         announceTeam: string;

package/dist/strings.en.js

@@ -439,7 +439,7 @@ export const WORDS_EN = {
     grid: { title: "A grid of drawings ({n})", drawings: "Drawings ({n}): {list}.", key: "Key: {list}.", cell: "Drawing {n} of {total}", listSep: "; " },
     replay: {
         title: "Replay, {time}", objects: "{n} tracked objects", objectsOne: "{n} tracked object", events: "{n} events", eventsOne: "{n} event", players: "Players", others: "Ball, puck and officials", trail: "Trail of the last {s} seconds", numbers: "Shirt numbers", eventLines: "Passes and shots",
-        home: "home", away: "away", ball: "ball", puck: "puck", official: "official", pass: "Pass", shot: "Shot", goal: "Goal", whistle: "Whistle",
+        home: "home", away: "away", ball: "ball", puck: "puck", official: "official", pass: "Pass", shot: "Shot", goal: "Goal", whistle: "Whistle", faceoff: "Face-off",
         announce: "{what}, {time}", announceTeam: "{what}, {team}, {time}",
         group: "Replay controls", play: "Play", pause: "Pause", back: "Previous frame", forward: "Next frame", stepBack: "Back", stepForward: "Forward", speed: "Speed", loop: "Loop", position: "Position", time: "Time", event: "Event", spokenSeconds: "0:{ss}", spokenMinutes: "{m}:{ss}", spokenHours: "{h}:{mm}:{ss}", positionValue: "{t} of {total}",
         keys: "Replay of the play. Space plays or pauses, the left and right arrow keys step by a frame, Shift with an arrow key moves 5 seconds, and Home and End go to the ends.",

package/dist/strings.ja.js

@@ -464,7 +464,7 @@ export const WORDS_JA = {
     grid: { title: "図のグリッド（{n}枚）", drawings: "図（{n}枚）：{list}。", key: "凡例：{list}。", cell: "{total}枚中{n}枚目の図", listSep: "；" },
     replay: {
         title: "リプレイ（再生時間{time}）", objects: "追跡対象は{n}個", objectsOne: "追跡対象は{n}個", events: "イベント{n}件", eventsOne: "イベント{n}件", players: "選手", others: "ボール・パック・審判", trail: "直近{s}秒の軌跡", numbers: "背番号", eventLines: "パスとシュート",
-        home: "ホーム", away: "アウェイ", ball: "ボール", puck: "パック", official: "審判", pass: "パス", shot: "シュート", goal: "ゴール", whistle: "ホイッスル",
+        home: "ホーム", away: "アウェイ", ball: "ボール", puck: "パック", official: "審判", pass: "パス", shot: "シュート", goal: "ゴール", whistle: "ホイッスル", faceoff: "フェイスオフ",
         announce: "{what}、{time}", announceTeam: "{team}の{what}、{time}",
         group: "リプレイの操作", play: "再生", pause: "一時停止", back: "前のコマ", forward: "次のコマ", stepBack: "前へ", stepForward: "次へ", speed: "再生速度", loop: "繰り返し", position: "再生位置", time: "時間", event: "イベント", spokenSeconds: "{s}秒", spokenMinutes: "{m}分{s}秒", spokenHours: "{h}時間{m}分{s}秒", positionValue: "{total}中{t}",
         keys: "プレーのリプレイです。スペースキーで再生と一時停止、左右の矢印キーで1コマずつ前後に移動、Shiftキーを押しながら矢印キーで5秒ずつ移動、Homeキーで最初、Endキーで最後に移動します。",

package/dist/turn.replay.board.d.ts

@@ -7,7 +7,7 @@ import { type HungBoard } from "./venue.boards.ts";
 export declare const hungBoards: (model: Pick<TurnModel, "uprights">) => HungBoard[];
 /** The planes of a hung scoreboard with the replay's board on it: the same planes (the same ids, in the same places), the faces drawn with the score, the period and the clock. */
 export declare function hungBoardPlanes(hung: HungBoard, state: ReplayBoardState): Plane[];
-/** What is written on a board, as one string: it changes when, and only when, the score, the period or the clock does. */
+/** What is written on a board, as one string: it changes when, and only when, the score, the period, the clock or a penalty's clock does. */
 export declare const boardKey: (state: ReplayBoardState) => string;
 /** The longest the game clock goes without a write while the replay plays, in milliseconds. */
 export declare const CLOCK_EVERY = 1000;

package/dist/turn.replay.board.js

@@ -7,11 +7,20 @@ export const hungBoards = (model) => model.uprights.items.flatMap((item) => (ite
 /** The planes of a hung scoreboard with the replay's board on it: the same planes (the same ids, in the same places), the faces drawn with the score, the period and the clock. */
 export function hungBoardPlanes(hung, state) {
     const clock = safeClock(state.clock);
-    const live = clock === "" ? undefined : { clock, ...(state.period === undefined ? {} : { period: state.period }) };
+    const live = clock === "" ? undefined : { clock, ...(state.period === undefined ? {} : { period: state.period }), ...powerPlay(state) };
     return centreBoard(hung.id, hung.box, hung.lift, { ...hung.look, score: state.score, ...(live === undefined ? {} : { live }) });
 }
-/** What is written on a board, as one string: it changes when, and only when, the score, the period or the clock does. */
-export const boardKey = (state) => `${state.score[0]}-${state.score[1]} ${state.period ?? ""} ${state.clock}`;
+/** A power play on the board: the clocks of each side's penalties that make it play short, and which side has more skaters. Nothing when no side plays short. */
+function powerPlay(state) {
+    const short = (state.penalties ?? []).filter((p) => p.short);
+    if (short.length === 0 || state.strength === undefined)
+        return {};
+    const [home, away] = state.strength;
+    const pp = home > away ? "home" : away > home ? "away" : undefined;
+    return { penalties: { home: short.filter((p) => p.team === "home").map((p) => p.left), away: short.filter((p) => p.team === "away").map((p) => p.left), ...(pp === undefined ? {} : { pp }) } };
+}
+/** What is written on a board, as one string: it changes when, and only when, the score, the period, the clock or a penalty's clock does. */
+export const boardKey = (state) => `${state.score[0]}-${state.score[1]} ${state.period ?? ""} ${state.clock}${state.strength === undefined ? "" : ` ${state.strength.join("-")} ${(state.penalties ?? []).map((p) => `${p.team}${p.left}${p.short ? "" : "x"}`).join(",")}`}`;
 /** The longest the game clock goes without a write while the replay plays, in milliseconds. */
 export const CLOCK_EVERY = 1000;
 const FACE = /-(south|north|east|west)$/;
@@ -29,6 +38,14 @@ export function boardFollower(timeline, now) {
             one.face.dataset.score = `${s.score[0]}-${s.score[1]}`;
             one.face.dataset.period = s.period === undefined ? "" : String(s.period);
             one.face.dataset.clock = s.clock;
+            if (s.strength === undefined) {
+                delete one.face.dataset.strength;
+                delete one.face.dataset.penalties;
+            }
+            else {
+                one.face.dataset.strength = s.strength.join("-");
+                one.face.dataset.penalties = (s.penalties ?? []).map((p) => `${p.team} ${p.left}`).join(", ");
+            }
         }
     };
     return {

package/dist/venue.boards.d.ts

@@ -20,6 +20,12 @@ export interface BoardLive {
     period?: number;
     /** The clock as it is written, `19:20`: digits and one colon. */
     clock: string;
+    /** A power play: each side's penalty clocks (`1:42`, the soonest first, two at most are drawn) in its block of colour, and `PP` in the block of the side with more skaters. */
+    penalties?: {
+        home: string[];
+        away: string[];
+        pp?: "home" | "away";
+    };
 }
 /** The scoreboard hung over a surface, with what it is made from: a replay draws its faces again with the score and the clock of the time it is at. */
 export interface HungBoard {