@crowdedkingdoms/crowdyjs 18.10.0 → 18.12.0-dev.1

package/dist/kit/modules/racing.js

@@ -0,0 +1,113 @@
+import { HubState } from '../mirror.js';
+/** Races and ball games (the `racing` starter, types `race` and `ball`). */
+export class RacingKit {
+    constructor(runtime, raceType = 'race', ballType = 'ball') {
+        this.runtime = runtime;
+        this.raceType = raceType;
+        this.ballType = ballType;
+        this.races = new Map();
+        this.matches = new Map();
+    }
+    /** The race with key `key`. */
+    race(key) {
+        let r = this.races.get(key);
+        if (!r) {
+            r = new Race(this.runtime, this.raceType, key);
+            this.races.set(key, r);
+        }
+        return r;
+    }
+    /** The ball game with key `key`. */
+    ball(key) {
+        let m = this.matches.get(key);
+        if (!m) {
+            m = new BallMatch(this.runtime, this.ballType, key);
+            this.matches.set(key, m);
+        }
+        return m;
+    }
+}
+/**
+ * One race: a course of gates passed in order, a countdown, laps and splits, places in finishing
+ * order, and a ghost of the winner's run. A client reports where its racer is ({@link pos}, a few
+ * times a second) and the hub times the positions its movement warden kept. `view.onEvent` hears
+ * `go`, `timing` (with its `stage`: `started`, `checkpoint`, `lap`, `finished`), `violation` and
+ * `finished`.
+ */
+export class Race {
+    constructor(runtime, nodeType, key) {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.key = key;
+        this.view = new HubState(runtime, nodeType, key, 'race');
+    }
+    watch() {
+        return this.view.start();
+    }
+    unwatch() {
+        return this.view.stop();
+    }
+    /** @throws {KitError} `started`, `full`. */
+    join() {
+        return this.runtime.call(this.nodeType, this.key, 'join', null, { action: true });
+    }
+    leave() {
+        return this.runtime.call(this.nodeType, this.key, 'leave', null, { action: true });
+    }
+    /** Starts the countdown (the first to join, or a developer). @throws {KitError} `forbidden`, `started`. */
+    start() {
+        return this.runtime.call(this.nodeType, this.key, 'start', null, { action: true });
+    }
+    /** Reports where the racer is; resolves with the position the hub kept. */
+    pos(x, z) {
+        return this.runtime.call(this.nodeType, this.key, 'pos', { x, z });
+    }
+    /** The winner's run, once there is one. */
+    ghost() {
+        return this.runtime.call(this.nodeType, this.key, 'ghost');
+    }
+}
+/**
+ * One ball game: two teams, a ball the hub moves (passes, shots, friction, the side walls),
+ * possession (claim a loose ball near it, or take it from an opponent whose protection is over), a
+ * goal in each end wall. `view.onEvent` hears `claimed`, `passed`, `shot`, `goal`, `violation` and
+ * `finished`.
+ */
+export class BallMatch {
+    constructor(runtime, nodeType, key) {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.key = key;
+        this.view = new HubState(runtime, nodeType, key, 'ball');
+    }
+    watch() {
+        return this.view.start();
+    }
+    unwatch() {
+        return this.view.stop();
+    }
+    /** @throws {KitError} `bad_request` (red or blue), `full`, `started`. */
+    join(team) {
+        return this.runtime.call(this.nodeType, this.key, 'join', { team }, { action: true });
+    }
+    /** @throws {KitError} `forbidden`, `not_ready` (each team needs a player), `started`. */
+    start() {
+        return this.runtime.call(this.nodeType, this.key, 'start', null, { action: true });
+    }
+    /** Reports where the player is; resolves with the position the hub kept. */
+    pos(x, z) {
+        return this.runtime.call(this.nodeType, this.key, 'pos', { x, z });
+    }
+    /** Claims the ball. @throws {KitError} `out_of_reach`, `cooldown` (too soon, or its holder's protection), `conflict` (a teammate has it). */
+    claim() {
+        return this.runtime.call(this.nodeType, this.key, 'claim', null, { action: true });
+    }
+    /** Passes to a teammate. @throws {KitError} `conflict` (not the holder), `bad_request` (not a teammate). */
+    pass(to) {
+        return this.runtime.call(this.nodeType, this.key, 'pass', { to: Number(to) }, { action: true });
+    }
+    /** Shoots toward `(x, z)`. @throws {KitError} `conflict` (not the holder). */
+    shoot(x, z) {
+        return this.runtime.call(this.nodeType, this.key, 'shoot', { x, z }, { action: true });
+    }
+}

