@spawnite/engine 0.1.0-beta.15

package/readable/rounds/dist/RoundScreen.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from "react";
+/** @category Round */
+export interface RoundScreenProps {
+    /** Replaces "You won" when the round is won.
+     *  @defaultValue `"You won"` */
+    wonTitle?: string;
+    /** Replaces the default line under the won title.
+     *  @defaultValue `"Nice run."` */
+    wonText?: string;
+    /** Replaces "Out of time" when the round is lost.
+     *  @defaultValue `"Out of time"` */
+    lostTitle?: string;
+    /** Replaces the default line under the lost title.
+     *  @defaultValue `"So close."` */
+    lostText?: string;
+    /** What the game calls a level, in the line above the title that names
+     *  the level and the count, such as "Level 2 of 4". A game with no
+     *  levels shows no line.
+     *  @defaultValue `"Level"` */
+    noun?: string;
+    /** More of the game's own under the text, such as the coins banked. */
+    children?: ReactNode;
+    /** The game's own buttons, beside "Play again" below the pane, such as
+     *  one that plays the next level. */
+    actions?: ReactNode;
+    /** Pauses the world while the screen is open. Off, the world steps on
+     *  behind it, so a racer can coast past the line.
+     *  @defaultValue `true` */
+    pause?: boolean;
+}
+/** Opens over the round once it is won or lost: the level in a game with
+ *  levels, a title and text a game can replace, the score where the round
+ *  has a target, and a button under the pane that starts the round again,
+ *  beside any of the game's own. Draws nothing until the round ends. It
+ *  titles every loss "Out of time"; a game that fails a round for another
+ *  reason reads it from `useRound()` and passes its own `lostTitle`.
+ *  @category Round */
+export declare function RoundScreen({ wonTitle, wonText, lostTitle, lostText, noun, children, actions, pause, }: RoundScreenProps): import("react").JSX.Element | null;
+//# sourceMappingURL=RoundScreen.d.ts.map

package/readable/rounds/dist/RoundScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoundScreen.d.ts","sourceRoot":"","sources":["../RoundScreen.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAMvC,sBAAsB;AACtB,MAAM,WAAW,gBAAgB;IAC7B;oCACgC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;sCACkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;wCACoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;sCACkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;kCAG8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB;yCACqC;IACrC,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB;;+BAE2B;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;sBAMsB;AACtB,wBAAgB,WAAW,CAAC,EACxB,QAAQ,EACR,OAAO,EACP,SAAS,EACT,QAAQ,EACR,IAAc,EACd,QAAQ,EACR,OAAO,EACP,KAAY,GACf,EAAE,gBAAgB,sCAiClB"}

package/readable/rounds/dist/RoundScreen.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button, Text } from "@spawnite/ui";
+import { Modal, useLevelPlace } from "@spawnite/engine";
+import { useRound } from "./Round.js";
+import { RoundState } from "./traits.js";
+/** Opens over the round once it is won or lost: the level in a game with
+ *  levels, a title and text a game can replace, the score where the round
+ *  has a target, and a button under the pane that starts the round again,
+ *  beside any of the game's own. Draws nothing until the round ends. It
+ *  titles every loss "Out of time"; a game that fails a round for another
+ *  reason reads it from `useRound()` and passes its own `lostTitle`.
+ *  @category Round */
+export function RoundScreen({ wonTitle, wonText, lostTitle, lostText, noun = "Level", children, actions, pause = true, }) {
+    const { state, score, target, restart } = useRound();
+    const place = useLevelPlace();
+    if (state !== RoundState.Won && state !== RoundState.Lost)
+        return null;
+    const won = state === RoundState.Won;
+    const title = won ? (wonTitle ?? "You won") : (lostTitle ?? "Out of time");
+    const text = won ? (wonText ?? "Nice run.") : (lostText ?? "So close.");
+    return (_jsxs(Modal, { open: true, title: title, overline: place ? `${noun} ${place.number} of ${place.count}` : undefined, pause: pause, actions: _jsxs(_Fragment, { children: [_jsx(Button, { onPress: restart, children: "Play again" }), actions] }), children: [_jsx(Text, { children: text }), target > 0 && (_jsxs(Text, { children: [score, " of ", target] })), children] }));
+}
+//# sourceMappingURL=RoundScreen.js.map

