@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiBattleMapDissolve.d.ts

@@ -0,0 +1,38 @@
+import type { Filter, Sprite, UniformGroup } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+export declare const MAP_DISSOLVE_FRAGMENT = "\nin vec2 vTextureCoord;\nout vec4 finalColor;\nuniform sampler2D uTexture;\nuniform float uProgress;\nuniform float uEdgeSoftness;\nuniform float uHighlightWidth;\nuniform float uHighlightIntensity;\nuniform float uGrainAmount;\nuniform float uGrainScale;\nuniform float uSeed;\nuniform vec3 uHighlightColor;\n\nfloat stableNoise(vec2 point) {\n  return fract(sin(dot(point, vec2(127.1, 311.7)) + uSeed * 91.7) * 43758.5453123);\n}\n\nvoid main(void) {\n  vec4 source = texture(uTexture, vTextureCoord);\n  float progress = clamp(uProgress, 0.0, 1.0);\n  float luminance = dot(source.rgb, vec3(0.2126, 0.7152, 0.0722));\n  float darkness = 1.0 - luminance;\n  float grain = (stableNoise(floor(vTextureCoord * max(1.0, uGrainScale))) - 0.5) * uGrainAmount;\n  float signal = clamp(darkness + grain, 0.0, 1.0);\n  float threshold = 1.0 - progress;\n  float softness = max(0.0001, uEdgeSoftness);\n  float reveal = smoothstep(threshold - softness, threshold + softness, signal);\n  reveal *= smoothstep(0.0, 0.02, progress);\n  reveal = mix(reveal, 1.0, smoothstep(0.98, 1.0, progress));\n  float bandDistance = abs(signal - threshold);\n  float highlight = 1.0 - smoothstep(uHighlightWidth, uHighlightWidth + softness, bandDistance);\n  highlight *= (1.0 - smoothstep(0.92, 1.0, progress)) * smoothstep(0.0, 0.08, progress);\n  float visible = max(reveal, highlight);\n  vec3 highlighted = mix(source.rgb, uHighlightColor, highlight * uHighlightIntensity);\n  finalColor = vec4(highlighted, source.a * visible);\n}\n";
+export interface PixiBattleMapDissolveSettings {
+    readonly durationMs: number;
+    readonly edgeSoftness: number;
+    readonly highlightWidth: number;
+    readonly highlightIntensity: number;
+    readonly grainAmount: number;
+    readonly grainScale: number;
+    readonly highlightColor: string;
+}
+export declare const DEFAULT_PIXI_BATTLE_MAP_DISSOLVE_SETTINGS: PixiBattleMapDissolveSettings;
+interface Constructors {
+    readonly Filter: typeof Filter;
+    readonly UniformGroup: typeof UniformGroup;
+}
+/** Retained, single-pass darkness-first dissolve used only by the incoming battle-map sprite. */
+export declare class PixiBattleMapDissolve {
+    private readonly director;
+    private readonly activity;
+    private readonly requestRender;
+    private readonly filter;
+    private readonly uniforms;
+    private settings;
+    private active;
+    private reducedMotion;
+    private destroyed;
+    constructor(constructors: Constructors, director: PixiAnimationDirector, activity: PixiAnimationActivity | undefined, requestRender: (() => void) | undefined, settings?: PixiBattleMapDissolveSettings);
+    setReducedMotion(reducedMotion: boolean): void;
+    updateSettings(settings: PixiBattleMapDissolveSettings): void;
+    play(sprite: Sprite, seed: number): Promise<void>;
+    commit(): void;
+    destroy(): void;
+    private cleanup;
+}
+export {};

package/dist/PixiBattleSceneTransition.d.ts

