@bardway/trpg-pixi 0.0.0-stage → 0.1.0

package/dist/PixiMapMediaSurface.d.ts

@@ -0,0 +1,71 @@
+import { type RuntimeLogger } from '@bardway/trpg-media';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+import type { PixiVideoRuntime } from './PixiVideoRuntime.js';
+import type { PixiBattleMapDissolve } from './PixiBattleMapDissolve.js';
+import type { BattleViewportGridLayout } from './PixiSessionLayout.js';
+export interface MapMediaSource {
+    id: string;
+    revision?: string;
+    imageUrl: string;
+    videoUrl?: string;
+}
+export type MapMediaStatus = 'ready' | 'fallback';
+export interface MapMediaDependencies {
+    Sprite: typeof import('pixi.js').Sprite;
+    Graphics: typeof import('pixi.js').Graphics;
+    mediaBreath?: PixiMediaBreathRuntime;
+    videoRuntime?: PixiVideoRuntime;
+    requestRender(): void;
+    logger: RuntimeLogger;
+    fallbackColor: string;
+}
+/** Exact poster/dissolve/video readiness and replacement mechanics extracted from PixiBattleWorld. */
+export declare class PixiMapMediaSurface {
+    private readonly scene;
+    private readonly assets;
+    private readonly dependencies;
+    private readonly mapDissolve;
+    private mapKey;
+    private mapSprite;
+    private mapSpriteKey;
+    private mapLoadVersion;
+    private mapMediaBreath;
+    private mapVideoBinding;
+    private mapVideoReady;
+    private mapVideoFailed;
+    private mapPosterTexture;
+    private mapReadiness;
+    private pendingMapTransition;
+    private deferredMapVideoUpgrade;
+    private layout;
+    private mapFallbackNode;
+    private activeResourceScope;
+    private owner;
+    private destroyed;
+    constructor(scene: PixiSceneGraph, assets: PixiAssetManager, dependencies: MapMediaDependencies, mapDissolve?: PixiBattleMapDissolve | null);
+    sync(input: {
+        owner: string;
+        map: MapMediaSource;
+        layout: BattleViewportGridLayout;
+        animate?: boolean;
+    }): void;
+    setReducedMotion(reduced: boolean): void;
+    setPaused(paused: boolean): void;
+    reset(): void;
+    destroy(): void;
+    waitForMapReady(mapSnapshot: MapMediaSource, signal: AbortSignal, timeoutMs: number): Promise<MapMediaStatus>;
+    waitForVideoReady(map: MapMediaSource, signal: AbortSignal): Promise<boolean>;
+    private syncMap;
+    private resolveMapKey;
+    private resolveMapDissolveSeed;
+    private commitPendingMapTransition;
+    private destroyMapPresentation;
+    private upgradeMapToVideo;
+    private beginMapReadiness;
+    private settleMapReadiness;
+    private syncMapFallback;
+    private destroyMapSprite;
+    private destroyMapFallback;
+}

package/dist/PixiMapWorldUtils.d.ts

