@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,254 +0,0 @@
-import { EventEmitter } from 'events';
-export type EffectId = string;
-export type PresetId = string;
-export type LayerId = string;
-export interface ColorRGB {
-    r: number;
-    g: number;
-    b: number;
-}
-export interface ColorHSL {
-    h: number;
-    s: number;
-    l: number;
-}
-export type PostProcessEffectType = 'bloom' | 'color_grading' | 'motion_blur' | 'depth_of_field' | 'vignette' | 'chromatic_aberration' | 'film_grain' | 'lens_flare' | 'tone_mapping' | 'ambient_occlusion' | 'fog' | 'outline' | 'pixelate' | 'blur' | 'sharpen' | 'distortion' | 'color_blindness' | 'night_vision' | 'thermal_vision' | 'custom';
-export interface BloomParams {
-    intensity: number;
-    threshold: number;
-    softKnee: number;
-    radius: number;
-    scatter: number;
-    tintColor: ColorRGB;
-}
-export interface ColorGradingParams {
-    exposure: number;
-    contrast: number;
-    saturation: number;
-    temperature: number;
-    tint: number;
-    shadows: ColorRGB;
-    midtones: ColorRGB;
-    highlights: ColorRGB;
-    lift: number;
-    gamma: number;
-    gain: number;
-    hueShift: number;
-}
-export interface MotionBlurParams {
-    intensity: number;
-    sampleCount: number;
-    maxVelocity: number;
-    cameraMixed: number;
-}
-export interface DepthOfFieldParams {
-    focalDistance: number;
-    focalLength: number;
-    aperture: number;
-    nearBlurStart: number;
-    nearBlurEnd: number;
-    farBlurStart: number;
-    farBlurEnd: number;
-    bokehShape: 'circle' | 'hexagon' | 'octagon';
-    bokehIntensity: number;
-}
-export interface VignetteParams {
-    intensity: number;
-    smoothness: number;
-    roundness: number;
-    color: ColorRGB;
-    center: {
-        x: number;
-        y: number;
-    };
-}
-export interface ChromaticAberrationParams {
-    intensity: number;
-    redOffset: {
-        x: number;
-        y: number;
-    };
-    greenOffset: {
-        x: number;
-        y: number;
-    };
-    blueOffset: {
-        x: number;
-        y: number;
-    };
-}
-export interface FilmGrainParams {
-    intensity: number;
-    response: number;
-    size: number;
-    luminanceContribution: number;
-}
-export interface LensFlareParams {
-    intensity: number;
-    threshold: number;
-    ghostCount: number;
-    ghostSpacing: number;
-    ghostFade: number;
-    haloWidth: number;
-    haloFade: number;
-    tint: ColorRGB;
-}
-export interface ToneMappingParams {
-    mode: 'none' | 'aces' | 'reinhard' | 'filmic' | 'uncharted2';
-    whitePoint: number;
-    toeStrength: number;
-    toeLength: number;
-    shoulderStrength: number;
-    shoulderLength: number;
-}
-export interface AmbientOcclusionParams {
-    intensity: number;
-    radius: number;
-    quality: 'low' | 'medium' | 'high';
-    falloff: number;
-    directContribution: number;
-}
-export interface FogParams {
-    mode: 'linear' | 'exponential' | 'exponential2';
-    color: ColorRGB;
-    density: number;
-    nearDistance: number;
-    farDistance: number;
-    heightFalloff: number;
-    heightOffset: number;
-}
-export interface OutlineParams {
-    color: ColorRGB;
-    width: number;
-    depthSensitivity: number;
-    normalSensitivity: number;
-    colorSensitivity: number;
-}
-export interface PixelateParams {
-    pixelSize: number;
-    colorPalette?: ColorRGB[];
-}
-export interface BlurParams {
-    type: 'gaussian' | 'box' | 'radial' | 'directional';
-    intensity: number;
-    radius: number;
-    direction?: {
-        x: number;
-        y: number;
-    };
-    center?: {
-        x: number;
-        y: number;
-    };
-}
-export interface SharpenParams {
-    intensity: number;
-    threshold: number;
-}
-export interface DistortionParams {
-    type: 'barrel' | 'pincushion' | 'wave' | 'noise';
-    intensity: number;
-    frequency?: number;
-    amplitude?: number;
-    speed?: number;
-}
-export type EffectParams = BloomParams | ColorGradingParams | MotionBlurParams | DepthOfFieldParams | VignetteParams | ChromaticAberrationParams | FilmGrainParams | LensFlareParams | ToneMappingParams | AmbientOcclusionParams | FogParams | OutlineParams | PixelateParams | BlurParams | SharpenParams | DistortionParams | Record<string, unknown>;
-export interface PostProcessEffect {
-    id: EffectId;
-    type: PostProcessEffectType;
-    enabled: boolean;
-    priority: number;
-    layer: LayerId;
-    params: EffectParams;
-    blend: BlendSettings;
-    masks?: EffectMask[];
-    transitionState?: TransitionState;
-}
-export interface BlendSettings {
-    mode: 'normal' | 'additive' | 'multiply' | 'screen' | 'overlay';
-    opacity: number;
-}
-export interface EffectMask {
-    type: 'depth' | 'stencil' | 'texture' | 'radial';
-    invert: boolean;
-    params: Record<string, unknown>;
-}
-export interface TransitionState {
-    fromParams: EffectParams;
-    toParams: EffectParams;
-    progress: number;
-    duration: number;
-    easing: EasingType;
-}
-export type EasingType = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out';
-export interface EffectPreset {
-    id: PresetId;
-    name: string;
-    description?: string;
-    effects: {
-        type: PostProcessEffectType;
-        params: EffectParams;
-        priority?: number;
-    }[];
-}
-export type PostProcessEventType = 'effect-added' | 'effect-removed' | 'effect-enabled' | 'effect-disabled' | 'effect-updated' | 'preset-applied' | 'transition-started' | 'transition-completed' | 'layer-created' | 'layer-removed';
-export interface PostProcessEvent {
-    type: PostProcessEventType;
-    effectId?: EffectId;
-    presetId?: PresetId;
-    layerId?: LayerId;
-    data?: Record<string, unknown>;
-}
-export interface PostProcessSystemConfig {
-    maxEffects?: number;
-    defaultPriority?: number;
-    transitionDuration?: number;
-    enabledByDefault?: boolean;
-}
-export declare const DEFAULT_POSTPROCESS_CONFIG: PostProcessSystemConfig;
-export declare class NicePostProcess extends EventEmitter {
-    private effects;
-    private presets;
-    private layers;
-    private config;
-    private effectIdCounter;
-    private globalEnabled;
-    constructor(config?: Partial<PostProcessSystemConfig>);
-    private initializeBuiltInPresets;
-    addEffect(type: PostProcessEffectType, params?: Partial<EffectParams>, options?: {
-        layer?: LayerId;
-        priority?: number;
-        enabled?: boolean;
-        blend?: Partial<BlendSettings>;
-    }): EffectId;
-    removeEffect(effectId: EffectId): void;
-    getEffect(effectId: EffectId): PostProcessEffect | undefined;
-    getEffectsByType(type: PostProcessEffectType): PostProcessEffect[];
-    enableEffect(effectId: EffectId): void;
-    disableEffect(effectId: EffectId): void;
-    toggleEffect(effectId: EffectId): void;
-    setEffectParams(effectId: EffectId, params: Partial<EffectParams>): void;
-    setEffectPriority(effectId: EffectId, priority: number): void;
-    setEffectBlend(effectId: EffectId, blend: Partial<BlendSettings>): void;
-    transitionEffect(effectId: EffectId, toParams: Partial<EffectParams>, duration?: number, easing?: EasingType): void;
-    registerPreset(preset: EffectPreset): void;
-    getPreset(presetId: PresetId): EffectPreset | undefined;
-    listPresets(): EffectPreset[];
-    applyPreset(presetId: PresetId, layer?: LayerId): void;
-    createLayer(layerId: LayerId): void;
-    removeLayer(layerId: LayerId): void;
-    clearLayer(layerId: LayerId): void;
-    getLayerEffects(layerId: LayerId): PostProcessEffect[];
-    private sortLayerEffects;
-    setGlobalEnabled(enabled: boolean): void;
-    isGlobalEnabled(): boolean;
-    update(deltaTime: number): void;
-    private updateTransition;
-    private applyEasing;
-    private interpolateParams;
-    getActiveEffects(): PostProcessEffect[];
-    private getDefaultParams;
-}
-export declare function createPostProcessSystem(config?: Partial<PostProcessSystemConfig>): NicePostProcess;
-export declare function defineEffectPreset(options: EffectPreset): EffectPreset;
-export default NicePostProcess;

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

