@nice2dev/game-engine 1.1.5 → 1.1.7

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

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

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

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