@nice2dev/game-engine 1.1.5 → 1.1.6

package/dist/types/systems/NiceSceneManager.d.ts

@@ -0,0 +1,112 @@
+export type SceneId = string;
+export type SceneGroupId = string;
+export type SceneState = 'unloaded' | 'loading' | 'loaded' | 'active' | 'unloading' | 'paused';
+export interface SceneDefinition {
+    id: SceneId;
+    name: string;
+    /** Scene group */
+    group?: SceneGroupId;
+    /** Assets to preload */
+    assets?: string[];
+    /** Persistent between loads */
+    persistent?: boolean;
+    /** Dependencies (load these first) */
+    dependencies?: SceneId[];
+    /** Custom data */
+    metadata?: Record<string, unknown>;
+    /** Lifecycle callbacks */
+    onLoad?: (scene: SceneInstance) => void | Promise<void>;
+    onUnload?: (scene: SceneInstance) => void | Promise<void>;
+    onActivate?: (scene: SceneInstance) => void;
+    onDeactivate?: (scene: SceneInstance) => void;
+    onUpdate?: (scene: SceneInstance, deltaTime: number) => void;
+}
+export interface SceneInstance {
+    definition: SceneDefinition;
+    state: SceneState;
+    loadProgress: number;
+    loadTime?: number;
+    activatedAt?: number;
+    data: Record<string, unknown>;
+}
+export type TransitionType = 'none' | 'fade' | 'crossfade' | 'slide-left' | 'slide-right' | 'slide-up' | 'slide-down' | 'zoom' | 'custom';
+export interface SceneTransition {
+    type: TransitionType;
+    duration: number;
+    easing?: string;
+    color?: string;
+    customRender?: (progress: number, fromScene?: SceneId, toScene?: SceneId) => void;
+}
+export declare const DEFAULT_TRANSITION: SceneTransition;
+export interface LoadingScreen {
+    render: (progress: number, sceneName: string) => void;
+    minDisplayTime?: number;
+}
+export type SceneEventType = 'scene-registered' | 'scene-load-start' | 'scene-load-progress' | 'scene-load-complete' | 'scene-activated' | 'scene-deactivated' | 'scene-unload-start' | 'scene-unload-complete' | 'transition-start' | 'transition-complete' | 'error';
+export interface SceneEvent {
+    type: SceneEventType;
+    timestamp: number;
+    sceneId?: SceneId;
+    data?: unknown;
+}
+export type SceneEventCallback = (event: SceneEvent) => void;
+export interface SceneManagerConfig {
+    /** Default transition */
+    defaultTransition: SceneTransition;
+    /** Loading screen */
+    loadingScreen?: LoadingScreen;
+    /** Auto-unload inactive scenes */
+    autoUnload: boolean;
+    /** Max scenes in memory */
+    maxLoadedScenes: number;
+    /** Preload next scene */
+    preloadNext: boolean;
+}
+export declare const DEFAULT_SCENE_CONFIG: SceneManagerConfig;
+export declare class NiceScene {
+    private config;
+    private definitions;
+    private instances;
+    private groups;
+    private sceneStack;
+    private activeScene;
+    private persistentObjects;
+    private eventListeners;
+    private transitioning;
+    private transitionProgress;
+    constructor(config?: Partial<SceneManagerConfig>);
+    on(event: SceneEventType, callback: SceneEventCallback): () => void;
+    private emit;
+    register(definition: SceneDefinition): void;
+    registerMany(definitions: SceneDefinition[]): void;
+    load(sceneId: SceneId): Promise<SceneInstance>;
+    private simulateAssetLoad;
+    preload(sceneId: SceneId): Promise<void>;
+    activate(sceneId: SceneId, transition?: SceneTransition): Promise<void>;
+    private deactivate;
+    unload(sceneId: SceneId): Promise<void>;
+    private checkAutoUnload;
+    private performTransition;
+    isTransitioning(): boolean;
+    getTransitionProgress(): number;
+    push(sceneId: SceneId, transition?: SceneTransition): Promise<void>;
+    pop(transition?: SceneTransition): Promise<SceneId | null>;
+    replace(sceneId: SceneId, transition?: SceneTransition): Promise<void>;
+    update(deltaTime: number): void;
+    getActiveScene(): SceneId | null;
+    getActiveInstance(): SceneInstance | undefined;
+    getInstance(sceneId: SceneId): SceneInstance | undefined;
+    getSceneStack(): SceneId[];
+    isLoaded(sceneId: SceneId): boolean;
+    getLoadedScenes(): SceneId[];
+    getScenesByGroup(groupId: SceneGroupId): SceneId[];
+    markPersistent(objectId: string): void;
+    unmarkPersistent(objectId: string): void;
+    isPersistent(objectId: string): boolean;
+    getPersistentObjects(): string[];
+    setSceneData(sceneId: SceneId, key: string, value: unknown): void;
+    getSceneData<T = unknown>(sceneId: SceneId, key: string): T | undefined;
+    unloadAll(): Promise<void>;
+    destroy(): void;
+}
+export declare function createSceneManager(config?: Partial<SceneManagerConfig>): NiceScene;