@@ -0,0 +1,30 @@
+import type { Container, Filter, Graphics, Sprite, Texture } from 'pixi.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiStageTheme } from './PixiStageTheme.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+interface Constructors {
+    Container: typeof Container;
+    Filter?: typeof Filter;
+    Graphics: typeof Graphics;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+}
+/** One captured image, translated horizontally. It never owns the live scene or a ticker. */
+export declare class PixiBattleSceneTransition {
+    private readonly constructors;
+    private readonly animation;
+    private readonly render;
+    private readonly texture;
+    private readonly pixiStageTheme;
+    private readonly tuning?;
+    readonly node: Container;
+    private readonly veil;
+    private readonly slide;
+    private blur;
+    private destroyed;
+    constructor(constructors: Constructors, animation: PixiAnimationDirector, render: () => void, texture: Texture | null, pixiStageTheme: PixiStageTheme, tuning?: SessionTuningResolver | undefined);
+    play(signal: AbortSignal, reducedMotion: boolean, commit: () => void, onStart?: () => void): Promise<void>;
+    destroy(): void;
+    private releaseBlur;
+    private number;
+}
+export {};

package/dist/PixiBattleTokenLifecycleCoordinator.d.ts

@@ -0,0 +1,44 @@
+export interface TokenLifecyclePoint {
+    col: number;
+    row: number;
+}
+export interface TokenLifecycleSnapshot {
+    id: string;
+    gridPosition: TokenLifecyclePoint;
+}
+export interface TokenMovementTransition {
+    id: string;
+    from: TokenLifecyclePoint;
+    to: TokenLifecyclePoint;
+    generation: number;
+}
+export interface BattleSnapshotTransition {
+    revision: number;
+    added: Array<{
+        id: string;
+        generation: number;
+    }>;
+    removed: Array<{
+        id: string;
+        generation: number;
+    }>;
+    moved: TokenMovementTransition[];
+    skipAnim: boolean;
+}
+export interface TokenLifecycleLease {
+    generation: number;
+    signal: AbortSignal;
+}
+/** Computes renderer-local snapshot transitions and guards async completion by token generation. */
+export declare class PixiBattleTokenLifecycleCoordinator {
+    private readonly known;
+    private readonly generations;
+    private readonly controllers;
+    diff(revision: number, tokens: readonly TokenLifecycleSnapshot[], skipAnim?: boolean): BattleSnapshotTransition;
+    begin(id: string): TokenLifecycleLease;
+    isCurrent(id: string, lease: TokenLifecycleLease): boolean;
+    complete(id: string, lease: TokenLifecycleLease): void;
+    settle(id: string, position: TokenLifecyclePoint): void;
+    abort(id: string): void;
+    reset(): void;
+}

package/dist/PixiBattleVisualLayout.d.ts

