@nice2dev/game-engine 1.3.12 → 1.3.14

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

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

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

@@ -1,200 +0,0 @@
-/**
- * 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

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