package/dist/kit/modules/sessions.d.ts

@@ -0,0 +1,91 @@
+import { HubState } from '../mirror.js';
+import type { KitRuntime } from '../runtime.js';
+export type SessionPhase = 'lobby' | 'playing' | 'finished';
+export interface SessionConfig {
+    min_players: number;
+    max_players: number;
+    turn_ms: number;
+    target_score: number;
+    max_rounds: number;
+    /** A lobby nobody joins closes after this long. */
+    lobby_idle_ms: number;
+}
+export interface SessionMove {
+    player: number;
+    round: number;
+    /** null when the player ran out of time. */
+    points: number | null;
+}
+/** A session as everyone sees it: what `state` answers and the `session` topic carries. */
+export interface SessionState {
+    config: SessionConfig;
+    phase: SessionPhase;
+    /** Only these players may join, when set (a matchmaker's reservation). */
+    reserved: number[];
+    players: number[];
+    ready: number[];
+    connected: number[];
+    host: number | null;
+    turn: number;
+    round: number;
+    /** Scores by player id (the keys are the ids as text). */
+    scores: Record<string, number>;
+    winner: number | null;
+    moves: SessionMove[];
+}
+/** Where the session hubs are: type `session`, one per session key, in the starter pack. */
+export interface SessionsKitOptions {
+    nodeType?: string;
+}
+/** Game sessions (the `session` starter): {@link open} one by its key. */
+export declare class SessionsKit {
+    private readonly runtime;
+    private readonly sessions;
+    private readonly nodeType;
+    constructor(runtime: KitRuntime, options?: SessionsKitOptions);
+    /** The session with key `key` (a matchmaker's `matched.session`, or one a game names). */
+    open(key: string): GameSessionHandle;
+}
+/** Whose turn it is in `state`, while it plays. */
+export declare function sessionTurn(state: SessionState | undefined): number | null;
+/**
+ * One session from lobby to result: join, ready up, the host starts, players act in turn
+ * under a time limit, and the hub keeps the score and names the winner. {@link state} mirrors
+ * the `session` topic; every change is a snapshot on it.
+ */
+export declare class GameSessionHandle {
+    private readonly runtime;
+    readonly nodeType: string;
+    readonly key: string;
+    /** The `session` topic: the whole session. {@link watch} starts it. */
+    readonly state: HubState<SessionState>;
+    constructor(runtime: KitRuntime, nodeType: string, key: string);
+    /** Mirrors the session; resolves with it. */
+    watch(): Promise<SessionState>;
+    unwatch(): Promise<void>;
+    /** Whose turn it is, as the mirror last saw it. */
+    currentTurn(): number | null;
+    /** Whether it is the player's turn, as the mirror last saw it. */
+    isMyTurn(): Promise<boolean>;
+    /** @throws {KitError} `started`, `reserved`, `full`. */
+    join(): Promise<boolean>;
+    leave(): Promise<boolean>;
+    /** @throws {KitError} `not_member` (join the lobby first). */
+    ready(ready?: boolean): Promise<boolean>;
+    /**
+     * Starts the session (the host, once everyone is ready).
+     * @throws {KitError} `forbidden` (not the host), `not_ready`, `too_few_players`, `started`.
+     */
+    startGame(): Promise<boolean>;
+    /**
+     * Plays the player's move (the starter's is `{ points }`, 0 to 3); resolves with whether play
+     * goes on. Sent with an action id: a move resent after a lost reply is played once.
+     * @throws {KitError} `not_your_turn`, `invalid_move` (the game's rule).
+     */
+    act<A extends object = {
+        points: number;
+    }>(action: A): Promise<boolean>;
+    /** Changes the config: the host in the lobby, or a developer. */
+    configure(config: Partial<SessionConfig>): Promise<boolean>;
+}
+//# sourceMappingURL=sessions.d.ts.map

package/dist/kit/modules/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../../src/kit/modules/sessions.ts"],"names":[],"mappings":"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"}