package/readable/rounds/dist/RoundScreen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoundScreen.js","sourceRoot":"","sources":["../RoundScreen.tsx"],"names":[],"mappings":";AAIA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,mBAAgB;AACnC,OAAO,EAAE,UAAU,EAAE,oBAAiB;AAgCtC;;;;;;sBAMsB;AACtB,MAAM,UAAU,WAAW,CAAC,EACxB,QAAQ,EACR,OAAO,EACP,SAAS,EACT,QAAQ,EACR,IAAI,GAAG,OAAO,EACd,QAAQ,EACR,OAAO,EACP,KAAK,GAAG,IAAI,GACG;IACf,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAE,CAAC;IACrD,MAAM,KAAK,GAAG,aAAa,EAAE,CAAC;IAC9B,IAAI,KAAK,KAAK,UAAU,CAAC,GAAG,IAAI,KAAK,KAAK,UAAU,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IAEvE,MAAM,GAAG,GAAG,KAAK,KAAK,UAAU,CAAC,GAAG,CAAC;IACrC,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,aAAa,CAAC,CAAC;IAC3E,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,WAAW,CAAC,CAAC;IAExE,OAAO,CACH,MAAC,KAAK,IACF,IAAI,QACJ,KAAK,EAAE,KAAK,EACZ,QAAQ,EACJ,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,KAAK,CAAC,MAAM,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,EAEnE,KAAK,EAAE,KAAK,EACZ,OAAO,EACH,8BACI,KAAC,MAAM,IAAC,OAAO,EAAE,OAAO,2BAAqB,EAC5C,OAAO,IACT,aAGP,KAAC,IAAI,cAAE,IAAI,GAAQ,EAClB,MAAM,GAAG,CAAC,IAAI,CACX,MAAC,IAAI,eACA,KAAK,UAAM,MAAM,IACf,CACV,EACA,QAAQ,IACL,CACX,CAAC;AACN,CAAC","sourcesContent":["// SPDX-License-Identifier: LicenseRef-Spawnite-1.0\n// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0\n\nimport type { ReactNode } from \"react\";\nimport { Button, Text } from \"@spawnite/ui\";\nimport { Modal, useLevelPlace } from \"@spawnite/engine\";\nimport { useRound } from \"./Round\";\nimport { RoundState } from \"./traits\";\n\n/** @category Round */\nexport interface RoundScreenProps {\n    /** Replaces \"You won\" when the round is won.\n     *  @defaultValue `\"You won\"` */\n    wonTitle?: string;\n    /** Replaces the default line under the won title.\n     *  @defaultValue `\"Nice run.\"` */\n    wonText?: string;\n    /** Replaces \"Out of time\" when the round is lost.\n     *  @defaultValue `\"Out of time\"` */\n    lostTitle?: string;\n    /** Replaces the default line under the lost title.\n     *  @defaultValue `\"So close.\"` */\n    lostText?: string;\n    /** What the game calls a level, in the line above the title that names\n     *  the level and the count, such as \"Level 2 of 4\". A game with no\n     *  levels shows no line.\n     *  @defaultValue `\"Level\"` */\n    noun?: string;\n    /** More of the game's own under the text, such as the coins banked. */\n    children?: ReactNode;\n    /** The game's own buttons, beside \"Play again\" below the pane, such as\n     *  one that plays the next level. */\n    actions?: ReactNode;\n    /** Pauses the world while the screen is open. Off, the world steps on\n     *  behind it, so a racer can coast past the line.\n     *  @defaultValue `true` */\n    pause?: boolean;\n}\n\n/** Opens over the round once it is won or lost: the level in a game with\n *  levels, a title and text a game can replace, the score where the round\n *  has a target, and a button under the pane that starts the round again,\n *  beside any of the game's own. Draws nothing until the round ends. It\n *  titles every loss \"Out of time\"; a game that fails a round for another\n *  reason reads it from `useRound()` and passes its own `lostTitle`.\n *  @category Round */\nexport function RoundScreen({\n    wonTitle,\n    wonText,\n    lostTitle,\n    lostText,\n    noun = \"Level\",\n    children,\n    actions,\n    pause = true,\n}: RoundScreenProps) {\n    const { state, score, target, restart } = useRound();\n    const place = useLevelPlace();\n    if (state !== RoundState.Won && state !== RoundState.Lost) return null;\n\n    const won = state === RoundState.Won;\n    const title = won ? (wonTitle ?? \"You won\") : (lostTitle ?? \"Out of time\");\n    const text = won ? (wonText ?? \"Nice run.\") : (lostText ?? \"So close.\");\n\n    return (\n        <Modal\n            open\n            title={title}\n            overline={\n                place ? `${noun} ${place.number} of ${place.count}` : undefined\n            }\n            pause={pause}\n            actions={\n                <>\n                    <Button onPress={restart}>Play again</Button>\n                    {actions}\n                </>\n            }\n        >\n            <Text>{text}</Text>\n            {target > 0 && (\n                <Text>\n                    {score} of {target}\n                </Text>\n            )}\n            {children}\n        </Modal>\n    );\n}\n"]}

package/readable/rounds/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { rounds } from "./rounds.js";
+export { failRound, finishRound, RoundRefusal, startRound } from "./rules.js";
+export { RoundMachine, RoundState, RoundTrait } from "./traits.js";
+export { Round, type RoundProps, type RoundStatus, useRound } from "./Round.js";
+export { RoundScreen, type RoundScreenProps } from "./RoundScreen.js";
+export { LevelBanner, type LevelBannerProps } from "./LevelBanner.js";
+//# sourceMappingURL=index.d.ts.map

package/readable/rounds/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,oBAAiB;AAClC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,mBAAgB;AAC3E,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,oBAAiB;AAChE,OAAO,EAAE,KAAK,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,QAAQ,EAAE,mBAAgB;AAC7E,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,yBAAsB;AACnE,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,yBAAsB"}

package/readable/rounds/dist/index.js

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: LicenseRef-Spawnite-1.0
+// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0
+//  `@spawnite/engine/rounds`: the round plugin, the round's state and the
+//  calls that end it, and the components that show it.
+export { rounds } from "./rounds.js";
+export { failRound, finishRound, RoundRefusal, startRound } from "./rules.js";
+export { RoundMachine, RoundState, RoundTrait } from "./traits.js";
+export { Round, useRound } from "./Round.js";
+export { RoundScreen } from "./RoundScreen.js";
+export { LevelBanner } from "./LevelBanner.js";
+//# sourceMappingURL=index.js.map

package/readable/rounds/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,oFAAoF;AAEpF,0EAA0E;AAC1E,uDAAuD;AACvD,OAAO,EAAE,MAAM,EAAE,oBAAiB;AAClC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,mBAAgB;AAC3E,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,oBAAiB;AAChE,OAAO,EAAE,KAAK,EAAqC,QAAQ,EAAE,mBAAgB;AAC7E,OAAO,EAAE,WAAW,EAAyB,yBAAsB;AACnE,OAAO,EAAE,WAAW,EAAyB,yBAAsB","sourcesContent":["// SPDX-License-Identifier: LicenseRef-Spawnite-1.0\n// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0\n\n//  `@spawnite/engine/rounds`: the round plugin, the round's state and the\n//  calls that end it, and the components that show it.\nexport { rounds } from \"./rounds\";\nexport { failRound, finishRound, RoundRefusal, startRound } from \"./rules\";\nexport { RoundMachine, RoundState, RoundTrait } from \"./traits\";\nexport { Round, type RoundProps, type RoundStatus, useRound } from \"./Round\";\nexport { RoundScreen, type RoundScreenProps } from \"./RoundScreen\";\nexport { LevelBanner, type LevelBannerProps } from \"./LevelBanner\";\n"]}

package/readable/rounds/dist/rounds.d.ts

@@ -0,0 +1,16 @@
+import { RunContext } from "@spawnite/engine/core";
+/** The round: its score, its clock, and its win or loss. List it in a
+ *  game's plugins beside `machines()`, then mount `<Round>` in a scene to
+ *  time one. Its handles are on the factory: `rounds.systems.advance` for
+ *  a system to run before or after, and `rounds.messages` for what a page
+ *  sends.
+ *  @category Plugins */
+export declare const rounds: import("@spawnite/engine/core").PluginFactory<[options?: unknown], import("@spawnite/engine/core").Plugin<{
+    start: import("@spawnite/engine/core").MessageDeclaration<{
+        readonly automatic: import("@spawnite/engine/core").BooleanMessageField;
+    }>;
+    restart: import("@spawnite/engine/core").MessageDeclaration<{}>;
+}, {
+    readonly advance: import("@spawnite/engine/core").SystemHandle<"rules", false, RunContext.Both>;
+}, Readonly<Record<never, never>>, Readonly<Record<never, never>>, never, Readonly<Record<never, never>>>>;
+//# sourceMappingURL=rounds.d.ts.map

package/readable/rounds/dist/rounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rounds.d.ts","sourceRoot":"","sources":["../rounds.ts"],"names":[],"mappings":"AAIA,OAAO,EAUH,UAAU,EAGb,MAAM,uBAAuB,CAAC;AAW/B;;;;;wBAKwB;AACxB,eAAO,MAAM,MAAM;;;;;;;0GAsClB,CAAC"}

