@datamoc/mw_games 0.44.2 → 0.46.0

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

@@ -1,240 +0,0 @@
-import { Application } from 'pixi.js';
-import type { Scene2D } from './Scene2D.ts';
-import type { SceneClass } from '../core/Scene.ts';
-import { Signal } from '../core/Signal.ts';
-import { type QualityScalerOptions } from './QualityScaler.ts';
-import { type TransitionOptions } from './render/SceneTransition.ts';
-export interface GameOptions {
-    /** the canvas to draw into; one is created and appended if omitted */
-    canvas?: HTMLCanvasElement;
-    /** background colour behind everything, as 0xRRGGBB */
-    background?: number;
-    /**
-     * Longest frame the game will simulate, in seconds.
-     *
-     * A backgrounded tab reports an enormous delta on its first frame back, which would
-     * teleport everything that moves. Frames longer than this are treated as this long,
-     * so the game slows down rather than jumping.
-     */
-    maxDelta?: number;
-    /**
-     * Pixel art is never smoothed when scaled - both inside the game (texture sampling)
-     * and in the browser's own compositing of the canvas element onto the page, which is a
-     * separate step and blurs on its own if left at the default. Set false for a game whose
-     * art is not pixel art and should smooth when magnified.
-     */
-    pixelArt?: boolean;
-    /**
-     * What the renderer sizes itself to. Defaults to the window.
-     *
-     * Sizing to the canvas's parent looks tidier but circles: a canvas styled to fill its
-     * parent gives the parent no height of its own, so both collapse. Pass an element only
-     * when that element has a size the canvas does not depend on.
-     */
-    resizeTo?: HTMLElement | Window;
-    /**
-     * Pixi extension registrations to run before the renderer is built.
-     *
-     * `TintedSprite` (and everything built on it - `AnimatedSprite`, `TileMap`,
-     * `DialogueStage`) registers its own colour-transform pipe automatically, at module
-     * scope, the moment a game imports it; a game never has to pass anything here for that.
-     * `TiledSprite` and `NinePatch` carry the same guarantee through a different mechanism:
-     * Pixi's own `TilingSprite`/`NineSliceSprite` modules each side-effect-import their own
-     * `init` module, which registers their render pipe unconditionally the moment the class
-     * is imported - true of Pixi's package itself, not something `mwg` implements or could
-     * accidentally omit, and confirmed directly against Pixi's own source rather than assumed
-     * (`tests/builtin-pipes.test.ts` checks it stays true). This stays as an escape hatch for
-     * a game defining its own Pixi extension - a custom render pipe, its own batcher - which
-     * still has to be registered before `app.init()` builds the renderer, the same constraint
-     * `registerColorTransform` works around by self-registering on import instead of needing a
-     * caller to remember it.
-     */
-    extensions?: readonly (() => void)[];
-    /**
-     * Suspends the loop and silences `audio` while the page is hidden, resuming both on
-     * show. True unless a game drives its own loop (or its own visibility handling), in
-     * which case set false and call `suspend`/`resume` itself.
-     */
-    autoPause?: boolean;
-    /** the game's own audio rig, silenced while the page is hidden - an `Orchestrator` fits */
-    audio?: AudioSuspendRig | null;
-    /**
-     * Frame-time quality scaling over the static device fit, off unless given: the backing
-     * store steps down after sustained over-budget frames and recovers only after a much
-     * longer streak inside budget. The ceiling stays the `fitResolution` answer, so this
-     * never asks for more than the device can make.
-     */
-    qualityScaling?: Omit<QualityScalerOptions, 'ceiling'> | null;
-}
-/** the suspend/resume pair `Game` calls on its audio rig around a page hide */
-export interface AudioSuspendRig {
-    suspend(): void;
-    resume(): void;
-}
-/**
- * The application: owns the renderer, the loop, and the current scene.
- *
- * Construct it, `await start(FirstScene)`, and the rest is scenes.
- *
- * The canvas is drawn at the display's `devicePixelRatio`, up to what the device can actually
- * make: a backing store of `viewport * devicePixelRatio` pixels is refused past the GPU's
- * `MAX_TEXTURE_SIZE` (WebGL clamps it rather than failing, with nothing reported), so the
- * resolution is reduced to the largest whole number that fits and a warning says so. A game
- * therefore keeps rendering on a device with a small limit, softer than the display asked for
- * rather than wrong; nothing changes on a device that can afford what it asked for.
- */
-export declare class Game {
-    private static instance;
-    readonly app: Application<import("pixi.js").Renderer>;
-    /** seconds elapsed in the previous frame, clamped by `maxDelta` */
-    elapsed: number;
-    /** total seconds since the current scene was created */
-    timeTotal: number;
-    /** multiplies elapsed time; 0 pauses the game without stopping the renderer */
-    timeScale: number;
-    /** fires after every frame's update, for systems that are not scene-owned */
-    readonly onFrame: Signal<number>;
-    private hitStopRemaining;
-    private hitStopScale;
-    private stack;
-    private pending;
-    /** transition requests held by `queue: true` until the running transition finishes */
-    private queued;
-    private running;
-    private options;
-    private started;
-    private stopWatchingDpr;
-    private stopWatchingVisibility;
-    private suspended_;
-    private timeScaleBeforeSuspend;
-    private scaler;
-    constructor(options?: GameOptions);
-    /** the viewport width in css pixels, which is what scenes lay out against */
-    get width(): number;
-    get height(): number;
-    /** the running game, or null before one exists, for code that works with or without one */
-    static get active(): Game | null;
-    /** the running game, for the few places that genuinely need a global */
-    static get current(): Game;
-    start(first: SceneClass<Scene2D>): Promise<void>;
-    /**
-     * Queues a scene change; it happens at the start of the next frame.
-     *
-     * The whole stack goes: every scene is destroyed, suspended or not, and the
-     * new one starts alone. For a scene that returns, push it instead.
-     */
-    switchScene(next: SceneClass<Scene2D>, options?: TransitionOptions): void;
-    /**
-     * Changes what the current scene shows under a transition: `swap` runs at the start of the next
-     * frame, once the outgoing picture has been photographed, and the transition then plays over the
-     * result. For a scene that replaces its decor, level or layout in place rather than switching scenes;
-     * `Scene2D.transitionTo` is the same call from inside the scene. While a transition is
-     * already playing this one is ignored unless its options say `queue: true` (play after
-     * it) or `interrupt: true` (finish it at once and play this one); see `TransitionOptions`.
-     */
-    transition(swap: () => void, options: TransitionOptions): void;
-    /** true while a transition is playing or one is held by `queue: true`, for a scene that should ignore input until it ends */
-    get transitioning(): boolean;
-    /**
-     * Queues a scene on top of the current one; it starts at the next frame.
-     *
-     * The scene underneath suspends but is not destroyed: it stops updating and
-     * keeps rendering, so the new scene can layer over it or replace it
-     * outright, and `popScene` resumes exactly where play left off.
-     */
-    pushScene(next: SceneClass<Scene2D>): void;
-    /**
-     * Queues the top scene's removal; it happens at the start of the next frame.
-     *
-     * @param result reported back to the resumed scene's `onResume`
-     */
-    popScene(result?: unknown): void;
-    /** the scene currently updating: the top of the stack */
-    get currentScene(): Scene2D | null;
-    /**
-     * Briefly dips `timeScale` toward `scale` for `duration` real seconds, then restores it
-     * to 1 - a heavy hit's momentary freeze-frame, distinct from `render.Camera.shake` (which
-     * moves the view, not the clock) and from `ui.FloatingText` (a damage number, not a time
-     * effect). A second call while one is still running simply replaces it, the same way
-     * `Camera.shake` restarts rather than stacking.
-     */
-    hitStop(duration: number, scale?: number): void;
-    /**
-     * Advances the game by one frame and draws it, without waiting for the browser.
-     *
-     * The loop normally runs on requestAnimationFrame, which browsers suspend while a tab
-     * is not visible. That is right for a game and wrong for a test or a screenshot, so
-     * this drives a frame directly.
-     *
-     * @param dt seconds to advance by
-     */
-    step(dt: number): void;
-    /** true while suspended by `suspend` (a page hide, usually) */
-    get suspended(): boolean;
-    /**
-     * Freezes the simulation for a page hide: the clock (`timeScale`) parks at 0, the top
-     * scene hears `onSuspend`, and the game's own audio rig is silenced. The renderer keeps
-     * going and `step(dt)` still works, so consoles and screenshots are unaffected.
-     * Idempotent; `resume` restores the parked clock and audio, and the player's own mute
-     * setting is never touched.
-     */
-    suspend(): void;
-    /**
-     * The counterpart to `suspend`: restores the parked clock, fires `onResume` on the top
-     * scene, and unsilences the audio rig. Calling it without a `suspend` does nothing.
-     */
-    resume(): void;
-    /**
-     * Publishes the running game on the global object, for tools and for the console.
-     *
-     * `__PIXI_APP__` is the name the PixiJS devtools extension looks for, so declaring it
-     * costs nothing and makes the scene graph inspectable. `__MWG__` is the game itself,
-     * which is what makes `__MWG__.step(1/60)` possible from a console: the only way to
-     * advance a game whose tab the browser has suspended, and the difference between
-     * diagnosing a frozen page and guessing at it.
-     *
-     * Neither is read by the framework. Nothing depends on them existing.
-     */
-    private expose;
-    /**
-     * Resizes the renderer to a resolution this device can actually afford.
-     *
-     * A full-window canvas at device resolution can ask for a backing store larger than the
-     * GPU's `MAX_TEXTURE_SIZE`, and WebGL clamps that silently instead of failing: the canvas
-     * keeps its size, the scene keeps being rendered into a surface that is not the one asked
-     * for, and nothing anywhere says so. A 1080-wide phone at `devicePixelRatio` 2.625 asks for
-     * 2121x4709 against the 4096 limit one emulator reported, and got a 2121x4096 drawing
-     * buffer; see `fitResolution` for the arithmetic and for what that investigation did and
-     * did not establish about the black screen that process showed.
-     *
-     * Called after `init`, whenever the renderer is resized (a rotation changes which one fits),
-     * and when `devicePixelRatio` itself changes. It returns immediately when the device can
-     * afford what was asked for, which is every ordinary case, so nothing about a normal
-     * startup changes.
-     */
-    private fitResolutionToDevice;
-    private frame;
-    private switchNow;
-    /** a picture of everything on screen now, or null when there is nothing to show or motion is reduced */
-    private snapshot;
-    /** puts what is on the stage into a container the transition may move, between its two layers */
-    private beginTransition;
-    /** finishes a transition that is still playing and puts the scenes back on the stage */
-    private endTransition;
-    /**
-     * Applies one queued scene change. While a transition is playing, a request carrying a
-     * transition is ignored by default (its swap never runs), held by `queue: true` until
-     * the running one finishes, or finishes it at once with `interrupt: true`; a request
-     * with no transition finishes the running one and applies, as it always has.
-     */
-    private applyRequest;
-    private applySwap;
-    /** a new scene alone: everything else is destroyed, the clocks restart */
-    private applySwitch;
-    /** a new scene over the current one, which suspends but survives underneath */
-    private applyPush;
-    /** the top scene leaves, reporting back to whatever it covered */
-    private applyPop;
-    destroy(): void;
-}
-//# sourceMappingURL=Game.d.ts.map

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

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