package/dist/kit/modules/sessions.js

@@ -0,0 +1,84 @@
+import { HubState } from '../mirror.js';
+/** Game sessions (the `session` starter): {@link open} one by its key. */
+export class SessionsKit {
+    constructor(runtime, options = {}) {
+        this.runtime = runtime;
+        this.sessions = new Map();
+        this.nodeType = options.nodeType ?? 'session';
+    }
+    /** The session with key `key` (a matchmaker's `matched.session`, or one a game names). */
+    open(key) {
+        let s = this.sessions.get(key);
+        if (!s) {
+            s = new GameSessionHandle(this.runtime, this.nodeType, key);
+            this.sessions.set(key, s);
+        }
+        return s;
+    }
+}
+/** Whose turn it is in `state`, while it plays. */
+export function sessionTurn(state) {
+    if (!state || state.phase !== 'playing')
+        return null;
+    return state.players[state.turn] ?? null;
+}
+/**
+ * One session from lobby to result: join, ready up, the host starts, players act in turn
+ * under a time limit, and the hub keeps the score and names the winner. {@link state} mirrors
+ * the `session` topic; every change is a snapshot on it.
+ */
+export class GameSessionHandle {
+    constructor(runtime, nodeType, key) {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.key = key;
+        this.state = new HubState(runtime, nodeType, key, 'session');
+    }
+    /** Mirrors the session; resolves with it. */
+    watch() {
+        return this.state.start();
+    }
+    unwatch() {
+        return this.state.stop();
+    }
+    /** Whose turn it is, as the mirror last saw it. */
+    currentTurn() {
+        return sessionTurn(this.state.get());
+    }
+    /** Whether it is the player's turn, as the mirror last saw it. */
+    async isMyTurn() {
+        const me = await this.runtime.playerId();
+        const turn = this.currentTurn();
+        return me !== null && turn !== null && String(turn) === me;
+    }
+    /** @throws {KitError} `started`, `reserved`, `full`. */
+    join() {
+        return this.runtime.call(this.nodeType, this.key, 'join', null, { action: true });
+    }
+    leave() {
+        return this.runtime.call(this.nodeType, this.key, 'leave', null, { action: true });
+    }
+    /** @throws {KitError} `not_member` (join the lobby first). */
+    ready(ready = true) {
+        return this.runtime.call(this.nodeType, this.key, 'ready', { ready }, { action: true });
+    }
+    /**
+     * Starts the session (the host, once everyone is ready).
+     * @throws {KitError} `forbidden` (not the host), `not_ready`, `too_few_players`, `started`.
+     */
+    startGame() {
+        return this.runtime.call(this.nodeType, this.key, 'start', null, { action: true });
+    }
+    /**
+     * Plays the player's move (the starter's is `{ points }`, 0 to 3); resolves with whether play
+     * goes on. Sent with an action id: a move resent after a lost reply is played once.
+     * @throws {KitError} `not_your_turn`, `invalid_move` (the game's rule).
+     */
+    act(action) {
+        return this.runtime.call(this.nodeType, this.key, 'act', action, { action: true });
+    }
+    /** Changes the config: the host in the lobby, or a developer. */
+    configure(config) {
+        return this.runtime.call(this.nodeType, this.key, 'configure', config, { action: true });
+    }
+}

package/dist/kit/modules/tables.d.ts

