@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,276 +0,0 @@
-export type RoomType = 'start' | 'combat' | 'elite' | 'boss' | 'treasure' | 'shop' | 'rest' | 'event' | 'secret' | 'exit';
-export type RunState = 'preparing' | 'active' | 'victory' | 'defeat' | 'abandoned';
-export type UnlockType = 'character' | 'relic' | 'card' | 'item' | 'enemy' | 'room' | 'challenge';
-export interface Room {
-    id: string;
-    type: RoomType;
-    floor: number;
-    position: {
-        x: number;
-        y: number;
-    };
-    connections: string[];
-    isVisited: boolean;
-    isCleared: boolean;
-    isRevealed: boolean;
-    content?: RoomContent;
-    rewards?: Reward[];
-    metadata?: Record<string, unknown>;
-}
-export interface RoomContent {
-    enemies?: Enemy[];
-    items?: Item[];
-    event?: RogueEvent;
-    shop?: ShopData;
-}
-export interface Floor {
-    id: string;
-    number: number;
-    rooms: Map<string, Room>;
-    startRoom: string;
-    bossRoom: string;
-    isComplete: boolean;
-}
-export interface Enemy {
-    id: string;
-    name: string;
-    type: 'normal' | 'elite' | 'boss';
-    health: number;
-    maxHealth: number;
-    attack: number;
-    defense: number;
-    abilities: string[];
-    loot: LootTable;
-}
-export interface Item {
-    id: string;
-    name: string;
-    description: string;
-    type: 'consumable' | 'equipment' | 'passive' | 'curse';
-    rarity: 'common' | 'uncommon' | 'rare' | 'legendary' | 'cursed';
-    effects: ItemEffect[];
-    price?: number;
-}
-export interface ItemEffect {
-    stat: string;
-    value: number;
-    duration?: number;
-}
-export interface Relic {
-    id: string;
-    name: string;
-    description: string;
-    rarity: 'common' | 'uncommon' | 'rare' | 'boss';
-    trigger: 'passive' | 'onCombatStart' | 'onCombatEnd' | 'onDamage' | 'onHeal' | 'onRoomEnter';
-    effect: string;
-    value?: number;
-}
-export interface LootTable {
-    gold: {
-        min: number;
-        max: number;
-    };
-    items: Array<{
-        itemId: string;
-        chance: number;
-    }>;
-    relics: Array<{
-        relicId: string;
-        chance: number;
-    }>;
-}
-export interface RogueEvent {
-    id: string;
-    name: string;
-    description: string;
-    choices: EventChoice[];
-}
-export interface EventChoice {
-    text: string;
-    requirements?: EventRequirement[];
-    outcomes: EventOutcome[];
-}
-export interface EventRequirement {
-    type: 'gold' | 'health' | 'item' | 'stat';
-    value: number | string;
-}
-export interface EventOutcome {
-    type: 'gold' | 'health' | 'item' | 'relic' | 'stat' | 'text' | 'damage';
-    value: number | string;
-    chance?: number;
-}
-export interface ShopData {
-    items: ShopItem[];
-    relics: ShopItem[];
-    removals: number;
-    removalPrice: number;
-}
-export interface ShopItem {
-    item: Item | Relic;
-    price: number;
-    isSold: boolean;
-}
-export interface Reward {
-    type: 'gold' | 'item' | 'relic' | 'heal' | 'cardRemove' | 'upgrade';
-    value: number | string;
-    claimed: boolean;
-}
-export interface RogueCharacter {
-    id: string;
-    name: string;
-    class: string;
-    health: number;
-    maxHealth: number;
-    gold: number;
-    relics: Relic[];
-    items: Item[];
-    deck?: string[];
-    level: number;
-    experience: number;
-    abilities: string[];
-    modifiers: CharacterModifier[];
-}
-export interface CharacterModifier {
-    id: string;
-    stat: string;
-    value: number;
-    duration: number;
-    source: string;
-}
-export interface Run {
-    id: string;
-    seed: string;
-    state: RunState;
-    character: RogueCharacter;
-    currentFloor: number;
-    currentRoom: string | null;
-    floors: Floor[];
-    startTime: number;
-    endTime?: number;
-    roomsVisited: number;
-    enemiesKilled: number;
-    bossesKilled: number;
-    goldEarned: number;
-    goldSpent: number;
-    damageDealt: number;
-    damageTaken: number;
-    history: RunHistoryEntry[];
-}
-export interface RunHistoryEntry {
-    timestamp: number;
-    type: string;
-    data: unknown;
-}
-export interface MetaProgress {
-    totalRuns: number;
-    totalVictories: number;
-    totalDeaths: number;
-    metaCurrency: number;
-    unlocks: Unlock[];
-    highestFloor: number;
-    fastestVictory: number;
-    mostGoldInRun: number;
-    characterProgress: Map<string, CharacterProgress>;
-}
-export interface Unlock {
-    id: string;
-    type: UnlockType;
-    targetId: string;
-    isUnlocked: boolean;
-    requirement: UnlockRequirement;
-}
-export interface UnlockRequirement {
-    type: 'runs' | 'victories' | 'currency' | 'achievement' | 'boss';
-    value: number | string;
-}
-export interface CharacterProgress {
-    characterId: string;
-    runsPlayed: number;
-    victories: number;
-    highestFloor: number;
-    totalKills: number;
-}
-export type RoguelikeEventType = 'run-start' | 'run-end' | 'room-enter' | 'room-clear' | 'floor-change' | 'combat-start' | 'combat-end' | 'enemy-kill' | 'boss-kill' | 'item-pickup' | 'relic-pickup' | 'shop-purchase' | 'event-choice' | 'level-up' | 'death' | 'unlock';
-export interface RoguelikeEvent {
-    type: RoguelikeEventType;
-    timestamp: number;
-    runId: string;
-    data: unknown;
-}
-export type RoguelikeEventCallback = (event: RoguelikeEvent) => void;
-export interface RoguelikeConfig {
-    /** Floors per run */
-    floorsPerRun: number;
-    /** Rooms per floor (average) */
-    roomsPerFloor: number;
-    /** Starting health */
-    startingHealth: number;
-    /** Starting gold */
-    startingGold: number;
-    /** Room type weights */
-    roomWeights: Record<RoomType, number>;
-    /** Shop price modifier */
-    shopPriceModifier: number;
-    /** Elite spawn chance */
-    eliteChance: number;
-    /** Event spawn chance */
-    eventChance: number;
-    /** Treasure spawn chance */
-    treasureChance: number;
-    /** Rest heal percent */
-    restHealPercent: number;
-    /** Meta currency per floor */
-    metaCurrencyPerFloor: number;
-}
-export declare const DEFAULT_ROGUELIKE_CONFIG: RoguelikeConfig;
-export declare class NiceRoguelike {
-    private config;
-    private activeRun;
-    private metaProgress;
-    private items;
-    private relics;
-    private events;
-    private eventListeners;
-    private nextId;
-    private rng;
-    constructor(config?: Partial<RoguelikeConfig>);
-    on(event: RoguelikeEventType, callback: RoguelikeEventCallback): () => void;
-    private emit;
-    setSeed(seed: string): void;
-    private generateSeed;
-    startRun(characterId: string, seed?: string): Run;
-    abandonRun(): void;
-    getRun(): Run | null;
-    private generateFloor;
-    private selectRoomType;
-    private createRoom;
-    private generateRoomContent;
-    private generateEnemies;
-    private generateShop;
-    private generateEvent;
-    private generateTreasure;
-    enterRoom(roomId: string): boolean;
-    private handleRoomEntry;
-    clearCurrentRoom(): void;
-    private generateRewards;
-    private completeFloor;
-    heal(amount: number): void;
-    damage(amount: number): void;
-    addGold(amount: number): void;
-    spendGold(amount: number): boolean;
-    addRelic(relic: Relic): void;
-    addItem(item: Item): void;
-    killEnemy(enemy: Enemy): void;
-    private victory;
-    private death;
-    getMetaProgress(): MetaProgress;
-    private saveMetaProgress;
-    unlock(unlockId: string): boolean;
-    purchaseUnlock(unlockId: string, cost: number): boolean;
-    getCurrentRoom(): Room | null;
-    getConnectedRooms(): Room[];
-    getFloorMap(): Room[];
-    isRunActive(): boolean;
-    destroy(): void;
-}
-export declare function createRoguelikeSystem(config?: Partial<RoguelikeConfig>): NiceRoguelike;

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