package/readable/rounds/dist/rounds.js

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: LicenseRef-Spawnite-1.0
+// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0
+import { anchorIfPresent, behaviours, definePlugin, definePluginFactory, dumpKey, machines, npcs, readMessages, reloadScene, RunContext, } from "@spawnite/engine/core";
+import { advanceRound, isRoundInState, roundMessages, RoundRefusal, scoreCredits, startRound, } from "./rules.js";
+import { RoundState, RoundTrait } from "./traits.js";
+/** The round: its score, its clock, and its win or loss. List it in a
+ *  game's plugins beside `machines()`, then mount `<Round>` in a scene to
+ *  time one. Its handles are on the factory: `rounds.systems.advance` for
+ *  a system to run before or after, and `rounds.messages` for what a page
+ *  sends.
+ *  @category Plugins */
+export const rounds = /*#__PURE__*/ definePluginFactory(() => definePlugin({
+    name: "rounds",
+    description: "The round: its score, its clock, and its win or loss.",
+    requires: [machines],
+    messages: roundMessages,
+    //  Each round scores what was credited before it spawned toward the
+    //  rounds in play then, so it counts only the coins after it.
+    setup: (world) => world.onAdd(RoundTrait, (round) => scoreCredits(world, round)),
+    systems: {
+        rules: {
+            //  After the pickups and the triggers, so a coin taken or a
+            //  goal reached this step counts toward it; before the
+            //  conversations, so a coin a dialog grants counts on the next
+            //  step; and before the machines, which run the countdown. On
+            //  the room and on each page alike: a page leaves each round
+            //  the room streams to the room, and plays a round of its own.
+            advance: {
+                system: (world, step) => {
+                    if (step.authoritative)
+                        takeRoundRequests(world, step);
+                    advanceRound(world, step);
+                },
+                after: [
+                    anchorIfPresent(behaviours.systems.pickup),
+                    anchorIfPresent(behaviours.systems.trigger),
+                ],
+                before: [
+                    anchorIfPresent(npcs.systems.converse),
+                    machines.systems.advance,
+                ],
+                description: "Takes each page's start and restart of the round, on the room, then scores each round in play and counts its clock down to a win or a loss.",
+                runsOn: RunContext.Both,
+            },
+        },
+    },
+}));
+/** Logs a page's request the room refused, which changes nothing. */
+function logRefusal(world, { message, reason }) {
+    console.warn(`The room refused ${message.name} from ${dumpKey(world, message.entity)}: ${reason}.`);
+}
+/** Answers each start and restart a page in a room sent: a start starts
+ *  the rounds that are ready, and a restart, once a round is won or lost,
+ *  starts the room's scene again, so every page gets the new round. Each
+ *  other is refused with a `RoundRefusal`, logged, and changes nothing,
+ *  but a `<Round>`'s automatic start of a round already counting down or
+ *  in play, which two pages opening the scene at once both send. Only a
+ *  room's world holds a page's messages. */
+function takeRoundRequests(world, step) {
+    for (const message of readMessages(world, rounds.messages.start)) {
+        if (isRoundInState(world, RoundState.Ready))
+            startRound(world);
+        else if (!message.payload.automatic ||
+            (!isRoundInState(world, RoundState.Countdown) &&
+                !isRoundInState(world, RoundState.Playing)))
+            logRefusal(world, { message, reason: RoundRefusal.NotReady });
+    }
+    let restarted = false;
+    for (const message of readMessages(world, rounds.messages.restart)) {
+        //  Two players' Play again in one step start it once.
+        if (restarted)
+            continue;
+        if (!isRoundInState(world, RoundState.Won) &&
+            !isRoundInState(world, RoundState.Lost))
+            logRefusal(world, { message, reason: RoundRefusal.NotEnded });
+        else if (!reloadScene(step))
+            logRefusal(world, { message, reason: RoundRefusal.NoScene });
+        else
+            restarted = true;
+    }
+}
+//# sourceMappingURL=rounds.js.map