@@ -0,0 +1,76 @@
+import { HubState, PrivateState } from '../mirror.js';
+import type { KitRuntime } from '../runtime.js';
+/** The last thing done at a table. */
+export interface CardPlayed {
+    player: number;
+    card: string | null;
+    /** `play`, `draw` or `pass`. */
+    action: string;
+}
+/** What the `table` topic carries: the public table, never a hand. */
+export interface CardTableView {
+    phase: 'lobby' | 'playing' | 'finished';
+    players: number[];
+    host: number | null;
+    /** Cards in each player's hand, by player id (the keys are the ids as text). */
+    hand_counts: Record<string, number>;
+    top: string | null;
+    /** The suit in play (an eight names one). */
+    suit: string | null;
+    draw_count: number;
+    turn: number | null;
+    turn_ends: number | null;
+    last: CardPlayed | null;
+    winner: number | null;
+    scores: Record<string, number>;
+}
+/** The caller's hand, as `hand` answers it. */
+export interface CardHand {
+    cards: string[];
+    /** The cards the rule lets them play now. */
+    playable: string[];
+    /** Whether they drew this turn (and may pass). */
+    drawn: boolean;
+}
+/** Card tables (the `deck` starter): {@link table} by key. */
+export declare class TablesKit {
+    private readonly runtime;
+    private readonly nodeType;
+    private readonly tables;
+    constructor(runtime: KitRuntime, nodeType?: string);
+    table(key: string): CardTable;
+}
+/**
+ * One table with true hidden information: the deck and every hand live in the hub, and a player
+ * reads only their own hand ({@link hand}, read again whenever the hub's `changed` message names
+ * them). The starter's game is crazy eights.
+ */
+export declare class CardTable {
+    private readonly runtime;
+    readonly nodeType: string;
+    readonly key: string;
+    /** The `table` topic: the public table. */
+    readonly table: HubState<CardTableView>;
+    /** The caller's hand: never on the topic. */
+    readonly hand: PrivateState<CardHand>;
+    constructor(runtime: KitRuntime, nodeType: string, key: string);
+    /** Mirrors the table and the caller's hand. */
+    watch(): Promise<CardTableView>;
+    unwatch(): Promise<void>;
+    /** @throws {KitError} `started`, `full`. */
+    join(): Promise<boolean>;
+    leave(): Promise<boolean>;
+    /** Deals (the host, from two players). @throws {KitError} `forbidden`, `too_few_players`, `started`. */
+    start(): Promise<boolean>;
+    /**
+     * Plays a card from the caller's hand; an eight names `suit` (`S`, `H`, `D` or `C`).
+     * @throws {KitError} `not_your_turn`, `not_found` (not in the hand), `not_playable` (the rule),
+     *   `bad_request` (an eight without a suit).
+     */
+    play(card: string, suit?: string): Promise<boolean>;
+    /** Draws a card (once a turn). @throws {KitError} `not_your_turn`, `conflict`, `empty`. */
+    draw(): Promise<boolean>;
+    /** Passes, after drawing. @throws {KitError} `conflict` (draw first). */
+    pass(): Promise<boolean>;
+}
+//# sourceMappingURL=tables.d.ts.map

package/dist/kit/modules/tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../src/kit/modules/tables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,sCAAsC;AACtC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,sEAAsE;AACtE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACnB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,+CAA+C;AAC/C,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,kDAAkD;IAClD,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,8DAA8D;AAC9D,qBAAa,SAAS;IAIlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;gBAGpC,OAAO,EAAE,UAAU,EACnB,QAAQ,SAAS;IAGpC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;CAQ9B;AAED;;;;GAIG;AACH,qBAAa,SAAS;IAOlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM;IARtB,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IACxC,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;gBAGnB,OAAO,EAAE,UAAU,EAC3B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM;IAYtB,+CAA+C;IACzC,KAAK,IAAI,OAAO,CAAC,aAAa,CAAC;IAK/B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B,4CAA4C;IAC5C,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAIxB,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAIzB,wGAAwG;IACxG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAIzB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKnD,2FAA2F;IAC3F,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAIxB,yEAAyE;IACzE,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;CAGzB"}

package/dist/kit/modules/tables.js

