@nice2dev/game-engine 1.1.5 → 1.1.6

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

@@ -0,0 +1,180 @@
+export type ReplayId = string;
+export type EntityId = string;
+export interface InputEvent {
+    type: string;
+    timestamp: number;
+    frame: number;
+    data: unknown;
+}
+export interface EntityState {
+    id: EntityId;
+    type: string;
+    position?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    rotation?: number;
+    velocity?: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    health?: number;
+    animation?: string;
+    customData?: Record<string, unknown>;
+}
+export interface ReplayFrame {
+    frameNumber: number;
+    timestamp: number;
+    deltaTime: number;
+    entities: EntityState[];
+    inputs: InputEvent[];
+    events: Array<{
+        type: string;
+        data: unknown;
+    }>;
+    customData?: Record<string, unknown>;
+}
+export interface ReplaySnapshot {
+    frameNumber: number;
+    timestamp: number;
+    fullState: {
+        entities: EntityState[];
+        customData: Record<string, unknown>;
+    };
+}
+export interface ReplayMetadata {
+    id: ReplayId;
+    name: string;
+    description?: string;
+    createdAt: number;
+    duration: number;
+    frameCount: number;
+    version: string;
+    gameMode?: string;
+    mapId?: string;
+    players?: Array<{
+        id: string;
+        name: string;
+        team?: string;
+    }>;
+    tags?: string[];
+    thumbnail?: string;
+    fileSize?: number;
+}
+export interface ReplayData {
+    metadata: ReplayMetadata;
+    frames: ReplayFrame[];
+    snapshots: ReplaySnapshot[];
+}
+export type PlaybackState = 'idle' | 'playing' | 'paused' | 'seeking' | 'finished';
+export interface PlaybackInfo {
+    state: PlaybackState;
+    currentFrame: number;
+    currentTime: number;
+    duration: number;
+    totalFrames: number;
+    speed: number;
+    progress: number;
+}
+export type ReplayEventType = 'recording-started' | 'recording-stopped' | 'frame-recorded' | 'snapshot-created' | 'playback-started' | 'playback-paused' | 'playback-resumed' | 'playback-stopped' | 'playback-finished' | 'playback-seek' | 'playback-speed-changed' | 'frame-played' | 'replay-loaded' | 'replay-exported';
+export interface ReplayEvent {
+    type: ReplayEventType;
+    timestamp: number;
+    replayId?: ReplayId;
+    data?: unknown;
+}
+export type ReplayEventCallback = (event: ReplayEvent) => void;
+export interface ReplayConfig {
+    /** Frames per second for recording */
+    recordFPS: number;
+    /** Snapshot interval (frames) for seeking */
+    snapshotInterval: number;
+    /** Max frames before auto-stop */
+    maxFrames: number;
+    /** Max duration (seconds) */
+    maxDuration: number;
+    /** Enable compression */
+    enableCompression: boolean;
+    /** Record inputs */
+    recordInputs: boolean;
+    /** Record entity states */
+    recordEntities: boolean;
+    /** Storage key prefix */
+    storagePrefix: string;
+    /** Auto-save replays */
+    autoSave: boolean;
+    /** Max stored replays */
+    maxStoredReplays: number;
+}
+export declare const DEFAULT_REPLAY_CONFIG: ReplayConfig;
+export interface ReplayStateProvider {
+    getEntities(): EntityState[];
+    setEntities(entities: EntityState[]): void;
+    getCustomState(): Record<string, unknown>;
+    setCustomState(state: Record<string, unknown>): void;
+}
+export declare class NiceReplay {
+    private config;
+    private isRecording;
+    private recordingStartTime;
+    private recordedFrames;
+    private recordedSnapshots;
+    private currentRecordingMetadata?;
+    private pendingInputs;
+    private pendingEvents;
+    private frameAccumulator;
+    private currentFrame;
+    private playbackState;
+    private loadedReplay?;
+    private playbackFrame;
+    private playbackTime;
+    private playbackSpeed;
+    private playbackAccumulator;
+    private stateProvider?;
+    private idCounter;
+    private eventListeners;
+    constructor(config?: Partial<ReplayConfig>);
+    on(event: ReplayEventType, callback: ReplayEventCallback): () => void;
+    private emit;
+    setStateProvider(provider: ReplayStateProvider): void;
+    startRecording(metadata?: Partial<ReplayMetadata>): ReplayId;
+    recordFrame(deltaTime: number): void;
+    recordInput(event: Omit<InputEvent, 'timestamp' | 'frame'>): void;
+    recordEvent(type: string, data: unknown): void;
+    private createSnapshot;
+    stopRecording(): ReplayData | null;
+    isCurrentlyRecording(): boolean;
+    getRecordingDuration(): number;
+    getRecordedFrameCount(): number;
+    loadReplay(replay: ReplayData): void;
+    startPlayback(fromFrame?: number): void;
+    pausePlayback(): void;
+    resumePlayback(): void;
+    stopPlayback(): void;
+    updatePlayback(deltaTime: number): void;
+    private applyFrame;
+    private applyNearestSnapshot;
+    seek(frameNumber: number): void;
+    seekToTime(timeSeconds: number): void;
+    setPlaybackSpeed(speed: number): void;
+    getPlaybackInfo(): PlaybackInfo;
+    getCurrentFrame(): ReplayFrame | undefined;
+    getFrameAt(frameNumber: number): ReplayFrame | undefined;
+    getInputsInRange(startFrame: number, endFrame: number): InputEvent[];
+    exportReplay(replay?: ReplayData): string;
+    importReplay(data: string): ReplayData | null;
+    private compress;
+    private decompress;
+    private isCompressed;
+    saveReplay(replay: ReplayData): boolean;
+    loadReplayFromStorage(replayId: ReplayId): ReplayData | null;
+    deleteReplay(replayId: ReplayId): void;
+    getStoredReplays(): ReplayMetadata[];
+    private updateReplayIndex;
+    private removeFromReplayIndex;
+    private trimStoredReplays;
+    destroy(): void;
+}
+export declare function createReplaySystem(config?: Partial<ReplayConfig>): NiceReplay;

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