package/readable/rounds/dist/rounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rounds.js","sourceRoot":"","sources":["../rounds.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,oFAAoF;AAGpF,OAAO,EACH,eAAe,EACf,UAAU,EACV,YAAY,EACZ,mBAAmB,EACnB,OAAO,EACP,QAAQ,EACR,IAAI,EACJ,YAAY,EACZ,WAAW,EACX,UAAU,GAGb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACH,YAAY,EACZ,cAAc,EACd,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,UAAU,GACb,mBAAgB;AACjB,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,oBAAiB;AAElD;;;;;wBAKwB;AACxB,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAC,mBAAmB,CAAC,GAAG,EAAE,CACzD,YAAY,CAAC;IACT,IAAI,EAAE,QAAQ;IACd,WAAW,EAAE,uDAAuD;IACpE,QAAQ,EAAE,CAAC,QAAQ,CAAC;IACpB,QAAQ,EAAE,aAAa;IACvB,oEAAoE;IACpE,8DAA8D;IAC9D,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACb,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAClE,OAAO,EAAE;QACL,KAAK,EAAE;YACH,4DAA4D;YAC5D,uDAAuD;YACvD,+DAA+D;YAC/D,8DAA8D;YAC9D,6DAA6D;YAC7D,+DAA+D;YAC/D,OAAO,EAAE;gBACL,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;oBACpB,IAAI,IAAI,CAAC,aAAa;wBAAE,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;oBACvD,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;gBAC9B,CAAC;gBACD,KAAK,EAAE;oBACH,eAAe,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC;oBAC1C,eAAe,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC;iBAC9C;gBACD,MAAM,EAAE;oBACJ,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC;oBACtC,QAAQ,CAAC,OAAO,CAAC,OAAO;iBAC3B;gBACD,WAAW,EACP,6IAA6I;gBACjJ,MAAM,EAAE,UAAU,CAAC,IAAI;aAC1B;SACJ;KACJ;CACJ,CAAC,CACL,CAAC;AAOF,qEAAqE;AACrE,SAAS,UAAU,CAAC,KAAY,EAAE,EAAE,OAAO,EAAE,MAAM,EAA0B;IACzE,OAAO,CAAC,IAAI,CACR,oBAAoB,OAAO,CAAC,IAAI,SAAS,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,GAAG,CACxF,CAAC;AACN,CAAC;AAED;;;;;;4CAM4C;AAC5C,SAAS,iBAAiB,CAAC,KAAY,EAAE,IAAuB;IAC5D,KAAK,MAAM,OAAO,IAAI,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/D,IAAI,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC;YAAE,UAAU,CAAC,KAAK,CAAC,CAAC;aAC1D,IACD,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS;YAC1B,CAAC,CAAC,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC;gBACzC,CAAC,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;YAE/C,UAAU,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;IACtE,CAAC;IACD,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,KAAK,MAAM,OAAO,IAAI,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACjE,sDAAsD;QACtD,IAAI,SAAS;YAAE,SAAS;QACxB,IACI,CAAC,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC;YACtC,CAAC,cAAc,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC;YAEvC,UAAU,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC;aAC7D,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACvB,UAAU,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC;;YAC5D,SAAS,GAAG,IAAI,CAAC;IAC1B,CAAC;AACL,CAAC","sourcesContent":["// SPDX-License-Identifier: LicenseRef-Spawnite-1.0\n// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0\n\nimport type { World } from \"koota\";\nimport {\n    anchorIfPresent,\n    behaviours,\n    definePlugin,\n    definePluginFactory,\n    dumpKey,\n    machines,\n    npcs,\n    readMessages,\n    reloadScene,\n    RunContext,\n    type AuthoritativeStep,\n    type DeliveredMessage,\n} from \"@spawnite/engine/core\";\nimport {\n    advanceRound,\n    isRoundInState,\n    roundMessages,\n    RoundRefusal,\n    scoreCredits,\n    startRound,\n} from \"./rules\";\nimport { RoundState, RoundTrait } from \"./traits\";\n\n/** The round: its score, its clock, and its win or loss. List it in a\n *  game's plugins beside `machines()`, then mount `<Round>` in a scene to\n *  time one. Its handles are on the factory: `rounds.systems.advance` for\n *  a system to run before or after, and `rounds.messages` for what a page\n *  sends.\n *  @category Plugins */\nexport const rounds = /*#__PURE__*/ definePluginFactory(() =>\n    definePlugin({\n        name: \"rounds\",\n        description: \"The round: its score, its clock, and its win or loss.\",\n        requires: [machines],\n        messages: roundMessages,\n        //  Each round scores what was credited before it spawned toward the\n        //  rounds in play then, so it counts only the coins after it.\n        setup: (world) =>\n            world.onAdd(RoundTrait, (round) => scoreCredits(world, round)),\n        systems: {\n            rules: {\n                //  After the pickups and the triggers, so a coin taken or a\n                //  goal reached this step counts toward it; before the\n                //  conversations, so a coin a dialog grants counts on the next\n                //  step; and before the machines, which run the countdown. On\n                //  the room and on each page alike: a page leaves each round\n                //  the room streams to the room, and plays a round of its own.\n                advance: {\n                    system: (world, step) => {\n                        if (step.authoritative) takeRoundRequests(world, step);\n                        advanceRound(world, step);\n                    },\n                    after: [\n                        anchorIfPresent(behaviours.systems.pickup),\n                        anchorIfPresent(behaviours.systems.trigger),\n                    ],\n                    before: [\n                        anchorIfPresent(npcs.systems.converse),\n                        machines.systems.advance,\n                    ],\n                    description:\n                        \"Takes each page's start and restart of the round, on the room, then scores each round in play and counts its clock down to a win or a loss.\",\n                    runsOn: RunContext.Both,\n                },\n            },\n        },\n    }),\n);\n\ninterface RoundRefusalLogOptions {\n    message: DeliveredMessage;\n    reason: RoundRefusal;\n}\n\n/** Logs a page's request the room refused, which changes nothing. */\nfunction logRefusal(world: World, { message, reason }: RoundRefusalLogOptions) {\n    console.warn(\n        `The room refused ${message.name} from ${dumpKey(world, message.entity)}: ${reason}.`,\n    );\n}\n\n/** Answers each start and restart a page in a room sent: a start starts\n *  the rounds that are ready, and a restart, once a round is won or lost,\n *  starts the room's scene again, so every page gets the new round. Each\n *  other is refused with a `RoundRefusal`, logged, and changes nothing,\n *  but a `<Round>`'s automatic start of a round already counting down or\n *  in play, which two pages opening the scene at once both send. Only a\n *  room's world holds a page's messages. */\nfunction takeRoundRequests(world: World, step: AuthoritativeStep) {\n    for (const message of readMessages(world, rounds.messages.start)) {\n        if (isRoundInState(world, RoundState.Ready)) startRound(world);\n        else if (\n            !message.payload.automatic ||\n            (!isRoundInState(world, RoundState.Countdown) &&\n                !isRoundInState(world, RoundState.Playing))\n        )\n            logRefusal(world, { message, reason: RoundRefusal.NotReady });\n    }\n    let restarted = false;\n    for (const message of readMessages(world, rounds.messages.restart)) {\n        //  Two players' Play again in one step start it once.\n        if (restarted) continue;\n        if (\n            !isRoundInState(world, RoundState.Won) &&\n            !isRoundInState(world, RoundState.Lost)\n        )\n            logRefusal(world, { message, reason: RoundRefusal.NotEnded });\n        else if (!reloadScene(step))\n            logRefusal(world, { message, reason: RoundRefusal.NoScene });\n        else restarted = true;\n    }\n}\n"]}

package/readable/rounds/dist/rules.d.ts

@@ -0,0 +1,65 @@
+import { type Entity, type World } from "koota";
+import { type UnpredictedStep } from "@spawnite/engine/core";
+import { RoundState } from "./traits.js";
+/** Why the room refused a page's start or restart of its round.
+ *  @category Round */
+export declare enum RoundRefusal {
+    /** A start, where no round on the room is ready. */
+    NotReady = "not-ready",
+    /** A restart, where no round on the room is won or lost. */
+    NotEnded = "not-ended",
+    /** A restart on a room whose scene is a spawn function, as a test's,
+     *  which cannot start again: a scene's file mounts one that can. */
+    NoScene = "no-scene"
+}
+/** The messages `rounds()` declares, reached as `rounds.messages`: a page
+ *  in a room sends `start` from `useRound().start()`, and marked
+ *  `automatic` from its `<Round>` as it opens the scene, and `restart` from
+ *  its `restart()`; the room answers each in the round's step. */
+export declare const roundMessages: {
+    start: import("@spawnite/engine/core").MessageDeclaration<{
+        readonly automatic: import("@spawnite/engine/core").BooleanMessageField;
+    }>;
+    restart: import("@spawnite/engine/core").MessageDeclaration<{}>;
+};
+/** Adds the coins `addCoins` credited since the rounds last scored to the
+ *  score of each round in play, and notes the count: a coin credited
+ *  while a round waits, counts down or has ended scores nothing, a spend
+ *  lowers nothing, and a wallet a save restored adds nothing. The step
+ *  scores before it decides the rounds, each call that starts, wins or
+ *  loses one scores first, and so does each round as it spawns, leaving
+ *  itself out: a coin a game's system credited earlier in the step counts
+ *  toward the round it ends, and never toward one it starts or spawns.
+ *  ponytail: every holder's coins count toward the one round, until a
+ *  room plays a round for each player. A coin a system credits between
+ *  the round's step and the machines', on the step a countdown ends,
+ *  counts toward the round that starts there. */
+export declare function scoreCredits(world: World, spawned?: Entity): void;
+/** Whether a round the world holds is in `state`. */
+export declare function isRoundInState(world: World, state: RoundState): boolean;
+/** Scores each round in play and counts its laps, then its clock: won the
+ *  step its score reaches the target or the last lap is in, which
+ *  finishes the level being played, and lost the step the time runs out.
+ *  The round's machine counts its countdown down and holds a round that
+ *  is ready until `startRound`; one that has ended holds its clock and its
+ *  score.
+ *  A lap line the room streams counts on the room alone. A round the
+ *  room streams is the room's alone too: a page reads it from the stream.
+ *  ponytail: a lap line counts any mover's entry, one player's until a
+ *  room races several. */
+export declare function advanceRound(world: World, step: UnpredictedStep): void;
+/** Starts each round that is ready: its countdown, or play where it has
+ *  none. A sling's release, a starting gate, a Start button.
+ *  @category Round */
+export declare function startRound(world: World): void;
+/** Wins each round in play, as a finish line does, and finishes the level
+ *  being played. It scores first, so a coin a game's system credited
+ *  earlier in the step counts.
+ *  @category Round */
+export declare function finishRound(world: World): void;
+/** Loses each round that has not ended, for `reason`: a crash, a fall, a
+ *  false start. `useRound()` and the game read the reason back. It scores
+ *  first, as `finishRound` does.
+ *  @category Round */
+export declare function failRound(world: World, reason: string): void;
+//# sourceMappingURL=rules.d.ts.map