@@ -0,0 +1,284 @@
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+export type BattleHpColorTone = 'healthy' | 'wounded' | 'critical' | 'empty';
+export declare const resolveBattleHpColor: (tone: BattleHpColorTone, tuning: SessionTuningResolver | undefined, battleHpColors: Readonly<Record<BattleHpColorTone, string>>) => string;
+export declare const resolveUnitCardHpGradientAlpha: (segmentIndex: number, segmentCount: number) => number;
+export declare const UNIT_CARD_LAYOUT: {
+    readonly source: {
+        readonly width: 724;
+        readonly height: 166;
+    };
+    readonly rowGap: 6;
+    readonly maxVisibleRows: 13;
+    readonly avatar: {
+        readonly x: 14;
+        readonly y: 13;
+        readonly width: 136;
+        readonly height: 140;
+        readonly radius: 5;
+    };
+    readonly order: {
+        readonly x: 205;
+        readonly y: 83;
+        readonly fontSize: 27;
+    };
+    readonly name: {
+        readonly x: 238;
+        readonly y: 83;
+        readonly fontSize: 25;
+        readonly minFontSize: 17;
+        readonly rightPadding: 12;
+    };
+    readonly status: {
+        readonly right: 700;
+        readonly y: 32;
+        readonly radius: 10;
+        readonly paddingX: 12;
+        readonly fontSize: 15;
+    };
+    readonly hp: {
+        readonly x: 695;
+        readonly y: 91;
+        readonly fontSize: 17;
+    };
+    readonly hpBar: {
+        readonly x: 238;
+        readonly y: 130;
+        readonly width: 455;
+        readonly height: 7;
+    };
+    readonly activeOutline: {
+        readonly inset: 5;
+        readonly width: 2.65;
+    };
+};
+export declare const BATTLE_TYPOGRAPHY_DEFAULTS: {
+    readonly round: {
+        readonly fontSize: 29;
+    };
+    readonly roster: {
+        readonly order: {
+            readonly x: 205;
+            readonly y: 83;
+            readonly fontSize: 27;
+        };
+        readonly name: {
+            readonly x: 238;
+            readonly y: 83;
+            readonly fontSize: 25;
+            readonly minFontSize: 17;
+        };
+        readonly hp: {
+            readonly x: 695;
+            readonly y: 91;
+            readonly fontSize: 17;
+        };
+        readonly status: {
+            readonly right: 700;
+            readonly y: 32;
+            readonly paddingX: 12;
+            readonly paddingY: 4;
+            readonly fontSize: 10;
+            readonly text: {
+                readonly x: 0;
+                readonly y: 0;
+            };
+            readonly icon: {
+                readonly x: 0;
+                readonly y: 0;
+                readonly size: 12;
+            };
+        };
+    };
+    readonly objective: {
+        readonly title: {
+            readonly x: 42;
+            readonly y: 28;
+            readonly fontSize: 23;
+        };
+        readonly percent: {
+            readonly x: 505;
+            readonly y: 28;
+            readonly fontSize: 22;
+        };
+    };
+    readonly token: {
+        readonly x: 0;
+        readonly y: 0;
+        readonly fontSize: 14;
+    };
+    readonly distance: {
+        readonly x: 27;
+        readonly y: 13.5;
+        readonly fontSize: 14;
+        readonly ruler: {
+            readonly x: 7;
+            readonly y: 5.5;
+        };
+    };
+};
+export type BattleTypographyTuning = {
+    round: {
+        fontSize: number;
+    };
+    roster: {
+        order: {
+            x: number;
+            y: number;
+            fontSize: number;
+        };
+        name: {
+            x: number;
+            y: number;
+            fontSize: number;
+            minFontSize: number;
+        };
+        hp: {
+            x: number;
+            y: number;
+            fontSize: number;
+        };
+        status: {
+            right: number;
+            y: number;
+            paddingX: number;
+            paddingY: number;
+            fontSize: number;
+            text: {
+                x: number;
+                y: number;
+            };
+            icon: {
+                x: number;
+                y: number;
+                size: number;
+            };
+        };
+    };
+    objective: {
+        title: {
+            x: number;
+            y: number;
+            fontSize: number;
+        };
+        percent: {
+            x: number;
+            y: number;
+            fontSize: number;
+        };
+    };
+    token: {
+        x: number;
+        y: number;
+        fontSize: number;
+    };
+    distance: {
+        x: number;
+        y: number;
+        fontSize: number;
+        ruler: {
+            x: number;
+            y: number;
+        };
+    };
+};
+export declare const resolveBattleTypography: (value: BattleTypographyTuning | undefined) => BattleTypographyTuning;
+export declare const resolveBattleStatusPillLayout: (style: BattleTypographyTuning["roster"]["status"], options: {
+    hasIcon: boolean;
+    labelWidth: number;
+    labelHeight: number;
+}) => {
+    width: number;
+    height: number;
+    label: {
+        x: number;
+        y: number;
+    };
+    icon: {
+        x: number;
+        y: number;
+    } | null;
+};
+export declare const TOKEN_RING_LAYOUT: {
+    readonly textureDiameter: 1254;
+    readonly outerDiameterByCell: 1.2;
+    readonly svgInnerDiameterRatio: 0.728;
+    readonly avatarApertureInset: 1.02;
+    readonly shadow: {
+        readonly offsetXRatio: 0.08;
+        readonly offsetYRatio: 0.11;
+        readonly radiusRatio: 0.455;
+    };
+};
+export declare const resolveBattleTokenVisualLayout: (cellDiameter: number) => {
+    ringDiameter: number;
+    avatarAperture: number;
+};
+export declare const DISTANCE_RULER_STYLE: {
+    readonly leadingWidth: 40;
+    readonly x: 7;
+    readonly y: 5.5;
+    readonly width: 9;
+    readonly height: 16;
+    readonly tickLengths: readonly [4, 7, 4, 7];
+    readonly textX: 27;
+};
+export declare const OBJECTIVE_LAYOUT: {
+    readonly source: {
+        readonly width: 550;
+        readonly height: 110;
+    };
+    readonly maxWidth: 275;
+    readonly gap: 10;
+    readonly title: {
+        readonly x: 42;
+        readonly y: 28;
+        readonly fontSize: 23;
+    };
+    readonly percent: {
+        readonly x: 505;
+        readonly y: 28;
+        readonly fontSize: 22;
+    };
+    readonly track: {
+        readonly x: 60;
+        readonly y: 63;
+        readonly width: 430;
+        readonly height: 10;
+        readonly radius: 2;
+    };
+};
+export declare const OBJECTIVE_PROGRESS_STYLE: {
+    readonly smallTickEvery: 0.05;
+    readonly majorTicks: readonly [0, 0.25, 0.5, 0.75, 1];
+    readonly smallTickHeight: 4;
+    readonly majorTickHeight: 8;
+    readonly endMarkerWidth: 2;
+    readonly highlightHeight: 1;
+    readonly shadowHeight: 1;
+};
+export declare const clampProgress: (value: number) => number;
+export interface BattleTeamCheckIconLayoutOptions {
+    areaWidth: number;
+    areaHeight: number;
+    iconHeight: number;
+    gap: number;
+    textureAspectRatio: number;
+}
+export interface BattleTeamCheckIconLayout {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const resolveBattleTeamCheckIconLayouts: (count: number, options: BattleTeamCheckIconLayoutOptions) => BattleTeamCheckIconLayout[];
+export interface BattleRosterCardLayoutOptions {
+    maxVisibleRows?: number;
+    rowGap?: number;
+}
+export declare const resolveBattleRosterCardLayout: (availableWidth: number, availableHeight: number, textureWidth: number, textureHeight: number, options?: BattleRosterCardLayoutOptions) => {
+    scale: number;
+    width: number;
+    height: number;
+    gap: number;
+    pitch: number;
+};

package/dist/PixiBattleWhipGeometry.d.ts

@@ -0,0 +1,18 @@
+/** Fixed topology: one narrow ribbon, updated in place for the entire attack. */
+export declare const WHIP_SEGMENTS = 40;
+export interface WhipShape {
+    length: number;
+    reach: number;
+    bend: number;
+    phase: number;
+    width: number;
+    tipRatio: number;
+}
+export declare const createWhipBuffers: () => {
+    positions: Float32Array<ArrayBuffer>;
+    centers: Float32Array<ArrayBuffer>;
+    uvs: Float32Array<ArrayBuffer>;
+    indices: Uint32Array<ArrayBuffer>;
+};
+export type WhipBuffers = ReturnType<typeof createWhipBuffers>;
+export declare const updateWhipPositions: (buffers: WhipBuffers, shape: WhipShape) => void;

package/dist/PixiBattleWhipMotion.d.ts

@@ -0,0 +1,63 @@
+import type { Container } from 'pixi.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiBattleWhipResources } from './PixiBattleWhipResources.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+interface WhipMotionContext {
+    resources: PixiBattleWhipResources;
+    parent: Container;
+    director: PixiAnimationDirector;
+    world: {
+        getCellSize?(): {
+            width: number;
+            height: number;
+        };
+        isReducedMotionEnabled?(): boolean;
+        getPresentationNode(id: string): {
+            position: {
+                x: number;
+                y: number;
+            };
+        } | null;
+    };
+    style: {
+        widthCellRatio: number;
+        bendCellRatio: number;
+        tipRatio: number;
+        alpha: number;
+        bodyColor: string;
+        edgeColor: string;
+    };
+    tuning?: SessionTuningResolver;
+    attackerId: string;
+    from: {
+        x: number;
+        y: number;
+    };
+    target: {
+        x: number;
+        y: number;
+    };
+    miss: boolean;
+    onStrike?: () => void;
+}
+/** A single lease spans approach, contact and return; the caller releases it in finally. */
+export declare class PixiBattleWhipMotion {
+    private readonly context;
+    private handle;
+    private generation;
+    private readonly pose;
+    private readonly cell;
+    private readonly reducedMotion;
+    private readonly settings;
+    constructor(context: WhipMotionContext);
+    get strikeSeconds(): number;
+    approach(signal: AbortSignal, dodge: () => Promise<void>): Promise<void>;
+    hold(signal: AbortSignal): Promise<void>;
+    retract(signal: AbortSignal): Promise<void>;
+    release(): void;
+    private number;
+    private color;
+    private tween;
+    private draw;
+}
+export {};

package/dist/PixiBattleWhipResources.d.ts

@@ -0,0 +1,53 @@
+import type { Container, Mesh, MeshGeometry, Shader, UniformGroup } from 'pixi.js';
+import type { PixiBattleFxCapabilities } from './PixiBattleFxResources.js';
+import { type WhipBuffers, type WhipShape } from './PixiBattleWhipGeometry.js';
+export interface PixiBattleWhipHandle {
+    mesh: Mesh<MeshGeometry, Shader>;
+    geometry: MeshGeometry;
+    shader: Shader;
+    buffers: WhipBuffers;
+    bodyColor: Float32Array;
+    edgeColor: Float32Array;
+    uniforms: UniformGroup<{
+        uBodyColor: {
+            value: Float32Array;
+            type: 'vec3<f32>';
+        };
+        uEdgeColor: {
+            value: Float32Array;
+            type: 'vec3<f32>';
+        };
+        uLength: {
+            value: number;
+            type: 'f32';
+        };
+        uLinkLength: {
+            value: number;
+            type: 'f32';
+        };
+        uBlur: {
+            value: number;
+            type: 'f32';
+        };
+    }>;
+    released: boolean;
+    generation: number;
+}
+/** Sub-pool owned exclusively by PixiBattleFxResourceOwner. */
+export declare class PixiBattleWhipResources {
+    private readonly capabilities;
+    private readonly available;
+    private readonly active;
+    private readonly owned;
+    constructor(capabilities: PixiBattleFxCapabilities);
+    acquire(parent: Container, bodyColor: string, edgeColor: string): PixiBattleWhipHandle | null;
+    update(handle: PixiBattleWhipHandle, shape: WhipShape, detail?: {
+        linkLength: number;
+        blur: number;
+    }): void;
+    release(handle: PixiBattleWhipHandle | null, generation?: number | undefined): void;
+    reset(): void;
+    destroy(): void;
+    get activeCount(): number;
+    private create;
+}

package/dist/PixiCameraFocusController.d.ts

@@ -0,0 +1,40 @@
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { PixiTokenWorld } from './PixiTokenWorld.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { BattleViewportGridLayout } from './PixiSessionLayout.js';
+import type { SessionTuningResolver } from '@bardway/trpg-media/tuning';
+export interface CameraFocusInput {
+    participantIds: readonly string[];
+    layout: BattleViewportGridLayout;
+    landingPoints?: readonly {
+        x: number;
+        y: number;
+    }[];
+    animateCamera: boolean;
+    signal: AbortSignal;
+    run(signal: AbortSignal): Promise<void>;
+    waitForBarriers?(): Promise<void>;
+}
+export declare const resolveConfinedCameraAxis: (focus: number, scale: number, viewportStart: number, viewportSize: number, mapStart: number, mapSize: number) => number;
+export declare const resolveCameraFocusPosition: (layout: BattleViewportGridLayout, focusPivot: {
+    x: number;
+    y: number;
+}, focusScale: {
+    x: number;
+    y: number;
+}) => {
+    x: number;
+    y: number;
+};
+export declare class PixiCameraFocusController {
+    private readonly scene;
+    private readonly world;
+    private readonly director;
+    private readonly getTuning;
+    private active;
+    constructor(scene: PixiSceneGraph, world: PixiTokenWorld, director: PixiAnimationDirector, getTuning: () => SessionTuningResolver | undefined);
+    reset(): void;
+    destroy(): void;
+    play(input: CameraFocusInput): Promise<void>;
+    private resolveTuningNumber;
+}