@@ -0,0 +1,73 @@
+import { HubState, PrivateState } from '../mirror.js';
+/** Card tables (the `deck` starter): {@link table} by key. */
+export class TablesKit {
+    constructor(runtime, nodeType = 'deck') {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.tables = new Map();
+    }
+    table(key) {
+        let t = this.tables.get(key);
+        if (!t) {
+            t = new CardTable(this.runtime, this.nodeType, key);
+            this.tables.set(key, t);
+        }
+        return t;
+    }
+}
+/**
+ * One table with true hidden information: the deck and every hand live in the hub, and a player
+ * reads only their own hand ({@link hand}, read again whenever the hub's `changed` message names
+ * them). The starter's game is crazy eights.
+ */
+export class CardTable {
+    constructor(runtime, nodeType, key) {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.key = key;
+        this.table = new HubState(runtime, nodeType, key, 'table');
+        this.hand = new PrivateState(runtime, {
+            nodeType,
+            key,
+            topic: 'table',
+            what: 'hand',
+            read: () => runtime.call(nodeType, key, 'hand'),
+        });
+    }
+    /** Mirrors the table and the caller's hand. */
+    async watch() {
+        const [view] = await Promise.all([this.table.start(), this.hand.start()]);
+        return view;
+    }
+    async unwatch() {
+        await Promise.all([this.table.stop(), this.hand.stop()]);
+    }
+    /** @throws {KitError} `started`, `full`. */
+    join() {
+        return this.runtime.call(this.nodeType, this.key, 'join', null, { action: true });
+    }
+    leave() {
+        return this.runtime.call(this.nodeType, this.key, 'leave', null, { action: true });
+    }
+    /** Deals (the host, from two players). @throws {KitError} `forbidden`, `too_few_players`, `started`. */
+    start() {
+        return this.runtime.call(this.nodeType, this.key, 'start', null, { action: true });
+    }
+    /**
+     * Plays a card from the caller's hand; an eight names `suit` (`S`, `H`, `D` or `C`).
+     * @throws {KitError} `not_your_turn`, `not_found` (not in the hand), `not_playable` (the rule),
+     *   `bad_request` (an eight without a suit).
+     */
+    play(card, suit) {
+        const args = suit === undefined ? { card } : { card, suit };
+        return this.runtime.call(this.nodeType, this.key, 'play', args, { action: true });
+    }
+    /** Draws a card (once a turn). @throws {KitError} `not_your_turn`, `conflict`, `empty`. */
+    draw() {
+        return this.runtime.call(this.nodeType, this.key, 'draw', null, { action: true });
+    }
+    /** Passes, after drawing. @throws {KitError} `conflict` (draw first). */
+    pass() {
+        return this.runtime.call(this.nodeType, this.key, 'pass', null, { action: true });
+    }
+}

package/dist/kit/modules/tactics.d.ts

@@ -0,0 +1,79 @@
+import { HubState } from '../mirror.js';
+import type { KitRuntime } from '../runtime.js';
+export interface TacticsUnitStats {
+    hp: number;
+    attack: number;
+    defense: number;
+    moves: number;
+    range: number;
+}
+export interface TacticsUnit {
+    id: number;
+    team: 'players' | 'enemies';
+    /** The player it belongs to; null for the hub's. */
+    owner: number | null;
+    x: number;
+    z: number;
+    hp: number;
+    stats: TacticsUnitStats;
+    moved: boolean;
+    acted: boolean;
+}
+/** What the `battle` topic carries. */
+export interface TacticsBattleView {
+    phase: 'lobby' | 'players' | 'enemies' | 'won' | 'lost';
+    round: number;
+    width: number;
+    height: number;
+    obstacles: Array<[number, number]>;
+    units: TacticsUnit[];
+    players: number[];
+    host: number | null;
+    /** Players who ended this phase's turn. */
+    ended_turn: number[];
+    /** When the players' phase runs out (Unix ms). */
+    phase_ends: number | null;
+    log: string[];
+}
+/** Grid battles (the `tactics` starter): {@link battle} by key. */
+export declare class TacticsKit {
+    private readonly runtime;
+    private readonly nodeType;
+    private readonly battles;
+    constructor(runtime: KitRuntime, nodeType?: string);
+    battle(key: string): TacticsBattle;
+}
+/**
+ * One battle in turns: each player's unit moves (within its move points, around obstacles and
+ * units) and attacks once a phase; when every player ends their turn, or the phase's time runs
+ * out, the hub's units act. The battle ends when one side has no unit standing.
+ */
+export declare class TacticsBattle {
+    private readonly runtime;
+    readonly nodeType: string;
+    readonly key: string;
+    /** The `battle` topic: the whole battle. */
+    readonly battle: HubState<TacticsBattleView>;
+    constructor(runtime: KitRuntime, nodeType: string, key: string);
+    watch(): Promise<TacticsBattleView>;
+    unwatch(): Promise<void>;
+    /** The player's units, as the mirror last saw them. */
+    myUnits(): Promise<TacticsUnit[]>;
+    /** @throws {KitError} `started`, `full`. */
+    join(): Promise<boolean>;
+    /** @throws {KitError} `forbidden` (the host starts it), `started`. */
+    start(): Promise<boolean>;
+    /**
+     * Moves the player's unit to `(x, z)`.
+     * @throws {KitError} `not_your_turn`, `conflict` (it moved), `out_of_reach`, `not_member`.
+     */
+    move(x: number, z: number): Promise<boolean>;
+    /**
+     * Attacks unit `target` with the player's unit.
+     * @throws {KitError} `not_your_turn`, `conflict` (it attacked), `out_of_reach`, `forbidden` (its own side), `not_found`.
+     */
+    attack(target: number): Promise<boolean>;
+    /** Ends the player's turn this phase. */
+    endTurn(): Promise<boolean>;
+}
+//# sourceMappingURL=tactics.d.ts.map