package/readable/rounds/dist/rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.d.ts","sourceRoot":"","sources":["../rules.ts"],"names":[],"mappings":"AAGA,OAAO,EAAe,KAAK,MAAM,EAAoB,KAAK,KAAK,EAAE,MAAM,OAAO,CAAC;AAC/E,OAAO,EAcH,KAAK,eAAe,EACvB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAEH,UAAU,EAGb,oBAAiB;AAIlB;sBACsB;AACtB,oBAAY,YAAY;IACpB,oDAAoD;IACpD,QAAQ,cAAc;IACtB,4DAA4D;IAC5D,QAAQ,cAAc;IACtB;wEACoE;IACpE,OAAO,aAAa;CACvB;AAED;;;kEAGkE;AAClE,eAAO,MAAM,aAAa;;;;;CAGzB,CAAC;AAOF;;;;;;;;;;;iDAWiD;AACjD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,QAa1D;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,WAQ7D;AAED;;;;;;;;;0BAS0B;AAC1B,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,eAAe,QAiC/D;AAaD;;sBAEsB;AACtB,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,QAItC;AAED;;;sBAGsB;AACtB,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,QAQvC;AAED;;;sBAGsB;AACtB,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,QAKrD"}

package/readable/rounds/dist/rules.js

@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: LicenseRef-Spawnite-1.0
+// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0
+import { createQuery } from "koota";
+import { boolean, defineMessage, findEntity, finishLevel, isRemote, readCreditedCoins, readEach, readEvents, readField, requirePlugin, TrackTriggerTrait, TriggerEnteredEvent, updateEach, } from "@spawnite/engine/core";
+import { RoundMachine, RoundState, RoundTrait, ScoredCoinsTrait, } from "./traits.js";
+/** Why the room refused a page's start or restart of its round.
+ *  @category Round */
+export var RoundRefusal;
+(function (RoundRefusal) {
+    /** A start, where no round on the room is ready. */
+    RoundRefusal["NotReady"] = "not-ready";
+    /** A restart, where no round on the room is won or lost. */
+    RoundRefusal["NotEnded"] = "not-ended";
+    /** A restart on a room whose scene is a spawn function, as a test's,
+     *  which cannot start again: a scene's file mounts one that can. */
+    RoundRefusal["NoScene"] = "no-scene";
+})(RoundRefusal || (RoundRefusal = {}));
+/** The messages `rounds()` declares, reached as `rounds.messages`: a page
+ *  in a room sends `start` from `useRound().start()`, and marked
+ *  `automatic` from its `<Round>` as it opens the scene, and `restart` from
+ *  its `restart()`; the room answers each in the round's step. */
+export const roundMessages = {
+    start: /*#__PURE__*/ defineMessage({ automatic: boolean() }),
+    restart: /*#__PURE__*/ defineMessage({}),
+};
+//  Made once, at module scope, so every step reuses them; the mark lets a
+//  game's bundler drop them where nothing imports the plugin.
+const rounds = /*#__PURE__*/ createQuery(RoundTrait);
+const playing = /*#__PURE__*/ createQuery(RoundTrait, RoundMachine.is.playing);
+/** Adds the coins `addCoins` credited since the rounds last scored to the
+ *  score of each round in play, and notes the count: a coin credited
+ *  while a round waits, counts down or has ended scores nothing, a spend
+ *  lowers nothing, and a wallet a save restored adds nothing. The step
+ *  scores before it decides the rounds, each call that starts, wins or
+ *  loses one scores first, and so does each round as it spawns, leaving
+ *  itself out: a coin a game's system credited earlier in the step counts
+ *  toward the round it ends, and never toward one it starts or spawns.
+ *  ponytail: every holder's coins count toward the one round, until a
+ *  room plays a round for each player. A coin a system credits between
+ *  the round's step and the machines', on the step a countdown ends,
+ *  counts toward the round that starts there. */
+export function scoreCredits(world, spawned) {
+    const credited = readCreditedCoins(world);
+    const scored = world.get(ScoredCoinsTrait)?.total ?? 0;
+    if (credited === scored)
+        return;
+    //  The state rather than the tag, which a plain set of the state moves
+    //  only at the next step.
+    updateEach(world, rounds, ([round], entity) => {
+        if (round.state === RoundState.Playing && entity !== spawned)
+            round.score += credited - scored;
+    });
+    if (world.has(ScoredCoinsTrait))
+        world.set(ScoredCoinsTrait, { total: credited });
+    else
+        world.add(ScoredCoinsTrait({ total: credited }));
+}
+/** Whether a round the world holds is in `state`. */
+export function isRoundInState(world, state) {
+    return (findEntity(world, rounds, (round) => readField(round, RoundTrait, "state") === state) !== undefined);
+}
+/** Scores each round in play and counts its laps, then its clock: won the
+ *  step its score reaches the target or the last lap is in, which
+ *  finishes the level being played, and lost the step the time runs out.
+ *  The round's machine counts its countdown down and holds a round that
+ *  is ready until `startRound`; one that has ended holds its clock and its
+ *  score.
+ *  A lap line the room streams counts on the room alone. A round the
+ *  room streams is the room's alone too: a page reads it from the stream.
+ *  ponytail: a lap line counts any mover's entry, one player's until a
+ *  room races several. */
+export function advanceRound(world, step) {
+    const { deltaSeconds } = step;
+    scoreCredits(world);
+    let laps = 0;
+    for (const { entity } of readEvents(step, TriggerEnteredEvent))
+        if (entity?.get(TrackTriggerTrait)?.lap && !isRemote(entity))
+            laps++;
+    //  A round the room streams is the room's to count and end: a page's
+    //  step would end its copy a step early, before the room's word.
+    updateEach(world, playing, ([round], entity) => {
+        if (isRemote(entity))
+            return;
+        round.lap += laps;
+        if (isWon(round))
+            return;
+        round.elapsed += deltaSeconds;
+    });
+    //  In a second walk: updateEach writes each record back after its
+    //  callback, which would undo a machine's send made inside it.
+    readEach(world, playing, ([round], entity) => {
+        if (isRemote(entity))
+            return;
+        if (isWon(round)) {
+            RoundMachine.send(entity, "WIN");
+            finishPlayedLevel(world, round);
+            return;
+        }
+        //  Within half a step, because summed steps drift below a whole
+        //  second: sixty seconds of them add up to 59.999999999998.
+        if (round.seconds > 0 &&
+            round.elapsed + deltaSeconds / 2 >= round.seconds) {
+            RoundMachine.send(entity, "LOSE");
+            entity.set(RoundTrait, { reason: "time" });
+        }
+    });
+}
+function isWon(round) {
+    return ((round.target > 0 && round.score >= round.target) ||
+        (round.laps > 0 && round.lap >= round.laps));
+}
+function finishPlayedLevel(world, { score, elapsed }) {
+    finishLevel(world, { score, seconds: elapsed });
+}
+/** Starts each round that is ready: its countdown, or play where it has
+ *  none. A sling's release, a starting gate, a Start button.
+ *  @category Round */
+export function startRound(world) {
+    requirePlugin(world, "rounds");
+    scoreCredits(world);
+    for (const round of world.query(rounds))
+        RoundMachine.send(round, "START");
+}
+/** Wins each round in play, as a finish line does, and finishes the level
+ *  being played. It scores first, so a coin a game's system credited
+ *  earlier in the step counts.
+ *  @category Round */
+export function finishRound(world) {
+    requirePlugin(world, "rounds");
+    scoreCredits(world);
+    for (const round of world.query(rounds)) {
+        if (!RoundMachine.send(round, "WIN"))
+            continue;
+        const record = round.get(RoundTrait);
+        if (record)
+            finishPlayedLevel(world, record);
+    }
+}
+/** Loses each round that has not ended, for `reason`: a crash, a fall, a
+ *  false start. `useRound()` and the game read the reason back. It scores
+ *  first, as `finishRound` does.
+ *  @category Round */
+export function failRound(world, reason) {
+    requirePlugin(world, "rounds");
+    scoreCredits(world);
+    for (const round of world.query(rounds))
+        if (RoundMachine.send(round, "LOSE"))
+            round.set(RoundTrait, { reason });
+}
+//# sourceMappingURL=rules.js.map

