@datamoc/mw_games 0.41.0 → 0.43.0

package/dist/two-d/Scene2D.d.ts

@@ -1,5 +1,6 @@
 import { Scene } from '../core/Scene.ts';
 import type { Container2D } from './render/Types2D.ts';
+import type { TransitionOptions } from './render/SceneTransition.ts';
 /**
  * A scene that draws through Pixi: `core.Scene`'s lifecycle plus the container everything
  * this screen shows hangs off.
@@ -13,6 +14,29 @@ import type { Container2D } from './render/Types2D.ts';
 export declare abstract class Scene2D extends Scene {
     /** everything this scene draws hangs off here */
     readonly stage: Container2D;
+    /**
+     * Replaces what this scene shows under a transition: the current picture is photographed, `swap`
+     * changes the content (a new level, decor, layout), and the transition plays over the result.
+     * Without a running `Game` (a test) `swap` just runs.
+     *
+     * @example
+     * ```ts
+     * import { Scene2D } from '@datamoc/mw_games/two-d';
+     * import { tileShrink } from '@datamoc/mw_games/two-d/render';
+     *
+     * class Levels extends Scene2D {
+     * 	override create(): void {}
+     * 	private level = 1;
+     * 	next(): void {
+     * 		this.transitionTo(() => this.load(++this.level), { transition: tileShrink({ columns: 8, rows: 5 }), duration: 0.6 });
+     * 	}
+     * 	private load(level: number): void {
+     * 		console.log('loading level', level);
+     * 	}
+     * }
+     * ```
+     */
+    transitionTo(swap: () => void, options: TransitionOptions): void;
     protected teardown(): void;
 }
 export type Scene2DClass = new () => Scene2D;

package/dist/two-d/Scene2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Scene2D.d.ts","sourceRoot":"","sources":["../../src/two-d/Scene2D.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;GASG;AACH,8BAAsB,OAAQ,SAAQ,KAAK;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAmB;IAE9C,UAAmB,QAAQ,IAAI,IAAI,CAElC;CACD;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,OAAO,CAAC"}
+{"version":3,"file":"Scene2D.d.ts","sourceRoot":"","sources":["../../src/two-d/Scene2D.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAErE;;;;;;;;;GASG;AACH,8BAAsB,OAAQ,SAAQ,KAAK;IAC1C,iDAAiD;IACjD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAmB;IAE9C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,IAAI,EAAE,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAI/D;IAED,UAAmB,QAAQ,IAAI,IAAI,CAElC;CACD;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,OAAO,CAAC"}

package/dist/two-d/Scene2D.js

@@ -1,5 +1,6 @@
 import { Container } from 'pixi.js';
 import { Scene } from '../core/Scene.js';
+import { Game } from './Game.js';
 /**
  * A scene that draws through Pixi: `core.Scene`'s lifecycle plus the container everything
  * this screen shows hangs off.
@@ -16,6 +17,35 @@ export class Scene2D extends Scene {
         /** everything this scene draws hangs off here */
         this.stage = new Container();
     }
+    /**
+     * Replaces what this scene shows under a transition: the current picture is photographed, `swap`
+     * changes the content (a new level, decor, layout), and the transition plays over the result.
+     * Without a running `Game` (a test) `swap` just runs.
+     *
+     * @example
+     * ```ts
+     * import { Scene2D } from '@datamoc/mw_games/two-d';
+     * import { tileShrink } from '@datamoc/mw_games/two-d/render';
+     *
+     * class Levels extends Scene2D {
+     * 	override create(): void {}
+     * 	private level = 1;
+     * 	next(): void {
+     * 		this.transitionTo(() => this.load(++this.level), { transition: tileShrink({ columns: 8, rows: 5 }), duration: 0.6 });
+     * 	}
+     * 	private load(level: number): void {
+     * 		console.log('loading level', level);
+     * 	}
+     * }
+     * ```
+     */
+    transitionTo(swap, options) {
+        const game = Game.active;
+        if (game)
+            game.transition(swap, options);
+        else
+            swap();
+    }
     teardown() {
         this.stage.destroy({ children: true });
     }

