@moku-labs/game 0.0.2 → 0.0.3

package/dist/{visual-BDUHSRvf.mjs → visual-NPrDkvUk.mjs}

@@ -197,7 +197,7 @@ const Transform = /*#__PURE__*/ component("Transform", transformDefaults);
 const Sprite = /*#__PURE__*/ component("Sprite", spriteDefaults);
 /**
 * A stretchable panel, sized in reference units, with its own alpha and tint. `debug: true` draws
-* the slice outline over it.
+* the slice outline over it. `clip: true` masks the children of the entity to the panel box.
 */
 const NineSlice = /*#__PURE__*/ component("NineSlice", {
 	texture: "",
@@ -205,7 +205,8 @@ const NineSlice = /*#__PURE__*/ component("NineSlice", {
 	height: 0,
 	alpha: 1,
 	tint: 16777215,
-	debug: false
+	debug: false,
+	clip: false
 });
 /**
 * The entity this view moves with. `0` means no parent.
@@ -266,8 +267,9 @@ function componentsFor() {
 }
 /**
 * Words on the screen: a string or a message, the style it is drawn in, and the string `text`
-* resolved out of it. A game writes `content`, `style`, `bind` and `anchor`; `resolved` is
-* engine-owned and `ui` and the tests read it.
+* resolved out of it. A game writes `content`, `style`, `bind`, `anchor` and `alpha`; `resolved`
+* is engine-owned and `ui` and the tests read it. `alpha` (1 by default) fades the whole block and
+* is patched in place, so a tween on it rebuilds nothing.
 */
 const Text = /*#__PURE__*/ component("Text", {
 	content: "",
@@ -277,6 +279,7 @@ const Text = /*#__PURE__*/ component("Text", {
 		x: .5,
 		y: .5
 	},
+	alpha: 1,
 	resolved: ""
 }, { owned: ["resolved"] });
 /**
@@ -289,7 +292,7 @@ const Text = /*#__PURE__*/ component("Text", {
 * ```ts
 * label({ text: "+5", style: "board.float", at: { x: 90, y: 180 } });
 * // [Text({ content: "+5", style: "board.float", bind: undefined,
-* //   anchor: { x: 0.5, y: 0.5 }, resolved: "" }),
+* //   anchor: { x: 0.5, y: 0.5 }, alpha: 1, resolved: "" }),
 * //  Transform({ x: 90, y: 180, rotation: 0, scale: 1 })]
 * ```
 */
@@ -585,10 +588,12 @@ function contentOf(props) {
 * The visual component of an element: a sprite for an image or an icon, the text for a text, the
 * nine-slice of its style (outlined when the style sets `debug`), or a rounded rectangle, a
 * triangle with `shape: "triangle"`, its stroke dashed with `dash`. A clipping element (`scroll`,
-* `overflow: "hidden"`) keeps the rectangle, which carries the clip. A style with a stroke and no fill draws
-* only the stroke, a ring. A container with no fill and no stroke gets an invisible rectangle:
-* the renderer hangs children under the display object of their parent, so every parent needs
-* one.
+* `overflow: "hidden"`) keeps the rectangle, which carries the clip; a text field's rectangle
+* clips too, and a nine-slice field draws its slices and clips to them. A style with a stroke and
+* no fill draws only the stroke, a ring. A container with no fill and no stroke gets a rectangle that draws
+* nothing, no fill and no stroke: the renderer hangs children under the display object of their
+* parent, so every parent needs one. It keeps the alpha of its style, because the alpha of an
+* entity fades its children too.
 *
 * @param element - The element to draw, with its rect known.
 * @returns The component values: one visual.
@@ -628,7 +633,8 @@ function visualOf(element) {
 		height: rect.h,
 		alpha,
 		tint,
-		debug: style.debug ?? false
+		debug: style.debug ?? false,
+		clip: type === "input"
 	})];
 	const filled = style.fill !== void 0 || style.stroke !== void 0;
 	const invisible = isContainer(type) && !filled;
@@ -638,12 +644,12 @@ function visualOf(element) {
 		h: rect.h,
 		fill: style.fill ?? Shape.defaults.fill,
 		fillAlpha: style.fill === void 0 ? 0 : Shape.defaults.fillAlpha,
-		alpha: invisible ? 0 : alpha,
+		alpha,
 		radius: style.radius ?? 0,
 		stroke: style.stroke ?? Shape.defaults.stroke,
-		strokeWidth: style.strokeWidth ?? 0,
+		strokeWidth: invisible ? 0 : style.strokeWidth ?? 0,
 		dash: style.dash ?? 0,
-		clip
+		clip: clip || type === "input"
 	})];
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": false,
@@ -64,13 +64,25 @@
     "test:integration": "vitest run --project integration",
     "test:coverage": "vitest run --project unit --project integration --coverage",
     "build": "tsdown",
+    "fixture:pack": "bun src/assets.ts --root tests/integration/merge-game --keys tests/integration/merge-game/generated/assets.ts --pack tests/integration/merge-game/dist/assets",
+    "fixture:visual": "bun tests/visual/run.ts",
     "validate": "publint && attw --pack . --profile esm-only",
     "release:setup": "moku-release setup",
     "release:doctor": "moku-release doctor",
     "release": "moku-release"
   },
   "peerDependencies": {
-    "pixi.js": "^8.0.0"
+    "pixi.js": "^8.0.0",
+    "playwright-core": ">=1.50.0",
+    "sharp": "^0.34.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright-core": {
+      "optional": true
+    },
+    "sharp": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.3",
@@ -89,7 +101,9 @@
     "jiti": "2.6.1",
     "lefthook": "2.1.1",
     "pixi.js": "8.21.0",
+    "playwright-core": "1.60.0",
     "publint": "0.3.21",
+    "sharp": "0.34.5",
     "tsdown": "0.22.1",
     "typescript": "6.0.3",
     "typescript-eslint": "8.58.0",
@@ -99,6 +113,7 @@
     "@moku-labs/common": "0.3.3",
     "@moku-labs/core": "1.7.0",
     "immer": "11.1.18",
+    "maxrects-packer": "2.7.3",
     "yoga-layout": "3.2.1"
   },
   "publishConfig": {

package/dist/headless-CvamCUcR.mjs

@@ -1,186 +0,0 @@
-import { a as graphHash } from "./registry-DlpRCibU.mjs";
-//#region src/plugins/flow/headless.ts
-const noPayload = null;
-/** Seed of a repro that pins no rng state, the seed `saveOf` writes. */
-const defaultSeed = 1;
-/**
-* Turns whatever `run()` rejected with into an error that can be thrown again.
-*
-* @param value - The rejection value.
-* @returns The value itself when it is an error, a wrapped one otherwise.
-* @example
-* ```ts
-* asError("offline").message; // "[game] The headless run failed.\n  offline."
-* ```
-*/
-function asError(value) {
-	if (value instanceof Error) return value;
-	return /* @__PURE__ */ new Error(`[game] The headless run failed.\n  ${String(value)}.`);
-}
-/**
-* Starts the one loop unless the app's own `onStart` already did, and keeps a fatal error until
-* someone asks for it. `run()` rejects only on a fatal error, and nobody awaits it here.
-*
-* @param app - The started app.
-* @returns The holder of the fatal error.
-*/
-function startLoop(app) {
-	const fatal = { error: void 0 };
-	if (app.flow.state().running) return fatal;
-	app.flow.run().catch((error) => {
-		fatal.error = error;
-	});
-	return fatal;
-}
-/**
-* Waits until the loop rests for the first time, or ends. An empty route walks nowhere: it only
-* waits for the gate the loop opens at the node it enters, so a start that is a chain of transit
-* nodes is played out before anything reads the game.
-*
-* @param app - The started app whose loop is running.
-* @param fatal - Holder of the fatal error of `run()`.
-* @returns Resolves once the loop rests at its first rest node.
-* @throws {Error} When the loop failed fatally instead of reaching a rest node.
-*/
-async function settleAtFirstRest(app, fatal) {
-	await app.flow.walk([]).catch((error) => {
-		throw asError(fatal.error ?? error);
-	});
-	if (fatal.error !== void 0) throw asError(fatal.error);
-}
-/**
-* Starts an app headless: sets flow mode `"fast"`, awaits `app.start()`, starts `flow.run()`
-* unless the app's own `onStart` already did, and waits until the loop rests for the first time.
-* `game.state().path` therefore names the first rest node of the graph as soon as the call
-* resolves. A fatal error of the loop rejects this call, and a later one is re-thrown by `walk`
-* and by `stop`, so a headless test never loses it.
-*
-* @param app - An app that is not started yet.
-* @returns The game: walk it, answer it, read it, stop it.
-* @throws {Error} When the loop failed fatally before it reached its first rest node.
-* @example
-* ```ts
-* // A test starts the merge game without a screen. The call resolves at the first rest node.
-* const game = await createHeadless(app);
-*
-* game.state().path; // "home": the transit node "boot" was played out
-* game.state().mode; // "fast"
-* await game.stop();
-* ```
-*/
-async function createHeadless(app) {
-	app.flow.setMode("fast");
-	await app.start();
-	const fatal = startLoop(app);
-	await settleAtFirstRest(app, fatal);
-	return {
-		walk: async (route) => {
-			const state = await app.flow.walk(route).catch((error) => {
-				throw asError(fatal.error ?? error);
-			});
-			if (fatal.error !== void 0) throw asError(fatal.error);
-			return state;
-		},
-		answer: (answer) => app.flow.gate.answer(answer),
-		state: () => app.flow.state(),
-		history: () => app.flow.history(),
-		stop: async () => {
-			await app.stop();
-			if (fatal.error !== void 0) throw asError(fatal.error);
-		}
-	};
-}
-/**
-* Reads the rest node a repro starts at: its checkpoint, or the start of the main flow.
-*
-* @param app - The started app.
-* @param repro - Starting state, optional checkpoint and the route.
-* @returns The path of the node the repro enters.
-* @throws {Error} When the graph has no main flow to start from.
-*/
-function reproPath(app, repro) {
-	if (repro.checkpoint !== void 0) return repro.checkpoint;
-	const graph = app.flow.describe();
-	const start = graph.flows[graph.main]?.start;
-	if (start === void 0) throw new Error(`[game] runRepro() found no flow "${graph.main}" to start from.\n  Name the checkpoint the repro was taken at.`);
-	return start;
-}
-/**
-* Builds the bookmark a repro is entered with: its state, its checkpoint and the hash of the
-* graph that runs now, so a checkpoint is accepted and any other rest node is checked. The route
-* is not part of it: the caller walks it after the restore.
-*
-* @param app - The started app.
-* @param repro - Starting state, optional checkpoint and the route.
-* @returns The bookmark to restore.
-* @throws {Error} When the repro names no checkpoint and the graph has no main flow.
-* @example
-* ```ts
-* // The game.restore command loads a bug report taken at the "home" checkpoint.
-* const bookmark = reproBookmark(app, { player: { coins: 7 }, checkpoint: "home", route: [] });
-* bookmark.path; // "home"
-* bookmark.rng; // { seed: 1, streams: {} }: the repro pinned no rng
-* await app.flow.restore(bookmark);
-* ```
-*/
-function reproBookmark(app, repro) {
-	return {
-		path: reproPath(app, repro),
-		input: noPayload,
-		player: repro.player,
-		session: repro.session ?? {},
-		rng: repro.rng ?? {
-			seed: defaultSeed,
-			streams: {}
-		},
-		graph: graphHash(app.flow.describe())
-	};
-}
-/**
-* Plays a repro: starts the app headless, restores the bookmark built from its state and
-* checkpoint, then walks its route. The app keeps running, so the caller can read more than the
-* result and stops it itself.
-*
-* @param app - An app that is not started yet.
-* @param repro - Starting state, optional checkpoint and the route.
-* @returns The path the run ended at, and the committed state.
-* @example
-* ```ts
-* // A bug report on the dice game: "reset keeps my coins". Replay it from the "home" checkpoint.
-* const reset = { at: "home", intent: "reset" };
-* const result = await runRepro(app, { player: { coins: 7 }, checkpoint: "home", route: [reset] });
-*
-* result.player; // { coins: 0 }; result.path is ["home"]
-* await app.stop(); // the app keeps running after the run
-* ```
-*/
-async function runRepro(app, repro) {
-	const game = await createHeadless(app);
-	await app.flow.restore(reproBookmark(app, repro));
-	const state = await game.walk(repro.route);
-	const ended = app.flow.bookmark();
-	return {
-		path: state.stack.map((frame) => frame.node),
-		player: ended.player,
-		session: ended.session
-	};
-}
-/**
-* Steps the frame loop by hand: `count` calls of `app.time.step(deltaMs)`. A headless game has no
-* frame source, so this is the only thing that moves the frame phases.
-*
-* @param app - A started app.
-* @param count - Number of frames.
-* @param deltaMs - Milliseconds per frame.
-* @example
-* ```ts
-* // A headless game has no frame source: the test moves the six frame phases by hand.
-* stepFrames(app, 2, 16);
-* app.time.snapshot(); // frame: 2, delta: 16, elapsed: 32
-* ```
-*/
-function stepFrames(app, count, deltaMs) {
-	for (let frame = 0; frame < count; frame += 1) app.time.step(deltaMs);
-}
-//#endregion
-export { stepFrames as i, reproBookmark as n, runRepro as r, createHeadless as t };

package/dist/headless-KaSWcd0s.d.mts

@@ -1,181 +0,0 @@
-import { L as Json, O as Answer, S as RouteStep, Y as RngState, b as JournalEntry, k as Api, t as Api$1, y as FlowState } from "./types-JNc_UQBo.mjs";
-
-//#region src/plugins/flow/headless.d.ts
-/**
- * The part of an app the headless helpers use. Structural on purpose: any app created with the
- * default plugins fits.
- *
- * @example
- * ```ts
- * const app: HeadlessApp = createApp({ pluginConfigs: { flow: { mainFlow } } });
- * ```
- */
-type HeadlessApp = {
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  time: Api;
-  flow: Api$1;
-};
-/**
- * A game played without a screen: answers go through the gate, effects resolve instantly.
- *
- * @example
- * ```ts
- * // A test of the dice game: two rolls, no screen, no waiting.
- * const game = await createHeadless(app);
- * const state = await game.walk([{ at: "home", intent: "roll" }, { at: "home", intent: "roll" }]);
- *
- * state.path; // "home"
- * await game.stop();
- * ```
- */
-type HeadlessGame = {
-  /**
-   * Walks a route through the running loop.
-   *
-   * @param route - The player's answers and substituted sub-flow results, in order.
-   * @returns The state the walk ended in.
-   * @throws {Error} When a step is never reached, or the loop failed fatally.
-   * @example
-   * ```ts
-   * // Open the board and tap the generator twice. Every node's logic runs for real.
-   * const tap = { at: "board/awaitIntent", intent: "tap", payload: { generatorId: "sawmill" } };
-   * const state = await game.walk([{ at: "home", intent: "play" }, tap, tap]);
-   *
-   * state.path; // "board/awaitIntent"
-   * ```
-   */
-  walk(route: readonly RouteStep[]): Promise<FlowState>;
-  /**
-   * Gives one answer to the gate, the way a tap does.
-   *
-   * @param answer - Intent and optional payload.
-   * @returns Whether the gate took it.
-   * @example
-   * ```ts
-   * // One tap without a route. The test then waits for the loop by itself.
-   * game.answer({ intent: "play" }); // true: "home" rests and lists "play"
-   * ```
-   */
-  answer(answer: Answer): boolean;
-  /**
-   * Reads where the graph stands.
-   *
-   * @returns Whether it runs, the path, the stack, what it waits for and the mode.
-   * @example
-   * ```ts
-   * // Right after createHeadless: the graph rests at its first rest node.
-   * game.state().path; // "home"
-   * game.state().pending; // { gate: ["play"] }
-   * ```
-   */
-  state(): FlowState;
-  /**
-   * Reads the edges taken since the last checkpoint.
-   *
-   * @returns A copy of the journal.
-   * @example
-   * ```ts
-   * // After a merge onto an empty cell: the last edge says why the move was refused.
-   * const last = game.history().at(-1);
-   * // last?.path: "board/merge", last?.outcome: "rejected", last?.payload: { reason: "empty" }
-   * ```
-   */
-  history(): readonly JournalEntry[];
-  /**
-   * Stops the app, then re-throws a fatal error of the loop.
-   *
-   * @throws {Error} When the loop failed fatally.
-   * @example
-   * ```ts
-   * // The last line of a headless test. A fatal error of the loop fails the test here.
-   * await game.stop();
-   * ```
-   */
-  stop(): Promise<void>;
-};
-/**
- * A reproducible run: a starting state, an optional checkpoint and the route played from it.
- *
- * @example
- * ```ts
- * const repro: Repro = { player: { coins: 0 }, checkpoint: "home", route: [{ at: "home", intent: "play" }] };
- * ```
- */
-type Repro = {
-  player: Json;
-  session?: Json;
-  rng?: RngState;
-  checkpoint?: string;
-  route: RouteStep[];
-};
-/**
- * What a repro run ends with: the path where the loop rests and the committed state.
- *
- * @example
- * ```ts
- * const result: ReproResult = { path: ["home"], player: { coins: 3 }, session: { visits: 1 } };
- * ```
- */
-type ReproResult = {
-  path: string[];
-  player: Json;
-  session: Json;
-};
-/**
- * Starts an app headless: sets flow mode `"fast"`, awaits `app.start()`, starts `flow.run()`
- * unless the app's own `onStart` already did, and waits until the loop rests for the first time.
- * `game.state().path` therefore names the first rest node of the graph as soon as the call
- * resolves. A fatal error of the loop rejects this call, and a later one is re-thrown by `walk`
- * and by `stop`, so a headless test never loses it.
- *
- * @param app - An app that is not started yet.
- * @returns The game: walk it, answer it, read it, stop it.
- * @throws {Error} When the loop failed fatally before it reached its first rest node.
- * @example
- * ```ts
- * // A test starts the merge game without a screen. The call resolves at the first rest node.
- * const game = await createHeadless(app);
- *
- * game.state().path; // "home": the transit node "boot" was played out
- * game.state().mode; // "fast"
- * await game.stop();
- * ```
- */
-declare function createHeadless(app: HeadlessApp): Promise<HeadlessGame>;
-/**
- * Plays a repro: starts the app headless, restores the bookmark built from its state and
- * checkpoint, then walks its route. The app keeps running, so the caller can read more than the
- * result and stops it itself.
- *
- * @param app - An app that is not started yet.
- * @param repro - Starting state, optional checkpoint and the route.
- * @returns The path the run ended at, and the committed state.
- * @example
- * ```ts
- * // A bug report on the dice game: "reset keeps my coins". Replay it from the "home" checkpoint.
- * const reset = { at: "home", intent: "reset" };
- * const result = await runRepro(app, { player: { coins: 7 }, checkpoint: "home", route: [reset] });
- *
- * result.player; // { coins: 0 }; result.path is ["home"]
- * await app.stop(); // the app keeps running after the run
- * ```
- */
-declare function runRepro(app: HeadlessApp, repro: Repro): Promise<ReproResult>;
-/**
- * Steps the frame loop by hand: `count` calls of `app.time.step(deltaMs)`. A headless game has no
- * frame source, so this is the only thing that moves the frame phases.
- *
- * @param app - A started app.
- * @param count - Number of frames.
- * @param deltaMs - Milliseconds per frame.
- * @example
- * ```ts
- * // A headless game has no frame source: the test moves the six frame phases by hand.
- * stepFrames(app, 2, 16);
- * app.time.snapshot(); // frame: 2, delta: 16, elapsed: 32
- * ```
- */
-declare function stepFrames(app: HeadlessApp, count: number, deltaMs: number): void;
-//#endregion
-export { createHeadless as a, ReproResult as i, HeadlessGame as n, runRepro as o, Repro as r, stepFrames as s, HeadlessApp as t };