package/dist/types/systems/NiceScore.d.ts

@@ -0,0 +1,186 @@
+export type ScoreboardId = string;
+export type PlayerId = string;
+export interface ScoreEntry {
+    playerId: PlayerId;
+    playerName: string;
+    score: number;
+    timestamp: number;
+    stats?: Record<string, number>;
+    metadata?: Record<string, unknown>;
+}
+export interface ComboState {
+    count: number;
+    multiplier: number;
+    maxCount: number;
+    timer: number;
+    timeout: number;
+    active: boolean;
+    lastActionTime: number;
+    category?: string;
+}
+export type MultiplierType = 'additive' | 'multiplicative';
+export interface ScoreMultiplier {
+    id: string;
+    name: string;
+    value: number;
+    type: MultiplierType;
+    duration?: number;
+    startTime?: number;
+    source?: string;
+    stackable: boolean;
+    maxStacks?: number;
+    currentStacks: number;
+}
+export interface ScorePopup {
+    id: string;
+    value: number;
+    text?: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    color?: string;
+    size?: 'small' | 'medium' | 'large';
+    duration: number;
+    startTime: number;
+    opacity: number;
+    offsetY: number;
+}
+export interface PlayerScoreState {
+    playerId: PlayerId;
+    score: number;
+    displayScore: number;
+    combo: ComboState;
+    multipliers: Map<string, ScoreMultiplier>;
+    totalMultiplier: number;
+    statistics: ScoreStatistics;
+    bonuses: Map<string, number>;
+}
+export interface ScoreStatistics {
+    totalPointsEarned: number;
+    highestScore: number;
+    highestCombo: number;
+    highestMultiplier: number;
+    gamesPlayed: number;
+    totalPlayTime: number;
+    averageScore: number;
+    pointsPerMinute: number;
+    customStats: Record<string, number>;
+}
+export interface ScoreAction {
+    type: string;
+    basePoints: number;
+    multiplierCategories?: string[];
+    comboCategory?: string;
+    bonusConditions?: Array<{
+        condition: () => boolean;
+        bonus: number;
+        name: string;
+    }>;
+}
+export type ScoreEventType = 'score-added' | 'score-subtracted' | 'score-set' | 'combo-started' | 'combo-increased' | 'combo-ended' | 'combo-milestone' | 'multiplier-added' | 'multiplier-removed' | 'multiplier-expired' | 'bonus-awarded' | 'high-score' | 'popup-created' | 'popup-removed';
+export interface ScoreEvent {
+    type: ScoreEventType;
+    timestamp: number;
+    playerId?: PlayerId;
+    data?: unknown;
+}
+export type ScoreEventCallback = (event: ScoreEvent) => void;
+export interface ScoreConfig {
+    /** Base combo timeout in seconds */
+    comboTimeout: number;
+    /** Combo multiplier formula: base + (count * increment) */
+    comboMultiplierBase: number;
+    comboMultiplierIncrement: number;
+    comboMultiplierMax: number;
+    /** Combo milestones for special effects */
+    comboMilestones: number[];
+    /** Score animation speed */
+    scoreAnimationSpeed: number;
+    /** Popup duration */
+    popupDuration: number;
+    /** Enable popups */
+    enablePopups: boolean;
+    /** Storage key */
+    storageKey: string;
+    /** Max high scores stored */
+    maxHighScores: number;
+}
+export declare const DEFAULT_SCORE_CONFIG: ScoreConfig;
+export declare class NiceScore {
+    private config;
+    private players;
+    private activePopups;
+    private scoreActions;
+    private highScores;
+    private popupIdCounter;
+    private eventListeners;
+    constructor(config?: Partial<ScoreConfig>);
+    on(event: ScoreEventType, callback: ScoreEventCallback): () => void;
+    private emit;
+    registerPlayer(playerId: PlayerId): void;
+    unregisterPlayer(playerId: PlayerId): void;
+    getPlayer(playerId: PlayerId): PlayerScoreState | undefined;
+    registerAction(action: ScoreAction & {
+        id: string;
+    }): void;
+    executeAction(playerId: PlayerId, actionId: string, position?: {
+        x: number;
+        y: number;
+    }): number;
+    addScore(playerId: PlayerId, basePoints: number, options?: {
+        position?: {
+            x: number;
+            y: number;
+        };
+        comboCategory?: string;
+        multiplierCategories?: string[];
+        bonusConditions?: Array<{
+            condition: () => boolean;
+            bonus: number;
+            name: string;
+        }>;
+        actionType?: string;
+        showPopup?: boolean;
+    }): number;
+    subtractScore(playerId: PlayerId, points: number): void;
+    setScore(playerId: PlayerId, score: number): void;
+    getScore(playerId: PlayerId): number;
+    getDisplayScore(playerId: PlayerId): number;
+    resetScore(playerId: PlayerId): void;
+    incrementCombo(playerId: PlayerId, category?: string): void;
+    breakCombo(playerId: PlayerId): void;
+    getCombo(playerId: PlayerId): ComboState | undefined;
+    addMultiplier(playerId: PlayerId, multiplier: Omit<ScoreMultiplier, 'currentStacks'>): void;
+    removeMultiplier(playerId: PlayerId, multiplierId: string): void;
+    private recalculateTotalMultiplier;
+    getMultipliers(playerId: PlayerId): ScoreMultiplier[];
+    getTotalMultiplier(playerId: PlayerId): number;
+    createPopup(value: number, position: {
+        x: number;
+        y: number;
+    }, options?: {
+        text?: string;
+        color?: string;
+        size?: 'small' | 'medium' | 'large';
+        duration?: number;
+        combo?: number;
+    }): string;
+    removePopup(popupId: string): void;
+    getActivePopups(): ScorePopup[];
+    update(deltaTime: number): void;
+    submitHighScore(playerId: PlayerId, playerName: string, stats?: Record<string, number>, metadata?: Record<string, unknown>): boolean;
+    getHighScores(): ScoreEntry[];
+    getRank(score: number): number;
+    isHighScore(score: number): boolean;
+    clearHighScores(): void;
+    getStatistics(playerId: PlayerId): ScoreStatistics | undefined;
+    incrementStat(playerId: PlayerId, statName: string, value?: number): void;
+    endSession(playerId: PlayerId, playTime: number): void;
+    private loadHighScores;
+    private saveHighScores;
+    savePlayerStats(playerId: PlayerId): void;
+    loadPlayerStats(playerId: PlayerId): ScoreStatistics | null;
+    destroy(): void;
+}
+export declare function createScoreSystem(config?: Partial<ScoreConfig>): NiceScore;

