@nice2dev/game-engine 1.3.12 → 1.3.14

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

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

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

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

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