package/readable/rounds/dist/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../rules.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,oFAAoF;AAEpF,OAAO,EAAE,WAAW,EAA6C,MAAM,OAAO,CAAC;AAC/E,OAAO,EACH,OAAO,EACP,aAAa,EACb,UAAU,EACV,WAAW,EACX,QAAQ,EACR,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,SAAS,EACT,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EACnB,UAAU,GAEb,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACH,YAAY,EACZ,UAAU,EACV,UAAU,EACV,gBAAgB,GACnB,oBAAiB;AAIlB;sBACsB;AACtB,MAAM,CAAN,IAAY,YAQX;AARD,WAAY,YAAY;IACpB,oDAAoD;IACpD,sCAAsB,CAAA;IACtB,4DAA4D;IAC5D,sCAAsB,CAAA;IACtB;wEACoE;IACpE,oCAAoB,CAAA;AACxB,CAAC,EARW,YAAY,KAAZ,YAAY,QAQvB;AAED;;;kEAGkE;AAClE,MAAM,CAAC,MAAM,aAAa,GAAG;IACzB,KAAK,EAAE,aAAa,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC;IAC5D,OAAO,EAAE,aAAa,CAAC,aAAa,CAAC,EAAE,CAAC;CAC3C,CAAC;AAEF,0EAA0E;AAC1E,8DAA8D;AAC9D,MAAM,MAAM,GAAG,aAAa,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;AACrD,MAAM,OAAO,GAAG,aAAa,CAAC,WAAW,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC;AAE/E;;;;;;;;;;;iDAWiD;AACjD,MAAM,UAAU,YAAY,CAAC,KAAY,EAAE,OAAgB;IACvD,MAAM,QAAQ,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC;IACvD,IAAI,QAAQ,KAAK,MAAM;QAAE,OAAO;IAChC,uEAAuE;IACvE,0BAA0B;IAC1B,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE;QAC1C,IAAI,KAAK,CAAC,KAAK,KAAK,UAAU,CAAC,OAAO,IAAI,MAAM,KAAK,OAAO;YACxD,KAAK,CAAC,KAAK,IAAI,QAAQ,GAAG,MAAM,CAAC;IACzC,CAAC,CAAC,CAAC;IACH,IAAI,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC;QAC3B,KAAK,CAAC,GAAG,CAAC,gBAAgB,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;;QAChD,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;AAC1D,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,cAAc,CAAC,KAAY,EAAE,KAAiB;IAC1D,OAAO,CACH,UAAU,CACN,KAAK,EACL,MAAM,EACN,CAAC,KAAK,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,KAAK,KAAK,CAC7D,KAAK,SAAS,CAClB,CAAC;AACN,CAAC;AAED;;;;;;;;;0BAS0B;AAC1B,MAAM,UAAU,YAAY,CAAC,KAAY,EAAE,IAAqB;IAC5D,MAAM,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IAC9B,YAAY,CAAC,KAAK,CAAC,CAAC;IACpB,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,UAAU,CAAC,IAAI,EAAE,mBAAmB,CAAC;QAC1D,IAAI,MAAM,EAAE,GAAG,CAAC,iBAAiB,CAAC,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,IAAI,EAAE,CAAC;IACzE,qEAAqE;IACrE,iEAAiE;IACjE,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE;QAC3C,IAAI,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO;QAC7B,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC;QAClB,IAAI,KAAK,CAAC,KAAK,CAAC;YAAE,OAAO;QACzB,KAAK,CAAC,OAAO,IAAI,YAAY,CAAC;IAClC,CAAC,CAAC,CAAC;IACH,kEAAkE;IAClE,+DAA+D;IAC/D,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE;QACzC,IAAI,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO;QAC7B,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACf,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACjC,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAChC,OAAO;QACX,CAAC;QACD,gEAAgE;QAChE,4DAA4D;QAC5D,IACI,KAAK,CAAC,OAAO,GAAG,CAAC;YACjB,KAAK,CAAC,OAAO,GAAG,YAAY,GAAG,CAAC,IAAI,KAAK,CAAC,OAAO,EACnD,CAAC;YACC,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAClC,MAAM,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/C,CAAC;IACL,CAAC,CAAC,CAAC;AACP,CAAC;AAED,SAAS,KAAK,CAAC,KAA6D;IACxE,OAAO,CACH,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC;QACjD,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,IAAI,KAAK,CAAC,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,CAC9C,CAAC;AACN,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAY,EAAE,EAAE,KAAK,EAAE,OAAO,EAAe;IACpE,WAAW,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;AACpD,CAAC;AAED;;sBAEsB;AACtB,MAAM,UAAU,UAAU,CAAC,KAAY;IACnC,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC/B,YAAY,CAAC,KAAK,CAAC,CAAC;IACpB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;QAAE,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AAC/E,CAAC;AAED;;;sBAGsB;AACtB,MAAM,UAAU,WAAW,CAAC,KAAY;IACpC,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC/B,YAAY,CAAC,KAAK,CAAC,CAAC;IACpB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QACtC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC;YAAE,SAAS;QAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACrC,IAAI,MAAM;YAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;AACL,CAAC;AAED;;;sBAGsB;AACtB,MAAM,UAAU,SAAS,CAAC,KAAY,EAAE,MAAc;IAClD,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC/B,YAAY,CAAC,KAAK,CAAC,CAAC;IACpB,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;QACnC,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;YAAE,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;AAChF,CAAC","sourcesContent":["// SPDX-License-Identifier: LicenseRef-Spawnite-1.0\n// Source available under the Spawnite License 1.0: https://spawnite.com/license/1.0\n\nimport { createQuery, type Entity, type TraitRecord, type World } from \"koota\";\nimport {\n    boolean,\n    defineMessage,\n    findEntity,\n    finishLevel,\n    isRemote,\n    readCreditedCoins,\n    readEach,\n    readEvents,\n    readField,\n    requirePlugin,\n    TrackTriggerTrait,\n    TriggerEnteredEvent,\n    updateEach,\n    type UnpredictedStep,\n} from \"@spawnite/engine/core\";\nimport {\n    RoundMachine,\n    RoundState,\n    RoundTrait,\n    ScoredCoinsTrait,\n} from \"./traits\";\n\ntype RoundRecord = TraitRecord<typeof RoundTrait>;\n\n/** Why the room refused a page's start or restart of its round.\n *  @category Round */\nexport enum RoundRefusal {\n    /** A start, where no round on the room is ready. */\n    NotReady = \"not-ready\",\n    /** A restart, where no round on the room is won or lost. */\n    NotEnded = \"not-ended\",\n    /** A restart on a room whose scene is a spawn function, as a test's,\n     *  which cannot start again: a scene's file mounts one that can. */\n    NoScene = \"no-scene\",\n}\n\n/** The messages `rounds()` declares, reached as `rounds.messages`: a page\n *  in a room sends `start` from `useRound().start()`, and marked\n *  `automatic` from its `<Round>` as it opens the scene, and `restart` from\n *  its `restart()`; the room answers each in the round's step. */\nexport const roundMessages = {\n    start: /*#__PURE__*/ defineMessage({ automatic: boolean() }),\n    restart: /*#__PURE__*/ defineMessage({}),\n};\n\n//  Made once, at module scope, so every step reuses them; the mark lets a\n//  game's bundler drop them where nothing imports the plugin.\nconst rounds = /*#__PURE__*/ createQuery(RoundTrait);\nconst playing = /*#__PURE__*/ createQuery(RoundTrait, RoundMachine.is.playing);\n\n/** Adds the coins `addCoins` credited since the rounds last scored to the\n *  score of each round in play, and notes the count: a coin credited\n *  while a round waits, counts down or has ended scores nothing, a spend\n *  lowers nothing, and a wallet a save restored adds nothing. The step\n *  scores before it decides the rounds, each call that starts, wins or\n *  loses one scores first, and so does each round as it spawns, leaving\n *  itself out: a coin a game's system credited earlier in the step counts\n *  toward the round it ends, and never toward one it starts or spawns.\n *  ponytail: every holder's coins count toward the one round, until a\n *  room plays a round for each player. A coin a system credits between\n *  the round's step and the machines', on the step a countdown ends,\n *  counts toward the round that starts there. */\nexport function scoreCredits(world: World, spawned?: Entity) {\n    const credited = readCreditedCoins(world);\n    const scored = world.get(ScoredCoinsTrait)?.total ?? 0;\n    if (credited === scored) return;\n    //  The state rather than the tag, which a plain set of the state moves\n    //  only at the next step.\n    updateEach(world, rounds, ([round], entity) => {\n        if (round.state === RoundState.Playing && entity !== spawned)\n            round.score += credited - scored;\n    });\n    if (world.has(ScoredCoinsTrait))\n        world.set(ScoredCoinsTrait, { total: credited });\n    else world.add(ScoredCoinsTrait({ total: credited }));\n}\n\n/** Whether a round the world holds is in `state`. */\nexport function isRoundInState(world: World, state: RoundState) {\n    return (\n        findEntity(\n            world,\n            rounds,\n            (round) => readField(round, RoundTrait, \"state\") === state,\n        ) !== undefined\n    );\n}\n\n/** Scores each round in play and counts its laps, then its clock: won the\n *  step its score reaches the target or the last lap is in, which\n *  finishes the level being played, and lost the step the time runs out.\n *  The round's machine counts its countdown down and holds a round that\n *  is ready until `startRound`; one that has ended holds its clock and its\n *  score.\n *  A lap line the room streams counts on the room alone. A round the\n *  room streams is the room's alone too: a page reads it from the stream.\n *  ponytail: a lap line counts any mover's entry, one player's until a\n *  room races several. */\nexport function advanceRound(world: World, step: UnpredictedStep) {\n    const { deltaSeconds } = step;\n    scoreCredits(world);\n    let laps = 0;\n    for (const { entity } of readEvents(step, TriggerEnteredEvent))\n        if (entity?.get(TrackTriggerTrait)?.lap && !isRemote(entity)) laps++;\n    //  A round the room streams is the room's to count and end: a page's\n    //  step would end its copy a step early, before the room's word.\n    updateEach(world, playing, ([round], entity) => {\n        if (isRemote(entity)) return;\n        round.lap += laps;\n        if (isWon(round)) return;\n        round.elapsed += deltaSeconds;\n    });\n    //  In a second walk: updateEach writes each record back after its\n    //  callback, which would undo a machine's send made inside it.\n    readEach(world, playing, ([round], entity) => {\n        if (isRemote(entity)) return;\n        if (isWon(round)) {\n            RoundMachine.send(entity, \"WIN\");\n            finishPlayedLevel(world, round);\n            return;\n        }\n        //  Within half a step, because summed steps drift below a whole\n        //  second: sixty seconds of them add up to 59.999999999998.\n        if (\n            round.seconds > 0 &&\n            round.elapsed + deltaSeconds / 2 >= round.seconds\n        ) {\n            RoundMachine.send(entity, \"LOSE\");\n            entity.set(RoundTrait, { reason: \"time\" });\n        }\n    });\n}\n\nfunction isWon(round: Pick<RoundRecord, \"score\" | \"target\" | \"lap\" | \"laps\">) {\n    return (\n        (round.target > 0 && round.score >= round.target) ||\n        (round.laps > 0 && round.lap >= round.laps)\n    );\n}\n\nfunction finishPlayedLevel(world: World, { score, elapsed }: RoundRecord) {\n    finishLevel(world, { score, seconds: elapsed });\n}\n\n/** Starts each round that is ready: its countdown, or play where it has\n *  none. A sling's release, a starting gate, a Start button.\n *  @category Round */\nexport function startRound(world: World) {\n    requirePlugin(world, \"rounds\");\n    scoreCredits(world);\n    for (const round of world.query(rounds)) RoundMachine.send(round, \"START\");\n}\n\n/** Wins each round in play, as a finish line does, and finishes the level\n *  being played. It scores first, so a coin a game's system credited\n *  earlier in the step counts.\n *  @category Round */\nexport function finishRound(world: World) {\n    requirePlugin(world, \"rounds\");\n    scoreCredits(world);\n    for (const round of world.query(rounds)) {\n        if (!RoundMachine.send(round, \"WIN\")) continue;\n        const record = round.get(RoundTrait);\n        if (record) finishPlayedLevel(world, record);\n    }\n}\n\n/** Loses each round that has not ended, for `reason`: a crash, a fall, a\n *  false start. `useRound()` and the game read the reason back. It scores\n *  first, as `finishRound` does.\n *  @category Round */\nexport function failRound(world: World, reason: string) {\n    requirePlugin(world, \"rounds\");\n    scoreCredits(world);\n    for (const round of world.query(rounds))\n        if (RoundMachine.send(round, \"LOSE\")) round.set(RoundTrait, { reason });\n}\n"]}