@@ -1,202 +0,0 @@
-export type RuneId = string;
-export type RunewordId = string;
-export type InscriptionId = string;
-export type RuneTier = 1 | 2 | 3 | 4 | 5 | 6 | 7;
-export type RuneElement = 'fire' | 'ice' | 'lightning' | 'nature' | 'shadow' | 'holy' | 'arcane' | 'physical' | 'universal';
-export interface RuneDefinition {
-    id: RuneId;
-    name: string;
-    description: string;
-    symbol: string;
-    tier: RuneTier;
-    element: RuneElement;
-    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-    stats: RuneStat[];
-    effects?: RuneEffect[];
-    levelRequired: number;
-    equipmentTypes?: string[];
-    upgradeInto?: RuneId;
-    upgradeCount?: number;
-    icon: string;
-    color: string;
-    glowEffect?: string;
-    tags?: string[];
-}
-export interface RuneStat {
-    stat: string;
-    value: number;
-    isPercentage: boolean;
-}
-export interface RuneEffect {
-    type: 'on_hit' | 'on_kill' | 'on_damage_taken' | 'passive' | 'aura' | 'proc';
-    effectId?: string;
-    chance?: number;
-    value?: number;
-    duration?: number;
-    cooldown?: number;
-    description: string;
-}
-export interface RunewordDefinition {
-    id: RunewordId;
-    name: string;
-    description: string;
-    lore?: string;
-    runes: RuneId[];
-    equipmentTypes: string[];
-    socketCount: number;
-    bonusStats: RuneStat[];
-    bonusEffects: RuneEffect[];
-    levelRequired: number;
-    icon: string;
-    vfx?: string;
-    nameColor?: string;
-    hidden: boolean;
-}
-export interface InscriptionDefinition {
-    id: InscriptionId;
-    name: string;
-    description: string;
-    tier: RuneTier;
-    type: 'major' | 'minor' | 'utility';
-    stats: RuneStat[];
-    effects?: RuneEffect[];
-    slot: string;
-    exclusive: boolean;
-    cost: InscriptionCost;
-    levelRequired: number;
-    professionRequired?: {
-        profession: string;
-        level: number;
-    };
-    icon: string;
-}
-export interface InscriptionCost {
-    currency?: Record<string, number>;
-    materials?: Record<string, number>;
-    runes?: Record<RuneId, number>;
-}
-export interface SocketedItem {
-    itemId: string;
-    equipmentType: string;
-    totalSockets: number;
-    sockets: Socket[];
-    inscription?: AppliedInscription;
-    activeRuneword?: RunewordId;
-    computedStats: Map<string, number>;
-    computedEffects: RuneEffect[];
-}
-export interface Socket {
-    index: number;
-    rune?: RuneId;
-    locked: boolean;
-    color?: RuneElement;
-}
-export interface AppliedInscription {
-    inscriptionId: InscriptionId;
-    appliedAt: number;
-    appliedBy: string;
-}
-export interface PlayerRuneData {
-    playerId: string;
-    runeInventory: Map<RuneId, number>;
-    maxRuneSlots: number;
-    discoveredRunewords: Set<RunewordId>;
-    inscriptionLevel: number;
-    inscriptionXP: number;
-    unlockedInscriptions: Set<InscriptionId>;
-    totalRunesCollected: number;
-    totalRunewordsCreated: number;
-    totalInscriptionsApplied: number;
-    runesUpgraded: number;
-}
-export interface RuneUpgradeRecipe {
-    fromRune: RuneId;
-    toRune: RuneId;
-    count: number;
-    additionalCost?: Record<string, number>;
-}
-export type RuneEventType = 'rune-obtained' | 'rune-socketed' | 'rune-removed' | 'rune-upgraded' | 'runeword-created' | 'runeword-destroyed' | 'runeword-discovered' | 'inscription-applied' | 'inscription-removed' | 'inscription-unlocked' | 'inscription-level-up';
-export interface RuneEvent {
-    type: RuneEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type RuneEventCallback = (event: RuneEvent) => void;
-export interface RuneConfig {
-    maxRuneSlots: number;
-    maxSocketsPerItem: number;
-    runeUpgradeCount: number;
-    inscriptionXPPerLevel: number;
-    inscriptionMaxLevel: number;
-    storageKey: string;
-}
-export declare const DEFAULT_RUNE_CONFIG: RuneConfig;
-export declare class NiceRune {
-    private config;
-    private runes;
-    private runewords;
-    private inscriptions;
-    private upgradeRecipes;
-    private items;
-    private players;
-    private eventListeners;
-    constructor(config?: Partial<RuneConfig>);
-    on(event: RuneEventType, callback: RuneEventCallback): () => void;
-    private emit;
-    registerRune(rune: RuneDefinition): void;
-    registerRuneword(runeword: RunewordDefinition): void;
-    registerInscription(inscription: InscriptionDefinition): void;
-    getPlayer(playerId: string): PlayerRuneData;
-    private createPlayerData;
-    addRune(playerId: string, runeId: RuneId, count?: number): boolean;
-    removeRune(playerId: string, runeId: RuneId, count?: number): boolean;
-    getRuneCount(playerId: string, runeId: RuneId): number;
-    getRuneInventory(playerId: string): Map<RuneId, number>;
-    registerItem(itemId: string, equipmentType: string, socketCount: number, socketColors?: RuneElement[]): SocketedItem;
-    getItem(itemId: string): SocketedItem | undefined;
-    socketRune(playerId: string, itemId: string, socketIndex: number, runeId: RuneId): boolean;
-    unsocketRune(playerId: string, itemId: string, socketIndex: number): RuneId | null;
-    unsocketAllRunes(playerId: string, itemId: string): RuneId[];
-    private checkRuneword;
-    getActiveRuneword(itemId: string): RunewordDefinition | undefined;
-    private recalculateItem;
-    canUpgradeRune(playerId: string, runeId: RuneId): boolean;
-    upgradeRune(playerId: string, runeId: RuneId): RuneId | null;
-    getUpgradeRecipe(runeId: RuneId): RuneUpgradeRecipe | undefined;
-    unlockInscription(playerId: string, inscriptionId: InscriptionId): boolean;
-    canApplyInscription(playerId: string, itemId: string, inscriptionId: InscriptionId): boolean;
-    applyInscription(playerId: string, itemId: string, inscriptionId: InscriptionId): boolean;
-    removeInscription(itemId: string): InscriptionId | null;
-    addInscriptionXP(playerId: string, xp: number): void;
-    getInscriptionXPForLevel(level: number): number;
-    getInscriptionProgress(playerId: string): {
-        level: number;
-        xp: number;
-        xpNeeded: number;
-    };
-    getRune(id: RuneId): RuneDefinition | undefined;
-    getAllRunes(): RuneDefinition[];
-    getRunesByTier(tier: RuneTier): RuneDefinition[];
-    getRunesByElement(element: RuneElement): RuneDefinition[];
-    getRuneword(id: RunewordId): RunewordDefinition | undefined;
-    getAllRunewords(): RunewordDefinition[];
-    getDiscoveredRunewords(playerId: string): RunewordDefinition[];
-    getInscription(id: InscriptionId): InscriptionDefinition | undefined;
-    getAllInscriptions(): InscriptionDefinition[];
-    getUnlockedInscriptions(playerId: string): InscriptionDefinition[];
-    getItemStats(itemId: string): Map<string, number>;
-    getItemEffects(itemId: string): RuneEffect[];
-    getStats(playerId: string): {
-        totalRunes: number;
-        uniqueRunes: number;
-        runewordsDiscovered: number;
-        runewordsCreated: number;
-        inscriptionsUnlocked: number;
-        inscriptionLevel: number;
-    };
-    save(): void;
-    load(): void;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createRuneSystem(config?: Partial<RuneConfig>): NiceRune;

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

@@ -1,194 +0,0 @@
-export type SaveSlotId = string | number;
-export interface SaveMetadata {
-    id: SaveSlotId;
-    name: string;
-    description?: string;
-    createdAt: number;
-    modifiedAt: number;
-    playTime: number;
-    version: string;
-    chapterOrLevel?: string;
-    difficulty?: string;
-    thumbnail?: string;
-    checksum: string;
-    compressed: boolean;
-    encrypted: boolean;
-    cloudSynced: boolean;
-    tags: string[];
-    customData: Record<string, unknown>;
-}
-export interface SaveData<T = Record<string, unknown>> {
-    metadata: SaveMetadata;
-    gameState: T;
-    timestamp: number;
-}
-export interface SaveSystemConfig {
-    /** Maximum number of save slots */
-    maxSlots: number;
-    /** Auto-save interval in seconds (0 = disabled) */
-    autoSaveInterval: number;
-    /** Number of auto-save slots to rotate */
-    autoSaveSlots: number;
-    /** Quick save slot IDs */
-    quickSaveSlots: number;
-    /** Enable data compression */
-    compression: boolean;
-    /** Compression level (1-9) */
-    compressionLevel: number;
-    /** Enable encryption */
-    encryption: boolean;
-    /** Encryption key (if encryption enabled) */
-    encryptionKey?: string;
-    /** Game version for save compatibility */
-    gameVersion: string;
-    /** Minimum compatible version */
-    minCompatibleVersion: string;
-    /** Storage adapter to use */
-    storageAdapter: 'localStorage' | 'indexedDB' | 'fileSystem' | 'memory' | 'custom';
-    /** Custom storage adapter implementation */
-    customStorage?: StorageAdapter;
-    /** Cloud save provider */
-    cloudProvider?: 'steam' | 'gog' | 'epic' | 'custom' | null;
-    /** Cloud save adapter */
-    cloudAdapter?: CloudSaveAdapter;
-    /** Enable save validation */
-    validateOnLoad: boolean;
-    /** Enable checksum verification */
-    checksumVerification: boolean;
-    /** Prefix for storage keys */
-    storagePrefix: string;
-}
-export declare const DEFAULT_SAVE_CONFIG: SaveSystemConfig;
-export type SaveEventType = 'save-start' | 'save-complete' | 'save-error' | 'load-start' | 'load-complete' | 'load-error' | 'auto-save' | 'delete' | 'cloud-sync-start' | 'cloud-sync-complete' | 'cloud-sync-error' | 'migration-start' | 'migration-complete' | 'checkpoint-created';
-export interface SaveEvent {
-    type: SaveEventType;
-    slotId?: SaveSlotId;
-    timestamp: number;
-    data?: unknown;
-    error?: Error;
-}
-export type SaveEventCallback = (event: SaveEvent) => void;
-export interface StorageAdapter {
-    save(key: string, data: string): Promise<void>;
-    load(key: string): Promise<string | null>;
-    delete(key: string): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-}
-export declare class LocalStorageAdapter implements StorageAdapter {
-    save(key: string, data: string): Promise<void>;
-    load(key: string): Promise<string | null>;
-    delete(key: string): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-}
-export declare class MemoryStorageAdapter implements StorageAdapter {
-    private storage;
-    save(key: string, data: string): Promise<void>;
-    load(key: string): Promise<string | null>;
-    delete(key: string): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-}
-export declare class IndexedDBAdapter implements StorageAdapter {
-    private dbName;
-    private storeName;
-    private db;
-    constructor(dbName?: string);
-    private getDB;
-    save(key: string, data: string): Promise<void>;
-    load(key: string): Promise<string | null>;
-    delete(key: string): Promise<void>;
-    list(): Promise<string[]>;
-    exists(key: string): Promise<boolean>;
-    clear(): Promise<void>;
-}
-export interface CloudSaveAdapter {
-    isAvailable(): Promise<boolean>;
-    upload(key: string, data: string): Promise<void>;
-    download(key: string): Promise<string | null>;
-    delete(key: string): Promise<void>;
-    list(): Promise<string[]>;
-    getLastSyncTime(): Promise<number | null>;
-    resolveConflict(localData: SaveData, cloudData: SaveData): Promise<'local' | 'cloud'>;
-}
-export interface SaveMigration {
-    fromVersion: string;
-    toVersion: string;
-    migrate: (data: Record<string, unknown>) => Record<string, unknown>;
-}
-export interface Checkpoint {
-    id: string;
-    name: string;
-    state: Record<string, unknown>;
-    timestamp: number;
-    level?: string;
-    position?: {
-        x: number;
-        y: number;
-        z?: number;
-    };
-}
-export declare class NiceSaveSystem<TGameState extends Record<string, unknown> = Record<string, unknown>> {
-    private config;
-    private storage;
-    private cloud?;
-    private eventListeners;
-    private autoSaveTimer;
-    private migrations;
-    private checkpoints;
-    private maxCheckpoints;
-    private currentPlayTime;
-    private playTimeStart;
-    constructor(config?: Partial<SaveSystemConfig>);
-    on(event: SaveEventType, callback: SaveEventCallback): () => void;
-    private emit;
-    startPlayTimeTracking(): void;
-    stopPlayTimeTracking(): void;
-    getPlayTime(): number;
-    setPlayTime(seconds: number): void;
-    private getKey;
-    private getMetadataKey;
-    save(slotId: SaveSlotId, gameState: TGameState, options?: {
-        name?: string;
-        description?: string;
-        thumbnail?: string;
-        tags?: string[];
-        customData?: Record<string, unknown>;
-    }): Promise<SaveMetadata>;
-    load(slotId: SaveSlotId): Promise<SaveData<TGameState> | null>;
-    delete(slotId: SaveSlotId): Promise<void>;
-    exists(slotId: SaveSlotId): Promise<boolean>;
-    getMetadata(slotId: SaveSlotId): Promise<SaveMetadata | null>;
-    listSaves(): Promise<SaveMetadata[]>;
-    getSlotCount(): Promise<number>;
-    quickSave(gameState: TGameState, slot?: number): Promise<SaveMetadata>;
-    quickLoad(slot?: number): Promise<SaveData<TGameState> | null>;
-    startAutoSave(getGameState?: () => TGameState): void;
-    stopAutoSave(): void;
-    getLatestAutoSave(): Promise<SaveData<TGameState> | null>;
-    createCheckpoint(name: string, state: Record<string, unknown>, options?: {
-        level?: string;
-        position?: {
-            x: number;
-            y: number;
-            z?: number;
-        };
-    }): Checkpoint;
-    getCheckpoints(): Checkpoint[];
-    getLatestCheckpoint(): Checkpoint | null;
-    loadCheckpoint(id: string): Checkpoint | null;
-    clearCheckpoints(): void;
-    registerMigration(migration: SaveMigration): void;
-    private applyMigrations;
-    syncToCloud(slotId: SaveSlotId): Promise<void>;
-    syncFromCloud(slotId: SaveSlotId): Promise<void>;
-    exportSave(slotId: SaveSlotId): Promise<string>;
-    importSave(slotId: SaveSlotId, data: string): Promise<SaveMetadata>;
-    clearAllSaves(): Promise<void>;
-    destroy(): void;
-}
-export declare function createSaveSystem<T extends Record<string, unknown>>(config?: Partial<SaveSystemConfig>): NiceSaveSystem<T>;