@@ -1,202 +0,0 @@
-export type SeedValue = number | string;
-export interface Vec2 {
-    x: number;
-    y: number;
-}
-export interface Vec3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export declare class SeededRandom {
-    private seed;
-    private state;
-    constructor(seed?: SeedValue);
-    private hashString;
-    /** Get next random number (0-1) */
-    next(): number;
-    /** Random integer in range [min, max] */
-    int(min: number, max: number): number;
-    /** Random float in range [min, max) */
-    float(min: number, max: number): number;
-    /** Random boolean with probability */
-    bool(probability?: number): boolean;
-    /** Pick random element from array */
-    pick<T>(array: T[]): T;
-    /** Shuffle array in place */
-    shuffle<T>(array: T[]): T[];
-    /** Weighted random selection */
-    weighted<T>(items: Array<{
-        item: T;
-        weight: number;
-    }>): T;
-    /** Reset to initial seed */
-    reset(): void;
-    /** Get current seed */
-    getSeed(): number;
-    /** Set new seed */
-    setSeed(seed: SeedValue): void;
-}
-export declare class PerlinNoise {
-    private permutation;
-    private p;
-    constructor(seed?: number);
-    private fade;
-    private lerp;
-    private grad;
-    /** 2D Perlin noise */
-    noise2D(x: number, y: number): number;
-    /** 3D Perlin noise */
-    noise3D(x: number, y: number, z: number): number;
-    /** Fractal Brownian Motion (octaves) */
-    fbm(x: number, y: number, octaves?: number, lacunarity?: number, persistence?: number): number;
-}
-export declare class WorleyNoise {
-    private rng;
-    constructor(seed?: number);
-    private hash;
-    noise2D(x: number, y: number, numPoints?: number): number;
-}
-export interface DungeonRoom {
-    id: number;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    connections: number[];
-    type: 'normal' | 'start' | 'end' | 'boss' | 'treasure' | 'secret';
-}
-export interface DungeonCorridor {
-    from: number;
-    to: number;
-    points: Vec2[];
-}
-export interface DungeonConfig {
-    width: number;
-    height: number;
-    minRoomSize: number;
-    maxRoomSize: number;
-    roomCount: number;
-    corridorWidth: number;
-    seed?: SeedValue;
-}
-export interface DungeonResult {
-    rooms: DungeonRoom[];
-    corridors: DungeonCorridor[];
-    grid: number[][];
-    startRoom: number;
-    endRoom: number;
-}
-export declare class DungeonGenerator {
-    private config;
-    private rng;
-    constructor(config: DungeonConfig);
-    generate(): DungeonResult;
-    private generateRooms;
-    private roomsOverlap;
-    private connectRooms;
-    private roomDistance;
-    private createCorridor;
-    private createGrid;
-    private drawLine;
-}
-export interface MazeConfig {
-    width: number;
-    height: number;
-    seed?: SeedValue;
-    algorithm?: 'recursive-backtrack' | 'prims' | 'kruskal';
-}
-export declare class MazeGenerator {
-    private config;
-    private rng;
-    constructor(config: MazeConfig);
-    generate(): number[][];
-    private generateRecursiveBacktrack;
-    private generatePrims;
-    private addWalls;
-    private generateKruskal;
-}
-export interface NameGeneratorConfig {
-    syllables?: {
-        start: string[];
-        middle: string[];
-        end: string[];
-    };
-    minLength?: number;
-    maxLength?: number;
-    seed?: SeedValue;
-}
-export declare class NameGenerator {
-    private rng;
-    private config;
-    private static DEFAULT_SYLLABLES;
-    constructor(config?: NameGeneratorConfig);
-    generate(): string;
-    generateMultiple(count: number): string[];
-}
-export interface HeightmapConfig {
-    width: number;
-    height: number;
-    scale?: number;
-    octaves?: number;
-    persistence?: number;
-    lacunarity?: number;
-    seed?: SeedValue;
-}
-export declare class HeightmapGenerator {
-    private noise;
-    private config;
-    constructor(config: HeightmapConfig);
-    generate(): number[][];
-    generateIsland(): number[][];
-}
-export interface WFCTile {
-    id: string;
-    weight: number;
-    adjacencies: {
-        up: string[];
-        down: string[];
-        left: string[];
-        right: string[];
-    };
-}
-export interface WFCConfig {
-    width: number;
-    height: number;
-    tiles: WFCTile[];
-    seed?: SeedValue;
-}
-export declare class WaveFunctionCollapse {
-    private config;
-    private rng;
-    private grid;
-    private tileMap;
-    constructor(config: WFCConfig);
-    generate(): string[][] | null;
-    private initialize;
-    private isCollapsed;
-    private findLowestEntropy;
-    private collapse;
-    private propagate;
-    private getResult;
-}
-export declare class NiceProcedural {
-    private rng;
-    private noise;
-    private worley;
-    constructor(seed?: SeedValue);
-    random(): SeededRandom;
-    perlin2D(x: number, y: number): number;
-    perlin3D(x: number, y: number, z: number): number;
-    fbm(x: number, y: number, octaves?: number): number;
-    cellular(x: number, y: number): number;
-    dungeon(config: DungeonConfig): DungeonResult;
-    maze(config: MazeConfig): number[][];
-    heightmap(config: HeightmapConfig): number[][];
-    island(config: HeightmapConfig): number[][];
-    name(config?: NameGeneratorConfig): string;
-    names(count: number, config?: NameGeneratorConfig): string[];
-    wfc(config: WFCConfig): string[][] | null;
-    setSeed(seed: SeedValue): void;
-}
-export declare function createProceduralSystem(seed?: SeedValue): NiceProcedural;

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