package/readable/rounds/dist/traits.d.ts

@@ -0,0 +1,103 @@
+/** Where a round stands: waiting for its start, counting down to it,
+ *  playing, won or lost.
+ *  @category Round */
+export declare enum RoundState {
+    Ready = "ready",
+    Countdown = "countdown",
+    Playing = "playing",
+    Won = "won",
+    Lost = "lost"
+}
+/** A round of play as a machine: playing, then won or lost; spawned in
+ *  `Ready` it waits for `START`, and in `Countdown` it waits out its
+ *  countdown first. The step scores a round in play and sends it `WIN` or
+ *  `LOSE`; its countdown is a wait of `countdown` seconds.
+ *  Its context: won when `score`, the coins `addCoins` credited while it
+ *  played, reaches `target`, or when `lap`, the laps she finished,
+ *  reaches `laps`; lost when `seconds`
+ *  run out first, a zero turning its rule off. `elapsed` is the seconds it
+ *  played, and `reason` why it was lost: `"time"`, or the reason a game
+ *  failed it with. A round spawned bare takes the defaults below, a
+ *  minute and one coin; `<Round>` writes each of its own.
+ *  @category Round */
+export declare const RoundMachine: import("@spawnite/engine/core").Machine<{
+    seconds: number;
+    target: number;
+    laps: number;
+    countdown: number;
+    elapsed: number;
+    score: number;
+    lap: number;
+    reason: string;
+}, "LOSE" | "START" | "WIN", RoundState, import("@spawnite/engine/core").StateTags<{
+    readonly ready: {
+        readonly on: {
+            readonly START: readonly [{
+                readonly target: RoundState.Countdown;
+                readonly guard: ({ context }: import("@spawnite/engine/core").MachineArgs<{
+                    seconds: number;
+                    target: number;
+                    laps: number;
+                    countdown: number;
+                    elapsed: number;
+                    score: number;
+                    lap: number;
+                    reason: string;
+                }>) => boolean;
+            }, {
+                readonly target: RoundState.Playing;
+            }];
+            readonly LOSE: RoundState.Lost;
+        };
+    };
+    readonly countdown: {
+        readonly wait: {
+            readonly seconds: ({ context }: Pick<import("@spawnite/engine/core").MachineArgs<{
+                seconds: number;
+                target: number;
+                laps: number;
+                countdown: number;
+                elapsed: number;
+                score: number;
+                lap: number;
+                reason: string;
+            }>, "context">) => number;
+            readonly then: RoundState.Playing;
+        };
+        readonly on: {
+            readonly LOSE: RoundState.Lost;
+        };
+    };
+    readonly playing: {
+        readonly on: {
+            readonly WIN: RoundState.Won;
+            readonly LOSE: RoundState.Lost;
+        };
+    };
+    readonly won: {};
+    readonly lost: {};
+}>>;
+/** A round of play on an entity of its own, which the Round component
+ *  spawns: the round machine's snapshot.
+ *  @category Round */
+export declare const RoundTrait: import("koota").Trait<{
+    seconds: number;
+    target: number;
+    laps: number;
+    countdown: number;
+    elapsed: number;
+    score: number;
+    lap: number;
+    reason: string;
+    state: RoundState;
+    waited: number;
+    paused: () => Record<string, number>;
+    history: () => import("xstate").PersistedHistoryValue;
+}>;
+/** On the world, the coins `addCoins` had credited when the rounds last
+ *  scored them: each round in play gains the rise from here to
+ *  `readCreditedCoins`. */
+export declare const ScoredCoinsTrait: import("koota").Trait<{
+    total: number;
+}>;
+//# sourceMappingURL=traits.d.ts.map

package/readable/rounds/dist/traits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traits.d.ts","sourceRoot":"","sources":["../traits.ts"],"names":[],"mappings":"AAMA;;sBAEsB;AACtB,oBAAY,UAAU;IAClB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,OAAO,YAAY;IACnB,GAAG,QAAQ;IACX,IAAI,SAAS;CAChB;AAED;;;;;;;;;;;sBAWsB;AACtB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CvB,CAAC;AAEH;;sBAEsB;AACtB,eAAO,MAAM,UAAU;;;;;;;;;;;;;EAAqB,CAAC;AAE7C;;2BAE2B;AAC3B,eAAO,MAAM,gBAAgB;;EAAoC,CAAC"}