@nice2dev/game-engine 1.0.28 → 1.1.6

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

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

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

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