@@ -1,223 +0,0 @@
-export type ProfileId = string;
-export type BadgeId = string;
-export type TitleId = string;
-export type AvatarId = string;
-export interface PlayerProfile {
-    id: ProfileId;
-    username: string;
-    displayName: string;
-    email?: string;
-    avatar?: AvatarId;
-    title?: TitleId;
-    bio?: string;
-    country?: string;
-    createdAt: number;
-    lastLoginAt: number;
-    lastActivityAt: number;
-    isOnline: boolean;
-    visibility: ProfileVisibility;
-    progression: ProfileProgression;
-    statistics: ProfileStatistics;
-    customization: ProfileCustomization;
-    preferences: ProfilePreferences;
-    badges: ProfileBadge[];
-    titles: ProfileTitle[];
-    playHistory: PlaySession[];
-}
-export type ProfileVisibility = 'public' | 'friends' | 'private';
-export interface ProfileProgression {
-    level: number;
-    experience: number;
-    experienceToNext: number;
-    totalExperience: number;
-    prestige: number;
-    rank?: string;
-    tier?: number;
-    seasonLevel?: number;
-    seasonExperience?: number;
-}
-export interface LevelConfig {
-    level: number;
-    experienceRequired: number;
-    rewards?: LevelReward[];
-}
-export interface LevelReward {
-    type: 'badge' | 'title' | 'currency' | 'item' | 'unlock';
-    id: string;
-    amount?: number;
-}
-export interface ProfileStatistics {
-    gamesPlayed: number;
-    gamesWon: number;
-    gamesLost: number;
-    gamesTied: number;
-    totalPlayTime: number;
-    highestScore: number;
-    totalScore: number;
-    kills: number;
-    deaths: number;
-    assists: number;
-    customStats: Record<string, number>;
-    achievementsUnlocked: number;
-    achievementsTotal: number;
-}
-export interface ProfileCustomization {
-    avatarId?: AvatarId;
-    frameId?: string;
-    bannerId?: string;
-    themeId?: string;
-    colorScheme?: string;
-    equippedItems?: string[];
-    showcase?: ShowcaseItem[];
-}
-export interface ShowcaseItem {
-    type: 'badge' | 'achievement' | 'item' | 'stat';
-    id: string;
-    position: number;
-}
-export interface ProfilePreferences {
-    language: string;
-    region?: string;
-    timezone?: string;
-    notifications: NotificationPreferences;
-    privacy: PrivacyPreferences;
-    gameplay: GameplayPreferences;
-}
-export interface NotificationPreferences {
-    friendRequests: boolean;
-    gameInvites: boolean;
-    achievements: boolean;
-    news: boolean;
-    marketing: boolean;
-}
-export interface PrivacyPreferences {
-    showOnlineStatus: boolean;
-    showPlayActivity: boolean;
-    showStatistics: boolean;
-    allowFriendRequests: boolean;
-    allowMessages: boolean;
-}
-export interface GameplayPreferences {
-    autoMatchmaking: boolean;
-    preferredGameModes: string[];
-    difficultyPreference?: string;
-    tutorialCompleted: boolean;
-}
-export interface ProfileBadge {
-    id: BadgeId;
-    name: string;
-    description: string;
-    icon: string;
-    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-    earnedAt: number;
-    isEquipped: boolean;
-    category?: string;
-}
-export interface ProfileTitle {
-    id: TitleId;
-    name: string;
-    description?: string;
-    earnedAt: number;
-    isEquipped: boolean;
-    rarity?: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-}
-export interface PlaySession {
-    sessionId: string;
-    startTime: number;
-    endTime: number;
-    duration: number;
-    gameMode?: string;
-    mapId?: string;
-    score?: number;
-    result?: 'win' | 'loss' | 'draw' | 'incomplete';
-    experienceGained: number;
-    statistics?: Record<string, number>;
-}
-export type ProfileEventType = 'profile-created' | 'profile-updated' | 'profile-loaded' | 'level-up' | 'prestige-up' | 'experience-gained' | 'badge-earned' | 'badge-equipped' | 'title-earned' | 'title-equipped' | 'stat-updated' | 'session-started' | 'session-ended' | 'preference-changed' | 'customization-changed';
-export interface ProfileEvent {
-    type: ProfileEventType;
-    timestamp: number;
-    profileId: ProfileId;
-    data?: unknown;
-}
-export type ProfileEventCallback = (event: ProfileEvent) => void;
-export interface ProfileConfig {
-    /** Storage key prefix */
-    storagePrefix: string;
-    /** Max play history entries */
-    maxHistoryEntries: number;
-    /** Experience curve type */
-    experienceCurve: 'linear' | 'exponential' | 'custom';
-    /** Base experience for level 2 */
-    baseExperience: number;
-    /** Experience scaling factor */
-    experienceScale: number;
-    /** Max level (0 = unlimited) */
-    maxLevel: number;
-    /** Enable prestige system */
-    enablePrestige: boolean;
-    /** Max prestige level */
-    maxPrestige: number;
-    /** Max badges to equip */
-    maxEquippedBadges: number;
-    /** Auto-save interval (ms, 0 = disabled) */
-    autoSaveInterval: number;
-}
-export declare const DEFAULT_PROFILE_CONFIG: ProfileConfig;
-export declare class NiceProfile {
-    private config;
-    private profiles;
-    private activeProfileId?;
-    private levelConfigs;
-    private availableBadges;
-    private availableTitles;
-    private autoSaveTimer?;
-    private currentSession?;
-    private sessionStartTime;
-    private eventListeners;
-    constructor(config?: Partial<ProfileConfig>);
-    on(event: ProfileEventType, callback: ProfileEventCallback): () => void;
-    private emit;
-    private generateLevelConfigs;
-    setLevelConfigs(configs: LevelConfig[]): void;
-    getExperienceForLevel(level: number): number;
-    getLevelForExperience(totalExp: number): number;
-    private setupAutoSave;
-    createProfile(id: ProfileId, username: string, options?: Partial<PlayerProfile>): PlayerProfile;
-    getProfile(id: ProfileId): PlayerProfile | undefined;
-    getActiveProfile(): PlayerProfile | undefined;
-    setActiveProfile(id: ProfileId): boolean;
-    updateProfile(id: ProfileId, updates: Partial<PlayerProfile>): void;
-    deleteProfile(id: ProfileId): void;
-    addExperience(profileId: ProfileId, amount: number): number;
-    private grantLevelRewards;
-    prestige(profileId: ProfileId): boolean;
-    updateStat(profileId: ProfileId, stat: keyof ProfileStatistics | string, value: number, operation?: 'set' | 'add' | 'max'): void;
-    getStat(profileId: ProfileId, stat: string): number;
-    registerBadge(badge: Omit<ProfileBadge, 'earnedAt' | 'isEquipped'>): void;
-    awardBadge(profileId: ProfileId, badgeId: BadgeId): boolean;
-    equipBadge(profileId: ProfileId, badgeId: BadgeId): boolean;
-    getEquippedBadges(profileId: ProfileId): ProfileBadge[];
-    registerTitle(title: Omit<ProfileTitle, 'earnedAt' | 'isEquipped'>): void;
-    awardTitle(profileId: ProfileId, titleId: TitleId): boolean;
-    equipTitle(profileId: ProfileId, titleId: TitleId): boolean;
-    startSession(profileId: ProfileId, options?: {
-        gameMode?: string;
-        mapId?: string;
-    }): string;
-    endSession(profileId: ProfileId, result?: {
-        score?: number;
-        result?: 'win' | 'loss' | 'draw' | 'incomplete';
-        experienceGained?: number;
-        statistics?: Record<string, number>;
-    }): PlaySession | null;
-    getCurrentSession(): PlaySession | undefined;
-    getPlayHistory(profileId: ProfileId, limit?: number): PlaySession[];
-    updatePreference<K extends keyof ProfilePreferences>(profileId: ProfileId, category: K, updates: Partial<ProfilePreferences[K]>): void;
-    updateCustomization(profileId: ProfileId, updates: Partial<ProfileCustomization>): void;
-    save(profileId: ProfileId): boolean;
-    saveAll(): void;
-    load(profileId: ProfileId): PlayerProfile | null;
-    destroy(): void;
-}
-export declare function createProfileSystem(config?: Partial<ProfileConfig>): NiceProfile;