package/dist/types/systems/NiceScreenFX.d.ts

@@ -0,0 +1,235 @@
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+}
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export type EaseFunction = (t: number) => number;
+export type ScreenEffectType = 'shake' | 'flash' | 'fade' | 'vignette' | 'chromatic' | 'blur' | 'freeze' | 'distort' | 'colorGrade' | 'scanlines' | 'pixelate' | 'filmGrain';
+export interface BaseEffect {
+    id: string;
+    type: ScreenEffectType;
+    startTime: number;
+    duration: number;
+    intensity: number;
+    isActive: boolean;
+    priority: number;
+    layer: number;
+}
+export interface ShakeEffect extends BaseEffect {
+    type: 'shake';
+    amplitude: number;
+    frequency: number;
+    decay: number;
+    direction?: Vec2;
+    offset: Vec2;
+    rotation: number;
+    trauma: number;
+}
+export interface FlashEffect extends BaseEffect {
+    type: 'flash';
+    color: Color;
+    fadeIn: number;
+    fadeOut: number;
+    currentAlpha: number;
+}
+export interface FadeEffect extends BaseEffect {
+    type: 'fade';
+    color: Color;
+    fadeIn: boolean;
+    currentAlpha: number;
+}
+export interface VignetteEffect extends BaseEffect {
+    type: 'vignette';
+    radius: number;
+    softness: number;
+    color: Color;
+}
+export interface ChromaticEffect extends BaseEffect {
+    type: 'chromatic';
+    offset: number;
+    angle: number;
+}
+export interface BlurEffect extends BaseEffect {
+    type: 'blur';
+    radius: number;
+    direction?: Vec2;
+    isRadial: boolean;
+    center?: Vec2;
+}
+export interface FreezeEffect extends BaseEffect {
+    type: 'freeze';
+    desaturate: number;
+    zoom: number;
+    slowMotion: number;
+}
+export interface DistortEffect extends BaseEffect {
+    type: 'distort';
+    center: Vec2;
+    radius: number;
+    strength: number;
+    wave?: {
+        amplitude: number;
+        frequency: number;
+    };
+}
+export interface ColorGradeEffect extends BaseEffect {
+    type: 'colorGrade';
+    brightness: number;
+    contrast: number;
+    saturation: number;
+    hueShift: number;
+    tint: Color;
+}
+export interface ScanlinesEffect extends BaseEffect {
+    type: 'scanlines';
+    spacing: number;
+    thickness: number;
+    opacity: number;
+    speed: number;
+    phase: number;
+}
+export interface PixelateEffect extends BaseEffect {
+    type: 'pixelate';
+    pixelSize: number;
+    targetSize: number;
+}
+export interface FilmGrainEffect extends BaseEffect {
+    type: 'filmGrain';
+    amount: number;
+    speed: number;
+    luminanceOnly: boolean;
+}
+export type ScreenEffect = ShakeEffect | FlashEffect | FadeEffect | VignetteEffect | ChromaticEffect | BlurEffect | FreezeEffect | DistortEffect | ColorGradeEffect | ScanlinesEffect | PixelateEffect | FilmGrainEffect;
+export interface ScreenState {
+    offset: Vec2;
+    rotation: number;
+    scale: number;
+    alpha: number;
+    overlayColor: Color | null;
+    blurAmount: number;
+    chromaticOffset: number;
+    saturation: number;
+    brightness: number;
+    contrast: number;
+    hueShift: number;
+    vignetteIntensity: number;
+    pixelSize: number;
+    scanlinePhase: number;
+    grainAmount: number;
+}
+export type ScreenFXEventType = 'effect-start' | 'effect-end' | 'effect-update' | 'shake-trigger' | 'flash-trigger' | 'freeze-start' | 'freeze-end' | 'transition-start' | 'transition-mid' | 'transition-end';
+export interface ScreenFXEvent {
+    type: ScreenFXEventType;
+    timestamp: number;
+    effectId?: string;
+    data: unknown;
+}
+export type ScreenFXEventCallback = (event: ScreenFXEvent) => void;
+export interface ScreenFXConfig {
+    /** Maximum shake amplitude */
+    maxShakeAmplitude: number;
+    /** Maximum trauma value */
+    maxTrauma: number;
+    /** Trauma decay rate */
+    traumaDecay: number;
+    /** Default effect duration */
+    defaultDuration: number;
+    /** Default flash duration */
+    flashDuration: number;
+    /** Default fade duration */
+    fadeDuration: number;
+    /** Default freeze duration */
+    freezeDuration: number;
+    /** Enable shake */
+    enableShake: boolean;
+    /** Enable post effects */
+    enablePostEffects: boolean;
+}
+export declare const DEFAULT_SCREENFX_CONFIG: ScreenFXConfig;
+export declare class NiceScreenFX {
+    private config;
+    private effects;
+    private state;
+    private currentTime;
+    private eventListeners;
+    private nextId;
+    private noise;
+    constructor(config?: Partial<ScreenFXConfig>);
+    on(event: ScreenFXEventType, callback: ScreenFXEventCallback): () => void;
+    private emit;
+    shake(amplitude: number, duration: number, options?: {
+        frequency?: number;
+        decay?: number;
+        direction?: Vec2;
+    }): string;
+    addTrauma(amount: number): void;
+    private updateShake;
+    flash(color: Color, duration?: number, options?: {
+        fadeIn?: number;
+        fadeOut?: number;
+        intensity?: number;
+    }): string;
+    private updateFlash;
+    fadeIn(duration?: number, color?: Color): string;
+    fadeOut(duration?: number, color?: Color): string;
+    private createFade;
+    private updateFade;
+    vignette(intensity: number, duration: number, options?: {
+        radius?: number;
+        softness?: number;
+        color?: Color;
+    }): string;
+    chromatic(offset: number, duration: number, options?: {
+        angle?: number;
+    }): string;
+    blur(radius: number, duration: number, options?: {
+        direction?: Vec2;
+        isRadial?: boolean;
+        center?: Vec2;
+    }): string;
+    freeze(duration?: number, options?: {
+        desaturate?: number;
+        zoom?: number;
+        slowMotion?: number;
+    }): string;
+    colorGrade(settings: Partial<{
+        brightness: number;
+        contrast: number;
+        saturation: number;
+        hueShift: number;
+        tint: Color;
+    }>, duration: number): string;
+    scanlines(opacity: number, duration: number, options?: {
+        spacing?: number;
+        thickness?: number;
+        speed?: number;
+    }): string;
+    pixelate(pixelSize: number, duration: number): string;
+    filmGrain(amount: number, duration: number, options?: {
+        speed?: number;
+        luminanceOnly?: boolean;
+    }): string;
+    stopEffect(id: string): void;
+    stopAllEffects(): void;
+    stopEffectsByType(type: ScreenEffectType): void;
+    getEffect(id: string): ScreenEffect | undefined;
+    update(deltaTime: number): ScreenState;
+    private updateEffect;
+    private applyEffect;
+    private resetState;
+    getState(): ScreenState;
+    getActiveEffects(): ScreenEffect[];
+    isEffectActive(type: ScreenEffectType): boolean;
+    getTimeScale(): number;
+    impact(intensity?: number): void;
+    explosion(distance?: number): void;
+    hit(): void;
+    death(): void;
+    destroy(): void;
+}
+export declare function createScreenFXSystem(config?: Partial<ScreenFXConfig>): NiceScreenFX;