@@ -0,0 +1,151 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type FactionId = string;
+export type StandingLevel = 'hated' | 'hostile' | 'unfriendly' | 'neutral' | 'friendly' | 'honored' | 'revered' | 'exalted';
+export interface StandingThreshold {
+    level: StandingLevel;
+    minValue: number;
+    maxValue: number;
+    color?: string;
+}
+export declare const DEFAULT_STANDING_THRESHOLDS: StandingThreshold[];
+export interface FactionPerk {
+    id: string;
+    name: string;
+    description: string;
+    requiredStanding: StandingLevel;
+    type: 'discount' | 'access' | 'buff' | 'item' | 'quest' | 'title';
+    value?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface FactionPenalty {
+    standingLevel: StandingLevel;
+    type: 'attack-on-sight' | 'no-service' | 'price-increase' | 'bounty';
+    value?: number;
+}
+export interface Faction {
+    id: FactionId;
+    name: string;
+    description: string;
+    icon?: string;
+    color?: string;
+    isHidden?: boolean;
+    defaultStanding: number;
+    standingCap: number;
+    standingFloor: number;
+    relationships: Map<FactionId, number>;
+    perks: FactionPerk[];
+    penalties: FactionPenalty[];
+    parentFaction?: FactionId;
+    childFactions?: FactionId[];
+    tags: string[];
+}
+export interface ReputationEntry {
+    factionId: FactionId;
+    currentValue: number;
+    standingLevel: StandingLevel;
+    lifetimeGained: number;
+    lifetimeLost: number;
+    lastChange: number;
+    lastChangeAmount: number;
+    progressToNext: number;
+    totalToNext: number;
+    unlockedPerks: Set<string>;
+    activeQuests: string[];
+}
+export interface EntityReputation {
+    entityId: EntityId;
+    reputations: Map<FactionId, ReputationEntry>;
+    titles: string[];
+    globalModifier: number;
+}
+export interface ReputationAction {
+    id: string;
+    name: string;
+    factionId: FactionId;
+    baseChange: number;
+    repeatable: boolean;
+    cooldown?: number;
+    maxRepeats?: number;
+    diminishingReturns?: number;
+    spilloverFactions?: {
+        factionId: FactionId;
+        ratio: number;
+    }[];
+}
+export type ReputationEventType = 'reputation-changed' | 'standing-changed' | 'perk-unlocked' | 'perk-lost' | 'penalty-applied' | 'penalty-removed' | 'title-earned' | 'faction-discovered';
+export interface ReputationEvent {
+    type: ReputationEventType;
+    entityId: EntityId;
+    factionId?: FactionId;
+    data?: Record<string, unknown>;
+}
+export interface ReputationSystemConfig {
+    standingThresholds?: StandingThreshold[];
+    decayEnabled?: boolean;
+    decayRate?: number;
+    decayTowardsNeutral?: boolean;
+    spilloverEnabled?: boolean;
+    spilloverRatio?: number;
+    diminishingReturnsEnabled?: boolean;
+    bonusModifierPerLevel?: number;
+}
+export declare const DEFAULT_REPUTATION_CONFIG: ReputationSystemConfig;
+export declare class NiceReputation extends EventEmitter {
+    private factions;
+    private entities;
+    private actions;
+    private actionHistory;
+    private config;
+    constructor(config?: Partial<ReputationSystemConfig>);
+    registerFaction(faction: Faction): void;
+    getFaction(id: FactionId): Faction | undefined;
+    getAllFactions(): Faction[];
+    getVisibleFactions(): Faction[];
+    setFactionRelationship(factionA: FactionId, factionB: FactionId, value: number): void;
+    getFactionRelationship(factionA: FactionId, factionB: FactionId): number;
+    registerEntity(entityId: EntityId): void;
+    getEntityReputation(entityId: EntityId): EntityReputation | undefined;
+    discoverFaction(entityId: EntityId, factionId: FactionId): void;
+    modifyReputation(entityId: EntityId, factionId: FactionId, amount: number, options?: {
+        bypassCap?: boolean;
+        noSpillover?: boolean;
+        source?: string;
+    }): number;
+    private applySpillover;
+    private handleStandingChange;
+    getStandingLevel(value: number): StandingLevel;
+    private updateProgressToNext;
+    getReputation(entityId: EntityId, factionId: FactionId): ReputationEntry | undefined;
+    getStanding(entityId: EntityId, factionId: FactionId): StandingLevel;
+    private checkPerks;
+    hasUnlockedPerk(entityId: EntityId, factionId: FactionId, perkId: string): boolean;
+    getUnlockedPerks(entityId: EntityId, factionId: FactionId): FactionPerk[];
+    private checkPenalties;
+    getActivePenalties(entityId: EntityId, factionId: FactionId): FactionPenalty[];
+    isHostile(entityId: EntityId, factionId: FactionId): boolean;
+    registerAction(action: ReputationAction): void;
+    performAction(entityId: EntityId, actionId: string): boolean;
+    grantTitle(entityId: EntityId, title: string): void;
+    hasTitle(entityId: EntityId, title: string): boolean;
+    getTitles(entityId: EntityId): string[];
+    update(deltaTime: number): void;
+    getHighestStandingFaction(entityId: EntityId): {
+        factionId: FactionId;
+        value: number;
+    } | null;
+    getLowestStandingFaction(entityId: EntityId): {
+        factionId: FactionId;
+        value: number;
+    } | null;
+    getFactionsByStanding(entityId: EntityId, standing: StandingLevel): FactionId[];
+    getAlliableFactions(entityId: EntityId): FactionId[];
+    getHostileFactions(entityId: EntityId): FactionId[];
+}
+export declare function createReputationSystem(config?: Partial<ReputationSystemConfig>): NiceReputation;
+export declare function defineFaction(options: Omit<Faction, 'relationships'> & {
+    relationships?: [FactionId, number][];
+}): Faction;
+export declare function defineReputationAction(options: ReputationAction): ReputationAction;
+export declare function defineFactionPerk(options: FactionPerk): FactionPerk;
+export default NiceReputation;

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

@@ -0,0 +1,200 @@
+/**
+ * NiceResource - Game Engine Resource Management System
+ *
+ * Comprehensive asset/resource management supporting:
+ * - Asset loading (images, audio, JSON, text, binary)
+ * - Asset caching and memory management
+ * - Loading queues with priorities
+ * - Asset bundles and packages
+ * - Reference counting
+ * - Asset streaming
+ * - Preloading and lazy loading
+ * - Asset dependencies
+ * - Memory budget management
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+export type AssetId = string;
+export type BundleId = string;
+export type LoaderId = string;
+export type AssetType = 'image' | 'audio' | 'json' | 'text' | 'binary' | 'spritesheet' | 'tilemap' | 'font' | 'shader' | 'model' | 'video' | 'custom';
+export type AssetState = 'unloaded' | 'queued' | 'loading' | 'loaded' | 'error' | 'unloading';
+export type LoadPriority = 'critical' | 'high' | 'normal' | 'low' | 'background';
+export interface AssetMetadata {
+    id: AssetId;
+    url: string;
+    type: AssetType;
+    size?: number;
+    mimeType?: string;
+    lastModified?: number;
+    checksum?: string;
+    tags?: string[];
+    dependencies?: AssetId[];
+    userData?: Record<string, unknown>;
+}
+export interface Asset<T = unknown> extends AssetMetadata {
+    state: AssetState;
+    data?: T;
+    error?: Error;
+    refCount: number;
+    loadedAt?: number;
+    accessedAt?: number;
+    loadTime?: number;
+    priority: LoadPriority;
+}
+export interface AssetBundle {
+    id: BundleId;
+    name: string;
+    assets: AssetId[];
+    dependencies?: BundleId[];
+    priority: LoadPriority;
+    preload?: boolean;
+    persistent?: boolean;
+    progress?: number;
+    state: AssetState;
+}
+export interface AssetLoaderOptions {
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    crossOrigin?: string;
+    credentials?: RequestCredentials;
+    headers?: Record<string, string>;
+}
+export type LoaderFunction<T = unknown> = (url: string, options?: AssetLoaderOptions) => Promise<T>;
+export interface AssetLoader<T = unknown> {
+    id: LoaderId;
+    types: AssetType[];
+    extensions: string[];
+    load: LoaderFunction<T>;
+    unload?: (asset: Asset<T>) => void;
+}
+export interface LoadingProgress {
+    total: number;
+    loaded: number;
+    failed: number;
+    current?: AssetId;
+    percentage: number;
+    bytesTotal?: number;
+    bytesLoaded?: number;
+}
+export type ResourceEventType = 'asset-queued' | 'asset-loading' | 'asset-loaded' | 'asset-error' | 'asset-unloaded' | 'bundle-loading' | 'bundle-loaded' | 'bundle-error' | 'progress' | 'memory-warning' | 'memory-critical';
+export interface ResourceEvent {
+    type: ResourceEventType;
+    assetId?: AssetId;
+    bundleId?: BundleId;
+    progress?: LoadingProgress;
+    error?: Error;
+    memoryUsage?: number;
+    timestamp: number;
+}
+export type ResourceEventCallback = (event: ResourceEvent) => void;
+export interface ResourceConfig {
+    maxConcurrentLoads: number;
+    defaultTimeout: number;
+    defaultRetries: number;
+    retryDelay: number;
+    memoryBudget: number;
+    lowMemoryThreshold: number;
+    criticalMemoryThreshold: number;
+    enableCaching: boolean;
+    cacheExpireTime: number;
+    autoUnloadUnused: boolean;
+    unusedAssetTimeout: number;
+}
+export declare const DEFAULT_RESOURCE_CONFIG: ResourceConfig;
+export declare class NiceResource extends EventEmitter {
+    private config;
+    private assets;
+    private bundles;
+    private loaders;
+    private typeToLoader;
+    private extensionToType;
+    private loadQueue;
+    private activeLoads;
+    private loadPromises;
+    private memoryUsage;
+    private destroyed;
+    constructor(config?: Partial<ResourceConfig>);
+    private registerDefaultLoaders;
+    private setupExtensionMappings;
+    registerLoader<T = unknown>(loader: AssetLoader<T>): void;
+    unregisterLoader(loaderId: LoaderId): void;
+    register(id: AssetId, url: string, type?: AssetType, metadata?: Partial<AssetMetadata>): void;
+    private inferType;
+    unregister(id: AssetId): void;
+    load<T = unknown>(id: AssetId, options?: AssetLoaderOptions): Promise<T>;
+    private loadAsset;
+    private loadWithTimeout;
+    private delay;
+    queue(id: AssetId, priority?: LoadPriority): void;
+    private sortQueue;
+    private processQueue;
+    private emitProgress;
+    private getLoadedCount;
+    private getFailedCount;
+    get<T = unknown>(id: AssetId): T | undefined;
+    getAsset(id: AssetId): Asset | undefined;
+    isLoaded(id: AssetId): boolean;
+    getState(id: AssetId): AssetState | undefined;
+    unload(id: AssetId): void;
+    release(id: AssetId): void;
+    registerBundle(bundle: AssetBundle): void;
+    loadBundle(bundleId: BundleId): Promise<void>;
+    unloadBundle(bundleId: BundleId, force?: boolean): void;
+    getBundleProgress(bundleId: BundleId): number;
+    isBundleLoaded(bundleId: BundleId): boolean;
+    private checkMemoryUsage;
+    unloadUnused(maxAge?: number): number;
+    getMemoryUsage(): number;
+    getMemoryBudget(): number;
+    setMemoryBudget(budget: number): void;
+    preload(ids: AssetId[], onProgress?: (progress: LoadingProgress) => void): Promise<void>;
+    preloadBundles(bundleIds: BundleId[], onProgress?: (progress: LoadingProgress) => void): Promise<void>;
+    getAssetsByType(type: AssetType): Asset[];
+    getAssetsByTag(tag: string): Asset[];
+    getAssetsByState(state: AssetState): Asset[];
+    getAllAssets(): Asset[];
+    getAllBundles(): AssetBundle[];
+    getStats(): {
+        totalAssets: number;
+        loadedAssets: number;
+        queuedAssets: number;
+        loadingAssets: number;
+        failedAssets: number;
+        totalBundles: number;
+        loadedBundles: number;
+        memoryUsage: number;
+        memoryBudget: number;
+        registeredLoaders: number;
+    };
+    clear(): void;
+    update(): void;
+    on(event: 'resource', callback: ResourceEventCallback): this;
+    off(event: 'resource', callback: ResourceEventCallback): this;
+    destroy(): void;
+}
+export declare function createResourceManager(config?: Partial<ResourceConfig>): NiceResource;
+export interface AssetManifest {
+    version: string;
+    baseUrl?: string;
+    assets: Array<{
+        id: AssetId;
+        url: string;
+        type?: AssetType;
+        size?: number;
+        tags?: string[];
+        dependencies?: AssetId[];
+    }>;
+    bundles?: Array<{
+        id: BundleId;
+        name: string;
+        assets: AssetId[];
+        dependencies?: BundleId[];
+        preload?: boolean;
+        persistent?: boolean;
+    }>;
+}
+export declare function loadManifest(resources: NiceResource, manifest: AssetManifest): void;
+export declare function loadManifestFromUrl(resources: NiceResource, manifestUrl: string): Promise<AssetManifest>;

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

@@ -0,0 +1,148 @@
+export type NoteType = 'tap' | 'hold' | 'slide' | 'swipe' | 'flick';
+export type HitResult = 'perfect' | 'great' | 'good' | 'miss' | 'early' | 'late';
+export type NoteColor = 'red' | 'blue' | 'green' | 'yellow' | 'pink' | 'purple';
+export interface TimingWindow {
+    perfect: number;
+    great: number;
+    good: number;
+}
+export declare const DEFAULT_TIMING_WINDOWS: TimingWindow;
+export interface Note {
+    id: string;
+    type: NoteType;
+    track: number;
+    beatTime: number;
+    actualTime: number;
+    duration?: number;
+    color?: NoteColor;
+    size?: number;
+    isHit: boolean;
+    result: HitResult | null;
+    hitTime: number | null;
+    isActive: boolean;
+    holdProgress?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface Chart {
+    id: string;
+    name: string;
+    artist: string;
+    difficulty: number;
+    level: number;
+    bpm: number;
+    offset: number;
+    bpmChanges?: Array<{
+        beat: number;
+        bpm: number;
+    }>;
+    notes: Note[];
+    trackCount: number;
+    duration: number;
+    noteCount: number;
+    audioUrl?: string;
+    coverUrl?: string;
+}
+export interface RhythmScore {
+    playerId: string;
+    chartId: string;
+    perfectCount: number;
+    greatCount: number;
+    goodCount: number;
+    missCount: number;
+    earlyCount: number;
+    lateCount: number;
+    currentCombo: number;
+    maxCombo: number;
+    score: number;
+    maxScore: number;
+    accuracy: number;
+    notesHit: number;
+    totalNotes: number;
+    avgTiming: number;
+    perfectRate: number;
+}
+export type RhythmEventType = 'note-spawn' | 'note-hit' | 'note-miss' | 'hold-start' | 'hold-tick' | 'hold-end' | 'combo-break' | 'combo-milestone' | 'beat' | 'song-start' | 'song-end' | 'pause' | 'resume';
+export interface RhythmEvent {
+    type: RhythmEventType;
+    timestamp: number;
+    playerId?: string;
+    data: unknown;
+}
+export type RhythmEventCallback = (event: RhythmEvent) => void;
+export interface RhythmConfig {
+    /** Timing windows (ms) */
+    timingWindows: TimingWindow;
+    /** Score values per hit result */
+    scoreValues: Record<HitResult, number>;
+    /** Note speed multiplier */
+    noteSpeed: number;
+    /** Approach time (ms) */
+    approachTime: number;
+    /** Combo milestones */
+    comboMilestones: number[];
+    /** Max score per note */
+    maxNoteScore: number;
+    /** Enable audio sync */
+    audioSync: boolean;
+    /** Input latency compensation (ms) */
+    inputLatency: number;
+}
+export declare const DEFAULT_RHYTHM_CONFIG: RhythmConfig;
+export declare class NiceRhythm {
+    private config;
+    private charts;
+    private activeChart;
+    private activeNotes;
+    private scores;
+    private currentTime;
+    private currentBeat;
+    private lastBeat;
+    private isPlaying;
+    private isPaused;
+    private startTime;
+    private eventListeners;
+    private nextId;
+    constructor(config?: Partial<RhythmConfig>);
+    on(event: RhythmEventType, callback: RhythmEventCallback): () => void;
+    private emit;
+    loadChart(chart: Omit<Chart, 'notes'> & {
+        notes: Omit<Note, 'id' | 'isHit' | 'result' | 'hitTime' | 'isActive'>[];
+    }): string;
+    getChart(id: string): Chart | undefined;
+    private beatToTime;
+    private timeToBeat;
+    startChart(chartId: string, playerId: string): boolean;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    hit(playerId: string, track: number): HitResult | null;
+    holdStart(playerId: string, track: number): boolean;
+    holdRelease(playerId: string, track: number): boolean;
+    private evaluateHit;
+    private updateScore;
+    update(deltaTime: number): void;
+    private updateNotes;
+    private endSong;
+    getScore(playerId: string): RhythmScore | undefined;
+    getCurrentTime(): number;
+    getCurrentBeat(): number;
+    getActiveNotes(): Note[];
+    getUpcomingNotes(lookahead: number): Note[];
+    getNoteProgress(noteId: string): number;
+    getCombo(playerId: string): number;
+    getAccuracy(playerId: string): number;
+    isActive(): boolean;
+    getProgress(): number;
+    generateChart(options: {
+        id: string;
+        name: string;
+        artist: string;
+        bpm: number;
+        duration: number;
+        trackCount: number;
+        density: number;
+        difficulty: number;
+    }): string;
+    destroy(): void;
+}
+export declare function createRhythmSystem(config?: Partial<RhythmConfig>): NiceRhythm;