@@ -0,0 +1,24 @@
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+export interface TokenAvatarCrop {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const resolveContainRect: (source: {
+    width: number;
+    height: number;
+}, viewport: PixiLayoutRect) => PixiLayoutRect;
+export declare const resolveCoverRect: (source: {
+    width: number;
+    height: number;
+}, viewport: PixiLayoutRect) => PixiLayoutRect;
+/** Covers a viewport while retaining the upper edge of the source image. */
+export declare const resolveTopCoverRect: (source: {
+    width: number;
+    height: number;
+}, viewport: PixiLayoutRect) => PixiLayoutRect;
+export declare const resolveCroppedCoverRect: (source: {
+    width: number;
+    height: number;
+}, viewport: PixiLayoutRect, crop?: TokenAvatarCrop) => PixiLayoutRect;

package/dist/PixiMediaBreathRuntime.d.ts

@@ -0,0 +1,69 @@
+import type { Filter, Sprite, Ticker, UniformGroup } from 'pixi.js';
+import type { PixiAnimationActivity } from './PixiAnimationActivity.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+export type PixiMediaBreathCategory = 'primary' | 'map' | 'avatar';
+export interface PixiMediaBreathBinding {
+    readonly filter: Filter;
+    release(): void;
+}
+export interface PixiMediaBreathFrame {
+    readonly breath: number;
+    readonly uiHighlightMultiplier: number;
+}
+interface Constructors {
+    Filter: typeof Filter;
+    UniformGroup: typeof UniformGroup;
+}
+export interface PixiMediaBreathSettings {
+    readonly enabled: boolean;
+    readonly contrast: number;
+    readonly shadowCrush: number;
+    readonly highlightBoost: number;
+    readonly dynamicStrength: number;
+    readonly brightReact: number;
+    readonly filterResolution: number;
+    readonly primaryGain: number;
+    readonly mapGain: number;
+    readonly avatarGain: number;
+    readonly uiHighlightGain: number;
+    readonly speedMultiplier: number;
+}
+export declare const DEFAULT_PIXI_MEDIA_BREATH_SETTINGS: PixiMediaBreathSettings;
+export declare const resolveMediaBreathSettings: (tuning?: SessionTuningResolver) => PixiMediaBreathSettings;
+export declare const resolveMediaBreathWave: (elapsedSeconds: number, phase?: number) => number;
+export declare class PixiMediaBreathRuntime {
+    private readonly constructors;
+    private readonly ticker;
+    private readonly activity;
+    private readonly requestRender;
+    private readonly bindings;
+    private readonly highlightListeners;
+    private settings;
+    private elapsedSeconds;
+    private paused;
+    private active;
+    private suspended;
+    private reducedMotion;
+    private destroyed;
+    private releaseActivity;
+    constructor(constructors: Constructors, ticker: Ticker, activity: PixiAnimationActivity, requestRender: () => void, tuning?: SessionTuningResolver);
+    attach(sprite: Sprite, category: PixiMediaBreathCategory): PixiMediaBreathBinding;
+    subscribeUiHighlight(listener: (frame: PixiMediaBreathFrame) => void): () => void;
+    getFrame(): PixiMediaBreathFrame;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    setPaused(paused: boolean): void;
+    setActive(active: boolean): void;
+    syncPresentationState(active: boolean, suspended: boolean): void;
+    setSuspended(suspended: boolean): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    reset(): void;
+    destroy(): void;
+    private releaseBinding;
+    private applyBinding;
+    private resolveCategoryBreath;
+    private resolveFrame;
+    private publishHighlightFrame;
+    private syncActivity;
+    private tick;
+}
+export {};

package/dist/PixiMotion.d.ts

@@ -0,0 +1,42 @@
+export declare const pixiMotion: {
+    readonly duration: {
+        readonly instant: 0;
+        readonly fast: 0.16;
+        readonly normal: 0.28;
+        readonly slow: 0.46;
+        readonly cinematic: 0.8;
+    };
+    readonly preset: {
+        readonly fadeIn: {
+            readonly duration: 0.28;
+            readonly ease: "power2.out";
+        };
+        readonly fadeOut: {
+            readonly duration: 0.16;
+            readonly ease: "power1.out";
+        };
+        readonly enter: {
+            readonly duration: 0.28;
+            readonly ease: "power3.out";
+        };
+        readonly emphasis: {
+            readonly duration: 0.46;
+            readonly ease: "power2.inOut";
+        };
+    };
+    readonly battleCurrentActor: {
+        readonly enterDurationMs: 280;
+        readonly enterOffsetPx: 4;
+        readonly breathePeriodMs: 2400;
+        readonly innerGlowAlpha: {
+            readonly min: 0.34;
+            readonly max: 0.58;
+        };
+    };
+};
+/** Existing battle effect timings stay explicit and do not become general UI values. */
+export declare const pixiCinematicTimings: {
+    readonly impact: 0.12;
+    readonly resource: 0.28;
+    readonly return: 0.22;
+};

package/dist/PixiObjectiveBreathingGlow.d.ts

@@ -0,0 +1,39 @@
+import type { Container } from 'pixi.js';
+export interface PixiObjectiveBreathingGlowConstructors {
+    Mesh?: typeof import('pixi.js').Mesh;
+    MeshGeometry?: typeof import('pixi.js').MeshGeometry;
+    Shader?: typeof import('pixi.js').Shader;
+    UniformGroup?: typeof import('pixi.js').UniformGroup;
+}
+export interface ObjectiveBreathingGlowLayout {
+    readonly width: number;
+    readonly height: number;
+    readonly cornerRadius: number;
+    readonly padding: number;
+    readonly coreWidth: number;
+    readonly softness: number;
+    readonly maxAlpha: number;
+    readonly maxScale: number;
+    readonly color: string;
+}
+/** One retained local shader surface for a map-objective cloud glow. */
+export declare class PixiObjectiveBreathingGlow {
+    private readonly constructors;
+    private mesh;
+    private geometry;
+    private shader;
+    private uniforms;
+    private surfaceHalfWidth;
+    private surfaceHalfHeight;
+    private maxAlpha;
+    private maxScale;
+    private highlightMultiplier;
+    constructor(constructors: PixiObjectiveBreathingGlowConstructors);
+    configure(parent: Container, layout: ObjectiveBreathingGlowLayout): void;
+    setFrame(breath: number, staticPresentation?: boolean): void;
+    setHighlightMultiplier(multiplier: number): void;
+    hide(): void;
+    destroy(): void;
+    private ensure;
+    private getUniformValues;
+}

package/dist/PixiPartyHudSurface.d.ts

@@ -0,0 +1,58 @@
+import type { ColorMatrixFilter, Container, Filter, Graphics, Sprite, Text, Texture, UniformGroup } from 'pixi.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import { type PortraitCardTextures, type InvestigatorDossierStatusEntry, type PixiPartyMemberState } from './PixiPortraitResourceCard.js';
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+import type { PortraitCardPorts } from './PixiPortraitResourceCard.js';
+import type { PixiSceneGraph } from './PixiSceneGraph.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+export type { PixiPartyMemberState } from './PixiPortraitResourceCard.js';
+export interface PreludeStoryPartyHudEntry {
+    readonly id: string;
+    readonly root: Container;
+    readonly targetX: number;
+    readonly targetY: number;
+}
+interface Constructors {
+    ColorMatrixFilter: typeof ColorMatrixFilter;
+    Container: typeof Container;
+    Filter: typeof Filter;
+    Graphics: typeof Graphics;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: new (options: import('pixi.js').TextOptions) => Text;
+    UniformGroup: typeof UniformGroup;
+}
+export declare class PixiPartyHudSurface {
+    private readonly assets;
+    private readonly constructors;
+    private readonly textures;
+    private readonly requestRender;
+    private readonly animation;
+    private readonly ports;
+    private readonly mediaBreath?;
+    readonly node: Container;
+    private readonly cards;
+    private readonly preludeStoryEntries;
+    private preludeStoryEntryActive;
+    private tuning;
+    private reducedMotion;
+    constructor(scene: PixiSceneGraph, assets: PixiAssetManager, constructors: Constructors, textures: PortraitCardTextures, requestRender: () => void, tuning: SessionTuningResolver | undefined, animation: PixiAnimationDirector, ports: {
+        card: PortraitCardPorts;
+        maxMembers: number;
+        resolveRects: (count: number) => readonly PixiLayoutRect[];
+    }, mediaBreath?: PixiMediaBreathRuntime | undefined);
+    sync(members: PixiPartyMemberState[], visible: boolean): void;
+    updateTuning(tuning: SessionTuningResolver | undefined): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    setEarthquakeTransform(x: number, y: number, rotation: number, scale: number): void;
+    previewResourceChange(): void;
+    previewStatus(status: InvestigatorDossierStatusEntry): void;
+    preparePreludeStoryEntry(): void;
+    getPreludeStoryEntries(): readonly PreludeStoryPartyHudEntry[];
+    restorePreludeStoryEntry(visible: boolean): void;
+    reset(): void;
+    destroy(): void;
+    private createCard;
+    private stagePreludeStoryCard;
+}

package/dist/PixiPersistentEffectTransition.d.ts

@@ -0,0 +1,23 @@
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+interface AlphaTarget {
+    alpha: number;
+}
+interface PixiPersistentEffectTransitionOptions {
+    readonly director: PixiAnimationDirector;
+    readonly getTuning: () => SessionTuningResolver | undefined;
+    readonly requestRender?: () => void;
+}
+/** Shared alpha envelope for retained Field and Global persistent effects. */
+export declare class PixiPersistentEffectTransition {
+    private readonly options;
+    private active;
+    constructor(options: PixiPersistentEffectTransitionOptions);
+    fadeIn(target: AlphaTarget, targetAlpha: number, signal: AbortSignal): Promise<boolean>;
+    fadeOut(target: AlphaTarget, targetAlpha: number, signal: AbortSignal): Promise<boolean>;
+    setReducedMotion(reducedMotion: boolean): void;
+    cancel(reason: string): void;
+    private transition;
+    private resolveDuration;
+}
+export {};

package/dist/PixiPortraitResourceCard.d.ts

@@ -0,0 +1,147 @@
+import type { RuntimeLogger } from '@bardway/trpg-media';
+export interface PortraitCardLayout {
+    cardWidth: number;
+    cardHeight: number;
+    portrait: PixiLayoutRect;
+    blood: {
+        x: number;
+        y: number;
+        size: number;
+    };
+    infoOffset: {
+        x: number;
+        y: number;
+    };
+    name: {
+        x: number;
+        y: number;
+        maxWidth: number;
+        minFontSize: number;
+        maxFontSize: number;
+    };
+    resources: {
+        labelX: number;
+        valueX: number;
+        valueYOffset: number;
+        rowY: number;
+        rowSpacing: number;
+        valueFontSize: number;
+        barX: number;
+        barYOffset: number;
+        barWidth: number;
+        barHeight: number;
+        tickCount: number;
+    };
+}
+export interface PortraitCardPorts {
+    logger: RuntimeLogger;
+    layout: PortraitCardLayout;
+    resourceSlots: number;
+    random(): number;
+    typography: ReturnType<typeof createPixiTypography>;
+    colors: {
+        mask: string;
+        paper: string;
+        paperEdge: string;
+    };
+    style: {
+        barBackground: string;
+        insanityTearGap: string;
+        name: string;
+        resourceDanger: string;
+        resourceFlash: string;
+        resourceNormal: string;
+        tick: string;
+    };
+}
+import type { ColorMatrixFilter, Container, Filter, Graphics, Sprite, Text, Texture, UniformGroup } from 'pixi.js';
+import type { TokenAvatarCrop } from './PixiMapWorldUtils.js';
+import { type PixiLayoutRect } from './PixiSessionLayout.js';
+import type { createPixiTypography } from './PixiTypography.js';
+import type { PixiAssetManager } from './PixiAssetManager.js';
+import type { PixiAnimationDirector } from './PixiAnimationDirector.js';
+import { type DossierInsanityMode } from './PixiInvestigatorDossierInsanityFilter.js';
+import type { SessionTuningResolver } from './tuning/SessionTuningResolver.js';
+import type { PixiMediaBreathRuntime } from './PixiMediaBreathRuntime.js';
+export interface PortraitResource {
+    id: string;
+    label: string;
+    current?: number;
+    maximum?: number;
+    color: string;
+}
+export interface PixiPartyMemberState {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+    avatarCrop?: TokenAvatarCrop;
+    resources: readonly PortraitResource[];
+    visualState: Partial<InvestigatorDossierStatus>;
+}
+export interface InvestigatorDossierStatus {
+    stain: boolean;
+    distorted: boolean;
+    grayscale: boolean;
+}
+export type InvestigatorDossierStatusEntry = 'stain' | 'distorted' | 'grayscale';
+export declare const resolveInvestigatorDossierStatus: (state: Partial<InvestigatorDossierStatus>) => InvestigatorDossierStatus;
+export declare const resolveInvestigatorDossierStatusEntry: (previous: InvestigatorDossierStatus, next: InvestigatorDossierStatus) => InvestigatorDossierStatusEntry | null;
+export declare const resolveDossierResourceValueColor: (ratio: number, normalColor: string, dangerColor: string) => string;
+export declare const fitDossierName: (name: string, maxCharacters: number) => string;
+export declare const resolveDossierTiltDegrees: (id: string) => number;
+export declare const resolveDossierInsanityMode: (value: unknown) => DossierInsanityMode;
+export declare const resolveDossierBloodRotationRadians: (random?: () => number) => number;
+export declare const resolveDossierBloodDisplaySize: (cardWidth: number, layout: PortraitCardLayout) => number;
+export declare const resolveDossierInsanitySeed: (random?: () => number) => number;
+interface Constructors {
+    ColorMatrixFilter: typeof ColorMatrixFilter;
+    Container: typeof Container;
+    Filter: typeof Filter;
+    Graphics: typeof Graphics;
+    Sprite: new (texture?: Texture | import('pixi.js').SpriteOptions) => Sprite;
+    Text: new (options: import('pixi.js').TextOptions) => Text;
+    UniformGroup: typeof UniformGroup;
+}
+export interface PortraitCardTextures {
+    background: Texture | null;
+    overlay: Texture | null;
+}
+export declare const resolveDossierNameColor: (tuning: SessionTuningResolver | undefined, fallback: string) => string;
+export declare class PixiPortraitResourceCard {
+    private readonly id;
+    private readonly assets;
+    private readonly constructors;
+    private readonly textures;
+    private readonly animation;
+    private readonly requestRender;
+    private readonly ports;
+    private readonly mediaBreath?;
+    private disposed;
+    private readonly resourceScope;
+    readonly root: Container;
+    private readonly node;
+    private tuning;
+    private reducedMotion;
+    constructor(id: string, assets: PixiAssetManager, constructors: Constructors, textures: PortraitCardTextures, animation: PixiAnimationDirector, requestRender: () => void, ports: PortraitCardPorts, mediaBreath?: PixiMediaBreathRuntime | undefined);
+    sync(member: PixiPartyMemberState, rect: PixiLayoutRect, tuning: SessionTuningResolver | undefined): void;
+    setReducedMotion(reducedMotion: boolean): void;
+    resetMotion(): void;
+    previewResourceChange(): void;
+    previewStatus(status: InvestigatorDossierStatusEntry): void;
+    destroy(): void;
+    private drawFallback;
+    private syncName;
+    private syncResources;
+    private syncBlood;
+    private syncAvatar;
+    private applyAvatarGeometry;
+    private syncInsanity;
+    private syncDeath;
+    private playStatusEntry;
+    private playMajorWoundEntry;
+    private playInsanityEntry;
+    private playDeathEntry;
+    private cancelStatusMotion;
+    private restoreStatusVisuals;
+}
+export {};

package/dist/PixiPreludeStoryTransition.d.ts

@@ -0,0 +1,35 @@
+import type { PixiLayoutRect } from './PixiSessionLayout.js';
+export interface PreludeStoryTransitionTiming {
+    readonly backgroundDarkenDuration: number;
+    readonly moduleTravelDelay: number;
+    readonly moduleTravelDuration: number;
+    readonly storyBaseRevealDuration: number;
+    readonly finalHandoffDuration: number;
+    readonly partyHudEnterDuration: number;
+    readonly partyHudMaxStagger: number;
+    readonly moduleTravelEase: string;
+    readonly hudEnterEase: string;
+}
+export declare const DEFAULT_PRELUDE_STORY_TRANSITION_TIMING: PreludeStoryTransitionTiming;
+export declare const resolvePreludeStoryTimeline: (timing: PreludeStoryTransitionTiming) => {
+    storyBaseRevealAt: number;
+    storyCommitAt: number;
+    completeAt: number;
+};
+export declare const resolvePreludeStoryModuleTarget: (aperture: {
+    readonly width: number;
+    readonly height: number;
+}, textureSize: {
+    readonly width: number;
+    readonly height: number;
+} | null, media: PixiLayoutRect) => {
+    rect: PixiLayoutRect;
+    x: number;
+    y: number;
+    scaleX: number;
+    scaleY: number;
+};
+export declare const resolvePreludeStoryPortraitOrder: <T extends {
+    readonly id: string;
+}>(entries: readonly T[]) => T[];
+export declare const resolvePreludeStoryPartyHudDelay: (id: string, maxDelay: number) => number;