package/dist/two-d/Scene2D.js.map

@@ -1 +1 @@
-{"version":3,"file":"Scene2D.js","sourceRoot":"","sources":["../../src/two-d/Scene2D.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC;;;;;;;;;GASG;AACH,MAAM,OAAgB,OAAQ,SAAQ,KAAK;IAA3C;;QACC,iDAAiD;QACxC,UAAK,GAAgB,IAAI,SAAS,EAAE,CAAC;IAK/C,CAAC;IAHmB,QAAQ;QAC1B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;CACD"}
+{"version":3,"file":"Scene2D.js","sourceRoot":"","sources":["../../src/two-d/Scene2D.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAIjC;;;;;;;;;GASG;AACH,MAAM,OAAgB,OAAQ,SAAQ,KAAK;IAA3C;;QACC,iDAAiD;QACxC,UAAK,GAAgB,IAAI,SAAS,EAAE,CAAC;IAiC/C,CAAC;IA/BA;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,YAAY,CAAC,IAAgB,EAAE,OAA0B;QACxD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC;QACzB,IAAI,IAAI;YAAE,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;YACpC,IAAI,EAAE,CAAC;IACb,CAAC;IAEkB,QAAQ;QAC1B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACxC,CAAC;CACD"}

package/dist/two-d/render/SceneTransition.d.ts

@@ -0,0 +1,272 @@
+import { Easing, type Easing as EasingFunction } from '../../core/Tween.ts';
+import type { Container2D, Texture2D } from './Types2D.ts';
+/**
+ * Screen transitions: how one picture hands over to the next. `Game.switchScene(Next, { transition })`
+ * photographs the outgoing scene, starts the new one underneath and animates the photograph away
+ * (`tileShrink`, `slide`, `dissolve`, `shrink`) or grows the new scene over it (`pop`, `grow`, `iris`).
+ * `Scene2D.transitionTo(swap, options)` does the same for a scene that replaces its own content.
+ *
+ * Each transition is a small factory: `start(context)` builds what it needs from the outgoing
+ * `snapshot` and the `incoming` container and returns a runtime whose `update(progress)` is called
+ * with eased progress from 0 to 1. The geometry (`tileDelays`, `tileProgress`, `popScale`) is plain
+ * functions, so a transition's timing is testable without drawing it.
+ */
+/** what a transition is given to work with */
+export interface TransitionContext {
+    /** the size of the screen in logical pixels */
+    width: number;
+    height: number;
+    /** a picture of the outgoing scene, or null when there was none to photograph */
+    snapshot: Texture2D | null;
+    /** the new scene, in a container the transition may move, scale, fade or mask */
+    incoming: Container2D;
+    /** drawn beneath `incoming`: the old picture, for a transition that grows the new scene over it */
+    under: Container2D;
+    /** drawn over `incoming`: the old picture, for a transition that takes it away */
+    over: Container2D;
+}
+export interface TransitionRuntime {
+    /** @param progress eased, 0 at the start and 1 at the end */
+    update(progress: number): void;
+    /** removes whatever the transition added, leaving `incoming` as it found it */
+    destroy(): void;
+}
+export interface SceneTransition {
+    readonly name: string;
+    start(context: TransitionContext): TransitionRuntime;
+}
+/** how a transition is run; `transition` is the only required part */
+export interface TransitionOptions {
+    transition: SceneTransition;
+    /** seconds, counted in real time; 0.5 when omitted. Reduced motion skips the transition entirely */
+    duration?: number;
+    /** a name from `Easing` or a function of progress; `easeInOutQuad` when omitted */
+    easing?: keyof typeof Easing | EasingFunction;
+    /** hold the scene still while the transition plays; false when omitted */
+    pause?: boolean;
+    /** runs once, the frame the transition ends */
+    onDone?: () => void;
+}
+/** where a transition starts from or aims at, in screen pixels; the screen's centre when omitted */
+export interface TransitionPoint {
+    x: number;
+    y: number;
+}
+export type TileOrder = 'diagonal' | 'random' | 'spiral' | 'rows';
+/**
+ * When each tile of a `columns` by `rows` grid starts, from 0 (first) to 1 (last), in row-major order.
+ * `diagonal` sweeps from the top left, `spiral` from the outside in, `rows` top to bottom, and
+ * `random` is a fixed shuffle for a given `seed`.
+ *
+ * @example
+ * ```ts
+ * import { tileDelays } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(tileDelays(3, 2, 'diagonal')); // [0, 1/3, 2/3, 1/3, 2/3, 1]
+ * ```
+ */
+export declare function tileDelays(columns: number, rows: number, order?: TileOrder, seed?: number): number[];
+/**
+ * One tile's progress when the whole transition is at `progress`: tiles start spread across the first
+ * `stagger` of the time, according to their `delay` from `tileDelays`, and each then takes the rest
+ * of it, so the last tile finishes exactly as the transition does.
+ *
+ * @example
+ * ```ts
+ * import { tileProgress } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(tileProgress(0, 0.5, 0.5)); // 1: the first tile is already done
+ * console.log(tileProgress(1, 0.5, 0.5)); // 0: the last one has not started
+ * ```
+ */
+export declare function tileProgress(delay: number, progress: number, stagger: number): number;
+/**
+ * The scale of something that pops in: 0 growing past 1 to `overshoot`, then settling on 1.
+ *
+ * @example
+ * ```ts
+ * import { popScale } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(popScale(0)); // 0
+ * console.log(popScale(0.7)); // 1.08, the peak
+ * console.log(popScale(1)); // 1
+ * ```
+ */
+export declare function popScale(progress: number, overshoot?: number): number;
+/**
+ * the `Easing` function for a name or a function, defaulting to `easeInOutQuad`
+ *
+ * @example
+ * ```ts
+ * import { resolveEasing } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(resolveEasing('linear')(0.25)); // 0.25
+ * console.log(resolveEasing((t) => t * t)(0.5)); // 0.25
+ * ```
+ */
+export declare function resolveEasing(easing: TransitionOptions['easing']): EasingFunction;
+export interface TileShrinkOptions {
+    columns?: number;
+    rows?: number;
+    /** the part of the duration over which tiles start, 0 to 1; 0.5 when omitted */
+    stagger?: number;
+    order?: TileOrder;
+    /** how far each tile turns while it shrinks, in radians; 0 when omitted */
+    rotation?: number;
+    seed?: number;
+}
+/**
+ * The old picture cut into tiles that each shrink to nothing, in `order`, uncovering the new scene.
+ *
+ * @example
+ * ```ts
+ * import { tileShrink } from '@datamoc/mw_games/two-d/render';
+ *
+ * const transition = tileShrink({ columns: 8, rows: 5, order: 'diagonal' });
+ * // Game.current.switchScene(NextLevel, { transition, duration: 0.6 });
+ * console.log(transition.name); // 'tileShrink'
+ * ```
+ */
+export declare function tileShrink(options?: TileShrinkOptions): SceneTransition;
+/**
+ * The old picture shrinking to a point (the screen's centre unless `to` names one) over the new scene.
+ *
+ * @example
+ * ```ts
+ * import { shrink } from '@datamoc/mw_games/two-d/render';
+ *
+ * const closeToButton = shrink({ to: { x: 700, y: 40 } });
+ * console.log(closeToButton.name); // 'shrink'
+ * ```
+ */
+export declare function shrink(options?: {
+    to?: TransitionPoint;
+}): SceneTransition;
+/**
+ * The new scene springing out of a point (the centre unless `from` names one), overshooting a little
+ * (`overshoot`, 1.08 when omitted) before it settles.
+ *
+ * @example
+ * ```ts
+ * import { pop } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(pop({ from: { x: 400, y: 300 } }).name); // 'pop'
+ * ```
+ */
+export declare function pop(options?: {
+    from?: TransitionPoint;
+    overshoot?: number;
+}): SceneTransition;
+/**
+ * The new scene growing from a point (the centre unless `from` names one) without overshoot.
+ *
+ * @example
+ * ```ts
+ * import { grow } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(grow().name); // 'grow'
+ * ```
+ */
+export declare function grow(options?: {
+    from?: TransitionPoint;
+}): SceneTransition;
+/**
+ * Old and new pictures sliding together: the new one enters from the `direction` side while the old
+ * one leaves the other way.
+ *
+ * @example
+ * ```ts
+ * import { slide } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(slide({ direction: 'left' }).name); // 'slide'
+ * ```
+ */
+export declare function slide(options?: {
+    direction?: 'left' | 'right' | 'up' | 'down';
+}): SceneTransition;
+/**
+ * A circle opening from a point (the centre unless `from` names one) that shows the new scene
+ * through it, the old picture around it.
+ *
+ * @example
+ * ```ts
+ * import { iris } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(iris({ from: { x: 120, y: 80 } }).name); // 'iris'
+ * ```
+ */
+export declare function iris(options?: {
+    from?: TransitionPoint;
+}): SceneTransition;
+/**
+ * The old picture fading out over the new scene.
+ *
+ * @example
+ * ```ts
+ * import { dissolve } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(dissolve().name); // 'dissolve'
+ * ```
+ */
+export declare function dissolve(): SceneTransition;
+/** how a window or panel comes and goes */
+export type OpenAnimationKind = 'pop' | 'grow' | 'slide' | 'fade';
+/**
+ * What a window opening (or closing, run backwards) looks like at `progress`: its scale, opacity and
+ * how far it is still pushed down by a `slide`. Closing never overshoots.
+ *
+ * @example
+ * ```ts
+ * import { openAnimationFrame } from '@datamoc/mw_games/two-d/render';
+ *
+ * console.log(openAnimationFrame('pop', 0).scale); // 0
+ * console.log(openAnimationFrame('pop', 1).scale); // 1
+ * console.log(openAnimationFrame('slide', 0.5).offset > 0); // true: still sliding up
+ * ```
+ */
+export declare function openAnimationFrame(kind: OpenAnimationKind, progress: number, closing?: boolean): {
+    scale: number;
+    alpha: number;
+    offset: number;
+};
+/**
+ * Plays one transition: owns the `under` and `over` layers, advances with `update(dt)` in real
+ * time and tells its `onDone` once. `Game` runs one of these around a scene change; it is exported so
+ * a game with its own compositing can run a transition the same way.
+ *
+ * @example
+ * ```ts
+ * import { Container2D as Container } from '@datamoc/mw_games/two-d/render';
+ * import { TransitionRunner, dissolve } from '@datamoc/mw_games/two-d/render';
+ *
+ * const incoming = new Container();
+ * const runner = new TransitionRunner({ transition: dissolve(), duration: 0.5 }, { width: 800, height: 600 }, null, incoming);
+ * // put runner.under, incoming and runner.over on the stage, in that order
+ * while (!runner.update(1 / 60)) continue;
+ * console.log(runner.done); // true
+ * ```
+ */
+export declare class TransitionRunner {
+    readonly under: Container2D;
+    readonly over: Container2D;
+    readonly pause: boolean;
+    private readonly runtime;
+    private readonly duration;
+    private readonly ease;
+    private readonly onDone?;
+    private readonly snapshot;
+    private elapsed;
+    private finished;
+    constructor(options: TransitionOptions, size: {
+        width: number;
+        height: number;
+    }, snapshot: Texture2D | null, incoming: Container2D);
+    /** how far along it is, 0 to 1, before easing */
+    get progress(): number;
+    get done(): boolean;
+    /** @returns true on the frame it ends (and on every call after) */
+    update(dt: number): boolean;
+    /** jumps to the end: the transition's last frame is applied, its layers are emptied, `onDone` runs */
+    finish(): void;
+}
+//# sourceMappingURL=SceneTransition.d.ts.map

package/dist/two-d/render/SceneTransition.d.ts.map

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