@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,202 @@
+export type DungeonId = string;
+export type RoomId = string;
+export type EncounterId = string;
+export type LootTableId = string;
+export type DungeonStatus = 'pending' | 'active' | 'completed' | 'failed' | 'abandoned';
+export type RoomType = 'start' | 'normal' | 'elite' | 'treasure' | 'shop' | 'rest' | 'boss' | 'secret';
+export type DifficultyTier = 'normal' | 'hard' | 'nightmare' | 'inferno';
+export interface RoomConnection {
+    targetRoomId: RoomId;
+    direction: 'north' | 'south' | 'east' | 'west' | 'up' | 'down';
+    locked?: boolean;
+    keyRequired?: string;
+}
+export interface RoomEncounter {
+    enemies: Array<{
+        enemyId: string;
+        count: number;
+        level?: number;
+    }>;
+    isBoss?: boolean;
+    eliteChance?: number;
+}
+export interface RoomReward {
+    lootTable?: LootTableId;
+    guaranteedItems?: Array<{
+        itemId: string;
+        quantity: number;
+    }>;
+    currency?: {
+        type: string;
+        amount: number;
+    };
+    experience?: number;
+}
+export interface RoomDefinition {
+    id: RoomId;
+    name: string;
+    description?: string;
+    type: RoomType;
+    width?: number;
+    height?: number;
+    tilemap?: string;
+    encounter?: RoomEncounter;
+    reward?: RoomReward;
+    interactables?: Array<{
+        type: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        data?: unknown;
+    }>;
+    connections: RoomConnection[];
+    background?: string;
+    ambience?: string;
+}
+export interface RoomInstance {
+    roomId: RoomId;
+    definition: RoomDefinition;
+    status: 'unvisited' | 'active' | 'cleared' | 'failed';
+    enemiesRemaining: number;
+    rewardCollected: boolean;
+    discoveredConnections: RoomId[];
+    visitCount: number;
+}
+export interface DungeonDefinition {
+    id: DungeonId;
+    name: string;
+    description: string;
+    theme: string;
+    recommendedLevel: number;
+    difficulty: DifficultyTier;
+    rooms: RoomDefinition[];
+    startRoomId: RoomId;
+    bossRoomId?: RoomId;
+    procedural?: {
+        minRooms: number;
+        maxRooms: number;
+        roomTypes: Array<{
+            type: RoomType;
+            weight: number;
+        }>;
+        branchChance: number;
+        loopChance: number;
+    };
+    lootTables: Map<LootTableId, LootTable>;
+    maxPlayers?: number;
+    timeLimit?: number;
+    maxDeaths?: number;
+    entryCost?: {
+        type: string;
+        amount: number;
+    };
+    requiresKey?: string;
+    minPlayerLevel?: number;
+    icon?: string;
+    banner?: string;
+}
+export interface LootTable {
+    id: LootTableId;
+    entries: Array<{
+        itemId: string;
+        weight: number;
+        minQuantity: number;
+        maxQuantity: number;
+        dropChance: number;
+    }>;
+}
+export interface DungeonInstance {
+    instanceId: string;
+    dungeonId: DungeonId;
+    definition: DungeonDefinition;
+    status: DungeonStatus;
+    currentRoomId: RoomId;
+    rooms: Map<RoomId, RoomInstance>;
+    startTime: number;
+    endTime?: number;
+    roomsCleared: number;
+    totalRooms: number;
+    bossDefeated: boolean;
+    enemiesKilled: number;
+    damageTaken: number;
+    damageDealt: number;
+    itemsCollected: number;
+    currencyCollected: Record<string, number>;
+    deaths: number;
+    players: string[];
+    difficultyMultiplier: number;
+    lootMultiplier: number;
+}
+export type DungeonEventType = 'dungeon-started' | 'dungeon-completed' | 'dungeon-failed' | 'dungeon-abandoned' | 'room-entered' | 'room-cleared' | 'boss-encountered' | 'boss-defeated' | 'loot-dropped' | 'secret-found' | 'player-died';
+export interface DungeonEvent {
+    type: DungeonEventType;
+    timestamp: number;
+    instanceId: string;
+    dungeonId: DungeonId;
+    data?: unknown;
+}
+export type DungeonEventCallback = (event: DungeonEvent) => void;
+export interface DungeonConfig {
+    difficultyScaling: Record<DifficultyTier, {
+        healthMultiplier: number;
+        damageMultiplier: number;
+        lootMultiplier: number;
+        expMultiplier: number;
+    }>;
+    maxConcurrentInstances: number;
+    instanceTimeout: number;
+    autoCleanupDelay: number;
+    storageKey: string;
+}
+export declare const DEFAULT_DUNGEON_CONFIG: DungeonConfig;
+export declare class NiceDungeon {
+    private config;
+    private definitions;
+    private instances;
+    private playerInstances;
+    private eventListeners;
+    private instanceCounter;
+    constructor(config?: Partial<DungeonConfig>);
+    on(event: DungeonEventType, callback: DungeonEventCallback): () => void;
+    private emit;
+    registerDungeon(definition: DungeonDefinition): void;
+    getDungeon(dungeonId: DungeonId): DungeonDefinition | undefined;
+    getAllDungeons(): DungeonDefinition[];
+    createInstance(dungeonId: DungeonId, players: string[], options?: {
+        difficulty?: DifficultyTier;
+        procedural?: boolean;
+    }): DungeonInstance | null;
+    private createRoomInstance;
+    private generateProceduralRooms;
+    startInstance(instanceId: string): boolean;
+    abandonInstance(instanceId: string): boolean;
+    private cleanupPlayerInstances;
+    enterRoom(instanceId: string, roomId: RoomId): boolean;
+    killEnemy(instanceId: string, damage?: number): void;
+    clearRoom(instanceId: string): void;
+    playerDied(instanceId: string, damage?: number): void;
+    collectRoomReward(instanceId: string): RoomReward | null;
+    rollLootTable(instanceId: string, tableId: LootTableId): Array<{
+        itemId: string;
+        quantity: number;
+    }>;
+    private completeDungeon;
+    private failDungeon;
+    private getCompletionStats;
+    getInstance(instanceId: string): DungeonInstance | undefined;
+    getPlayerInstance(playerId: string): DungeonInstance | undefined;
+    getCurrentRoom(instanceId: string): RoomInstance | undefined;
+    getAvailableConnections(instanceId: string): RoomConnection[];
+    getProgress(instanceId: string): {
+        cleared: number;
+        total: number;
+        percent: number;
+    } | null;
+    cleanupCompletedInstances(): number;
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createDungeonSystem(config?: Partial<DungeonConfig>): NiceDungeon;

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

@@ -0,0 +1,151 @@
+export type EntityId = number;
+export type ComponentType = string;
+export type SystemId = string;
+export type QueryId = string;
+export type TagId = string;
+export type GroupId = string;
+export type PrefabId = string;
+export interface Component {
+    type: ComponentType;
+}
+export interface ComponentDefinition<T extends Component = Component> {
+    type: ComponentType;
+    default: () => Omit<T, 'type'>;
+    schema?: Record<string, 'number' | 'string' | 'boolean' | 'object' | 'array'>;
+}
+export interface Entity {
+    id: EntityId;
+    active: boolean;
+    components: Map<ComponentType, Component>;
+    tags: Set<TagId>;
+    groups: Set<GroupId>;
+    parent?: EntityId;
+    children: EntityId[];
+}
+export interface EntityData {
+    components?: Record<ComponentType, Partial<Component>>;
+    tags?: TagId[];
+    groups?: GroupId[];
+    children?: EntityData[];
+}
+export type SystemPriority = number;
+export interface System {
+    id: SystemId;
+    priority: SystemPriority;
+    enabled: boolean;
+    query: QueryDefinition;
+    init?: () => void;
+    update: (entities: EntityId[], deltaTime: number) => void;
+    destroy?: () => void;
+}
+export interface QueryDefinition {
+    all?: ComponentType[];
+    any?: ComponentType[];
+    none?: ComponentType[];
+    tags?: {
+        all?: TagId[];
+        any?: TagId[];
+        none?: TagId[];
+    };
+}
+export interface Prefab {
+    id: PrefabId;
+    name: string;
+    data: EntityData;
+}
+export type ECSEventType = 'entity-created' | 'entity-destroyed' | 'component-added' | 'component-removed' | 'tag-added' | 'tag-removed' | 'system-added' | 'system-removed';
+export interface ECSEvent {
+    type: ECSEventType;
+    timestamp: number;
+    entityId?: EntityId;
+    data?: unknown;
+}
+export type ECSEventCallback = (event: ECSEvent) => void;
+export interface ECSConfig {
+    /** Initial entity pool size */
+    initialPoolSize: number;
+    /** Max entities */
+    maxEntities: number;
+    /** Enable entity pooling */
+    poolEntities: boolean;
+    /** Debug mode */
+    debug: boolean;
+}
+export declare const DEFAULT_ECS_CONFIG: ECSConfig;
+export declare class NiceECS {
+    private config;
+    private entities;
+    private entityPool;
+    private nextEntityId;
+    private componentDefs;
+    private componentStorage;
+    private systems;
+    private queries;
+    private queryDefinitions;
+    private tags;
+    private groups;
+    private prefabs;
+    private eventListeners;
+    private deferredOperations;
+    private updating;
+    constructor(config?: Partial<ECSConfig>);
+    on(event: ECSEventType, callback: ECSEventCallback): () => void;
+    private emit;
+    registerComponent<T extends Component>(def: ComponentDefinition<T>): void;
+    registerComponents(defs: ComponentDefinition[]): void;
+    createEntity(data?: EntityData): EntityId;
+    destroyEntity(id: EntityId): void;
+    getEntity(id: EntityId): Entity | undefined;
+    entityExists(id: EntityId): boolean;
+    setActive(id: EntityId, active: boolean): void;
+    isActive(id: EntityId): boolean;
+    addComponent<T extends Component>(entityId: EntityId, type: ComponentType, data?: Partial<Omit<T, 'type'>>): T;
+    removeComponent(entityId: EntityId, type: ComponentType): void;
+    getComponent<T extends Component>(entityId: EntityId, type: ComponentType): T | undefined;
+    hasComponent(entityId: EntityId, type: ComponentType): boolean;
+    hasComponents(entityId: EntityId, types: ComponentType[]): boolean;
+    getComponentsOfType<T extends Component>(type: ComponentType): Array<[EntityId, T]>;
+    addTag(entityId: EntityId, tag: TagId): void;
+    removeTag(entityId: EntityId, tag: TagId): void;
+    hasTag(entityId: EntityId, tag: TagId): boolean;
+    getEntitiesWithTag(tag: TagId): EntityId[];
+    addToGroup(entityId: EntityId, group: GroupId): void;
+    removeFromGroup(entityId: EntityId, group: GroupId): void;
+    getGroup(group: GroupId): EntityId[];
+    setParent(entityId: EntityId, parentId: EntityId | undefined): void;
+    getParent(entityId: EntityId): EntityId | undefined;
+    getChildren(entityId: EntityId): EntityId[];
+    getDescendants(entityId: EntityId): EntityId[];
+    createQuery(definition: QueryDefinition): QueryId;
+    getQueryResults(queryId: QueryId): EntityId[];
+    query(definition: QueryDefinition): EntityId[];
+    private matchesQuery;
+    private updateQueries;
+    addSystem(system: System): void;
+    removeSystem(systemId: SystemId): void;
+    getSystem(systemId: SystemId): System | undefined;
+    enableSystem(systemId: SystemId): void;
+    disableSystem(systemId: SystemId): void;
+    update(deltaTime: number): void;
+    registerPrefab(prefab: Prefab): void;
+    instantiatePrefab(prefabId: PrefabId, overrides?: Partial<EntityData>): EntityId;
+    serialize(): string;
+    deserialize(json: string): void;
+    getStats(): {
+        entityCount: number;
+        componentCount: number;
+        systemCount: number;
+        queryCount: number;
+        poolSize: number;
+    };
+    clear(): void;
+    destroy(): void;
+}
+export declare function createECS(config?: Partial<ECSConfig>): NiceECS;
+export declare function defineComponent<T extends object>(type: ComponentType, defaultFn: () => T): ComponentDefinition<T & Component>;
+export declare function defineSystem(id: SystemId, query: QueryDefinition, update: (entities: EntityId[], deltaTime: number) => void, options?: {
+    priority?: number;
+    enabled?: boolean;
+    init?: () => void;
+    destroy?: () => void;
+}): System;

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

@@ -0,0 +1,148 @@
+export type EnchantId = string;
+export type ItemId = string;
+export type MaterialId = string;
+export type ScrollId = string;
+export type EnchantCategory = 'weapon' | 'armor' | 'accessory' | 'tool' | 'any';
+export type EnchantEffect = 'stat' | 'effect' | 'skill' | 'elemental' | 'special';
+export interface EnchantModifier {
+    stat: string;
+    type: 'flat' | 'percent';
+    value: number;
+    perLevel?: number;
+}
+export interface EnchantDefinition {
+    id: EnchantId;
+    name: string;
+    description: string;
+    category: EnchantCategory;
+    effectType: EnchantEffect;
+    modifiers: EnchantModifier[];
+    maxLevel: number;
+    icon?: string;
+    particleEffect?: string;
+    glowColor?: string;
+    minItemLevel?: number;
+    maxItemLevel?: number;
+    allowedItemTypes?: string[];
+    excludedItemTypes?: string[];
+    conflictsWith?: EnchantId[];
+    rarity: string;
+    tags?: string[];
+}
+export interface EnchantInstance {
+    enchantId: EnchantId;
+    level: number;
+    appliedAt: number;
+}
+export interface EnhancementLevel {
+    level: number;
+    successRate: number;
+    destroyRate: number;
+    downgradeRate: number;
+    materials: Array<{
+        materialId: MaterialId;
+        quantity: number;
+    }>;
+    goldCost: number;
+    bonusMultiplier: number;
+}
+export interface EnhancementConfig {
+    maxLevel: number;
+    levels: EnhancementLevel[];
+    safeLevel: number;
+    useProtection: boolean;
+    protectionItemId?: MaterialId;
+}
+export interface EnchantScroll {
+    id: ScrollId;
+    name: string;
+    description: string;
+    enchantId: EnchantId;
+    targetLevel: number;
+    successRateBonus: number;
+    isGuaranteed: boolean;
+    consumable: boolean;
+}
+export type EnchantResult = 'success' | 'fail' | 'destroy' | 'downgrade' | 'protected';
+export interface EnchantAttemptResult {
+    result: EnchantResult;
+    newLevel: number;
+    previousLevel: number;
+    successRate: number;
+    materialsConsumed: Array<{
+        materialId: MaterialId;
+        quantity: number;
+    }>;
+    goldConsumed: number;
+    itemDestroyed: boolean;
+    protectionUsed: boolean;
+}
+export type EnchantEventType = 'enchant-applied' | 'enchant-removed' | 'enchant-upgraded' | 'enchant-failed' | 'enchant-destroyed' | 'enchant-downgraded' | 'enchant-protected' | 'enchant-transferred';
+export interface EnchantEvent {
+    type: EnchantEventType;
+    timestamp: number;
+    itemId: ItemId;
+    data?: unknown;
+}
+export type EnchantEventCallback = (event: EnchantEvent) => void;
+export interface EnchantSystemConfig {
+    maxEnchantsPerItem: number;
+    enableDestruction: boolean;
+    enableDowngrade: boolean;
+    luckyEnhanceChance: number;
+    superSuccessMultiplier: number;
+    transferCostMultiplier: number;
+    storageKey: string;
+}
+export declare const DEFAULT_ENCHANT_CONFIG: EnchantSystemConfig;
+export declare const DEFAULT_ENHANCEMENT_LEVELS: EnhancementLevel[];
+export declare class NiceEnchant {
+    private config;
+    private definitions;
+    private scrolls;
+    private enhancementConfigs;
+    private itemEnchants;
+    private itemLevels;
+    private eventListeners;
+    constructor(config?: Partial<EnchantSystemConfig>);
+    on(event: EnchantEventType, callback: EnchantEventCallback): () => void;
+    private emit;
+    registerEnchant(definition: EnchantDefinition): void;
+    registerScroll(scroll: EnchantScroll): void;
+    registerEnhancementConfig(itemType: string, config: EnhancementConfig): void;
+    canApplyEnchant(itemId: ItemId, enchantId: EnchantId, itemData?: {
+        type?: string;
+        level?: number;
+    }): {
+        can: boolean;
+        reason?: string;
+    };
+    applyEnchant(itemId: ItemId, enchantId: EnchantId, level?: number): boolean;
+    removeEnchant(itemId: ItemId, enchantId: EnchantId): boolean;
+    getEnhancementInfo(itemId: ItemId, itemType?: string): EnhancementLevel | null;
+    enhance(itemId: ItemId, itemType?: string, options?: {
+        useProtection?: boolean;
+        successRateBonus?: number;
+        materials?: Map<MaterialId, number>;
+        gold?: number;
+    }): EnchantAttemptResult | null;
+    useScroll(itemId: ItemId, scrollId: ScrollId): boolean;
+    transferEnchant(sourceItemId: ItemId, targetItemId: ItemId, enchantId: EnchantId, targetItemData?: {
+        type?: string;
+        level?: number;
+    }): {
+        success: boolean;
+        cost: number;
+    };
+    calculateEnchantStats(itemId: ItemId): Record<string, number>;
+    getEnchant(enchantId: EnchantId): EnchantDefinition | undefined;
+    getItemEnchants(itemId: ItemId): EnchantInstance[];
+    getItemLevel(itemId: ItemId): number;
+    getEnchantsByCategory(category: EnchantCategory): EnchantDefinition[];
+    getAllEnchants(): EnchantDefinition[];
+    private save;
+    private load;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createEnchantSystem(config?: Partial<EnchantSystemConfig>): NiceEnchant;

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

@@ -0,0 +1,127 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type ComponentType = string;
+export interface PooledComponent {
+    readonly type: ComponentType;
+    reset(): void;
+}
+export type ComponentFactory<T extends PooledComponent> = () => T;
+export type ComponentInitializer<T extends PooledComponent> = (component: T) => void;
+export interface PooledEntity {
+    id: EntityId;
+    active: boolean;
+    components: Map<ComponentType, PooledComponent>;
+    tags: Set<string>;
+    prefabId?: string;
+}
+export interface PrefabDefinition {
+    id: string;
+    name: string;
+    components: ComponentType[];
+    tags?: string[];
+    initializers?: Record<ComponentType, (component: PooledComponent) => void>;
+}
+export interface PoolStatistics {
+    totalCreated: number;
+    poolSize: number;
+    activeCount: number;
+    inactiveCount: number;
+    peakActive: number;
+    acquireCount: number;
+    releaseCount: number;
+}
+export type EntityPoolEventType = 'entity-acquired' | 'entity-released' | 'entity-created' | 'prefab-registered' | 'pool-cleared' | 'pool-warmed';
+export interface EntityPoolEvent {
+    type: EntityPoolEventType;
+    entityId?: EntityId;
+    prefabId?: string;
+    count?: number;
+}
+export interface EntityPoolConfig {
+    initialSize?: number;
+    maxSize?: number;
+    growSize?: number;
+    autoGrow?: boolean;
+    warmupOnStart?: boolean;
+}
+export declare const DEFAULT_ENTITY_POOL_CONFIG: EntityPoolConfig;
+export declare class NiceEntityPool extends EventEmitter {
+    private pool;
+    private active;
+    private componentFactories;
+    private prefabs;
+    private nextId;
+    private config;
+    private stats;
+    constructor(config?: Partial<EntityPoolConfig>);
+    registerComponent<T extends PooledComponent>(type: ComponentType, factory: ComponentFactory<T>): void;
+    hasComponentFactory(type: ComponentType): boolean;
+    registerPrefab(prefab: PrefabDefinition): void;
+    getPrefab(id: string): PrefabDefinition | undefined;
+    private createEntity;
+    private attachComponent;
+    acquire(componentTypes?: ComponentType[], tags?: string[]): PooledEntity | null;
+    acquireFromPrefab(prefabId: string): PooledEntity | null;
+    release(entityOrId: PooledEntity | EntityId): boolean;
+    releaseAll(): void;
+    get(id: EntityId): PooledEntity | undefined;
+    getActive(): PooledEntity[];
+    getByTag(tag: string): PooledEntity[];
+    getByPrefab(prefabId: string): PooledEntity[];
+    getByComponent(type: ComponentType): PooledEntity[];
+    warmup(count: number, componentTypes?: ComponentType[]): void;
+    warmupPrefab(prefabId: string, count: number): void;
+    shrink(targetSize?: number): number;
+    clear(): void;
+    getStats(): PoolStatistics;
+    getActiveCount(): number;
+    getInactiveCount(): number;
+}
+export declare abstract class BasePooledComponent implements PooledComponent {
+    abstract readonly type: ComponentType;
+    abstract reset(): void;
+}
+export declare class TransformComponent extends BasePooledComponent {
+    readonly type = "transform";
+    x: number;
+    y: number;
+    z: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+    reset(): void;
+}
+export declare class VelocityComponent extends BasePooledComponent {
+    readonly type = "velocity";
+    vx: number;
+    vy: number;
+    vz: number;
+    angularVelocity: number;
+    reset(): void;
+}
+export declare class SpriteComponent extends BasePooledComponent {
+    readonly type = "sprite";
+    textureId: string;
+    frameIndex: number;
+    alpha: number;
+    tint: number;
+    visible: boolean;
+    reset(): void;
+}
+export declare class HealthComponent extends BasePooledComponent {
+    readonly type = "health";
+    current: number;
+    max: number;
+    invulnerable: boolean;
+    reset(): void;
+}
+export declare class LifetimeComponent extends BasePooledComponent {
+    readonly type = "lifetime";
+    duration: number;
+    elapsed: number;
+    expired: boolean;
+    reset(): void;
+}
+export declare function createEntityPool(config?: Partial<EntityPoolConfig>): NiceEntityPool;
+export declare function registerCommonComponents(pool: NiceEntityPool): void;
+export default NiceEntityPool;