@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,112 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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

@@ -1,235 +0,0 @@
-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;