package/dist/kit/modules/tactics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tactics.d.ts","sourceRoot":"","sources":["../../../src/kit/modules/tactics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IAC5B,oDAAoD;IACpD,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,uCAAuC;AACvC,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;IACxD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnC,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,2CAA2C;IAC3C,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,kDAAkD;IAClD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,GAAG,EAAE,MAAM,EAAE,CAAC;CACf;AAED,mEAAmE;AACnE,qBAAa,UAAU;IAInB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;gBAGzC,OAAO,EAAE,UAAU,EACnB,QAAQ,SAAY;IAGvC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;CAQnC;AAED;;;;GAIG;AACH,qBAAa,aAAa;IAKtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM;IANtB,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAC;gBAG1B,OAAO,EAAE,UAAU,EAC3B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM;IAKtB,KAAK,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAInC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,uDAAuD;IACjD,OAAO,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAKvC,4CAA4C;IAC5C,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC;IAIxB,sEAAsE;IACtE,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAIzB;;;OAGG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI5C;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIxC,yCAAyC;IACzC,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAG5B"}

package/dist/kit/modules/tactics.js

@@ -0,0 +1,67 @@
+import { HubState } from '../mirror.js';
+/** Grid battles (the `tactics` starter): {@link battle} by key. */
+export class TacticsKit {
+    constructor(runtime, nodeType = 'tactics') {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.battles = new Map();
+    }
+    battle(key) {
+        let b = this.battles.get(key);
+        if (!b) {
+            b = new TacticsBattle(this.runtime, this.nodeType, key);
+            this.battles.set(key, b);
+        }
+        return b;
+    }
+}
+/**
+ * One battle in turns: each player's unit moves (within its move points, around obstacles and
+ * units) and attacks once a phase; when every player ends their turn, or the phase's time runs
+ * out, the hub's units act. The battle ends when one side has no unit standing.
+ */
+export class TacticsBattle {
+    constructor(runtime, nodeType, key) {
+        this.runtime = runtime;
+        this.nodeType = nodeType;
+        this.key = key;
+        this.battle = new HubState(runtime, nodeType, key, 'battle');
+    }
+    watch() {
+        return this.battle.start();
+    }
+    unwatch() {
+        return this.battle.stop();
+    }
+    /** The player's units, as the mirror last saw them. */
+    async myUnits() {
+        const me = await this.runtime.playerId();
+        return (this.battle.get()?.units ?? []).filter((u) => me !== null && String(u.owner) === me);
+    }
+    /** @throws {KitError} `started`, `full`. */
+    join() {
+        return this.runtime.call(this.nodeType, this.key, 'join', null, { action: true });
+    }
+    /** @throws {KitError} `forbidden` (the host starts it), `started`. */
+    start() {
+        return this.runtime.call(this.nodeType, this.key, 'start', null, { action: true });
+    }
+    /**
+     * Moves the player's unit to `(x, z)`.
+     * @throws {KitError} `not_your_turn`, `conflict` (it moved), `out_of_reach`, `not_member`.
+     */
+    move(x, z) {
+        return this.runtime.call(this.nodeType, this.key, 'move', { x, z }, { action: true });
+    }
+    /**
+     * Attacks unit `target` with the player's unit.
+     * @throws {KitError} `not_your_turn`, `conflict` (it attacked), `out_of_reach`, `forbidden` (its own side), `not_found`.
+     */
+    attack(target) {
+        return this.runtime.call(this.nodeType, this.key, 'attack', { target }, { action: true });
+    }
+    /** Ends the player's turn this phase. */
+    endTurn() {
+        return this.runtime.call(this.nodeType, this.key, 'end_turn', null, { action: true });
+    }
+}