@nice2dev/game-engine 1.3.13 → 1.3.15

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

@@ -1,96 +0,0 @@
-export type PropertyPath = string;
-export type BindingId = string;
-export interface ObservableChange<T = unknown> {
-    path: PropertyPath;
-    oldValue: T;
-    newValue: T;
-    timestamp: number;
-}
-export type ChangeCallback<T = unknown> = (change: ObservableChange<T>) => void;
-export type ComputedGetter<T> = () => T;
-export type WatchCallback<T> = (newValue: T, oldValue: T) => void;
-export type Transformer<T, U> = (value: T) => U;
-export declare class Observable<T extends object> {
-    private proxy;
-    private callbacks;
-    private deepCallbacks;
-    private batchedChanges;
-    private isBatching;
-    constructor(target: T);
-    private createProxy;
-    private notifyChange;
-    get value(): T;
-    watch(path: PropertyPath, callback: ChangeCallback): () => void;
-    watchDeep(callback: ChangeCallback): () => void;
-    batch(fn: () => void): void;
-    get<V>(path: PropertyPath): V | undefined;
-    set(path: PropertyPath, value: unknown): void;
-}
-export declare class Computed<T> {
-    private getter;
-    private cachedValue;
-    private isDirty;
-    private dependencies;
-    private callbacks;
-    constructor(getter: ComputedGetter<T>, dependencies?: Observable<object>[]);
-    addDependency(observable: Observable<object>): void;
-    private invalidate;
-    get(): T;
-    watch(callback: WatchCallback<T>): () => void;
-}
-export type BindingMode = 'one-way' | 'two-way' | 'one-time';
-export interface BindingConfig<S = unknown, T = unknown> {
-    source: Observable<object>;
-    sourcePath: PropertyPath;
-    target: Observable<object>;
-    targetPath: PropertyPath;
-    mode: BindingMode;
-    transformer?: Transformer<S, T>;
-    reverseTransformer?: Transformer<T, S>;
-    fallback?: T;
-}
-export interface BindingState {
-    id: BindingId;
-    config: BindingConfig;
-    active: boolean;
-    lastSync: number;
-    unsubscribe?: () => void;
-    reverseUnsubscribe?: () => void;
-}
-export type BindingEventType = 'binding-created' | 'binding-updated' | 'binding-removed' | 'property-changed' | 'computed-updated' | 'error';
-export interface BindingEvent {
-    type: BindingEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type BindingEventCallback = (event: BindingEvent) => void;
-export declare class NiceBinding {
-    private bindings;
-    private computeds;
-    private eventListeners;
-    private idCounter;
-    on(event: BindingEventType, callback: BindingEventCallback): () => void;
-    private emit;
-    observable<T extends object>(target: T): Observable<T>;
-    computed<T>(getter: ComputedGetter<T>, dependencies?: Observable<object>[]): Computed<T>;
-    bind<S = unknown, T = unknown>(config: BindingConfig<S, T>): BindingId;
-    private syncBinding;
-    private reverseSyncBinding;
-    unbind(id: BindingId): boolean;
-    pauseBinding(id: BindingId): void;
-    resumeBinding(id: BindingId): void;
-    forceSync(id: BindingId): void;
-    oneWay<S = unknown, T = unknown>(source: Observable<object>, sourcePath: PropertyPath, target: Observable<object>, targetPath: PropertyPath, transformer?: Transformer<S, T>): BindingId;
-    twoWay<_T = unknown>(source: Observable<object>, sourcePath: PropertyPath, target: Observable<object>, targetPath: PropertyPath): BindingId;
-    registerComputed<T>(id: string, getter: ComputedGetter<T>, dependencies?: Observable<object>[]): Computed<T>;
-    getComputed<T>(id: string): Computed<T> | undefined;
-    getBinding(id: BindingId): BindingState | undefined;
-    getActiveBindings(): BindingState[];
-    getBindingsForSource(source: Observable<object>): BindingState[];
-    getBindingsForTarget(target: Observable<object>): BindingState[];
-    unbindAll(): void;
-    destroy(): void;
-}
-export declare function createBindingSystem(): NiceBinding;
-export declare function reactive<T extends object>(target: T): Observable<T>;
-export declare function watchEffect<T extends object>(observable: Observable<T>, effect: (value: T) => void | (() => void)): () => void;

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

@@ -1,221 +0,0 @@
-export type RecipeId = string;
-export type MaterialId = string;
-export type UpgradeType = 'enhancement' | 'reforge' | 'upgrade' | 'augment' | 'temper';
-export interface BlacksmithItem {
-    itemId: string;
-    name: string;
-    maxDurability: number;
-    currentDurability: number;
-    durabilityLossRate: number;
-    upgradeLevel: number;
-    maxUpgradeLevel: number;
-    enhancementLevel: number;
-    maxEnhancementLevel: number;
-    reforgeCount: number;
-    maxReforges: number;
-    baseStats: Map<string, number>;
-    bonusStats: Map<string, number>;
-    itemType: string;
-    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-    itemLevel: number;
-    socketCount: number;
-    repairCount: number;
-    totalDurabilityRestored: number;
-}
-export interface RepairRecipe {
-    itemType: string;
-    costPerDurability: number;
-    materialsPerDurability?: Record<MaterialId, number>;
-    minLevel?: number;
-}
-export interface UpgradeRecipe {
-    id: RecipeId;
-    name: string;
-    description?: string;
-    type: UpgradeType;
-    itemTypes: string[];
-    minRarity?: string;
-    minItemLevel?: number;
-    fromLevel: number;
-    toLevel: number;
-    goldCost: number;
-    materials: Record<MaterialId, number>;
-    baseSuccessRate: number;
-    statIncrease: number;
-    statIncreasePercentage: boolean;
-    destroyOnFail: boolean;
-    downgradeOnFail: boolean;
-    durabilityLossOnFail: number;
-    bonusEffects?: UpgradeBonus[];
-}
-export interface UpgradeBonus {
-    level: number;
-    effect: 'stat_boost' | 'socket' | 'glow' | 'prefix' | 'suffix';
-    value?: number;
-    stat?: string;
-    name?: string;
-}
-export interface ReforgeRecipe {
-    id: RecipeId;
-    name: string;
-    itemTypes: string[];
-    minRarity?: string;
-    goldCost: number;
-    materials: Record<MaterialId, number>;
-    randomizeStats: boolean;
-    preserveEnhancement: boolean;
-    preserveSockets: boolean;
-    statRanges: Record<string, {
-        min: number;
-        max: number;
-    }>;
-}
-export interface SalvageRecipe {
-    itemType: string;
-    rarity: string;
-    baseMaterials: Record<MaterialId, number>;
-    levelMaterialBonus: number;
-    bonusMaterial?: MaterialId;
-    rareMaterialChance: number;
-    rareMaterials?: Record<MaterialId, number>;
-}
-export interface MaterialDefinition {
-    id: MaterialId;
-    name: string;
-    description?: string;
-    tier: number;
-    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
-    stackSize: number;
-    sellValue: number;
-    icon: string;
-    color?: string;
-}
-export interface PlayerBlacksmithData {
-    playerId: string;
-    materials: Map<MaterialId, number>;
-    blacksmithLevel: number;
-    blacksmithXP: number;
-    unlockedRecipes: Set<RecipeId>;
-    totalItemsRepaired: number;
-    totalItemsUpgraded: number;
-    totalItemsReforged: number;
-    totalItemsSalvaged: number;
-    upgradesSucceeded: number;
-    upgradesFailed: number;
-    longestUpgradeStreak: number;
-    currentUpgradeStreak: number;
-}
-export interface RepairResult {
-    success: boolean;
-    durabilityRestored: number;
-    goldSpent: number;
-    materialsUsed: Record<MaterialId, number>;
-}
-export interface UpgradeResult {
-    success: boolean;
-    item: BlacksmithItem;
-    fromLevel: number;
-    toLevel: number;
-    destroyed: boolean;
-    downgraded: boolean;
-    bonusUnlocked?: UpgradeBonus;
-}
-export interface ReforgeResult {
-    success: boolean;
-    item: BlacksmithItem;
-    oldStats: Map<string, number>;
-    newStats: Map<string, number>;
-}
-export interface SalvageResult {
-    success: boolean;
-    materialsObtained: Record<MaterialId, number>;
-    bonusMaterials: Record<MaterialId, number>;
-}
-export type BlacksmithEventType = 'item-repaired' | 'item-upgraded' | 'upgrade-failed' | 'item-reforged' | 'item-salvaged' | 'item-destroyed' | 'material-obtained' | 'recipe-unlocked' | 'blacksmith-level-up';
-export interface BlacksmithEvent {
-    type: BlacksmithEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type BlacksmithEventCallback = (event: BlacksmithEvent) => void;
-export interface BlacksmithConfig {
-    maxUpgradeLevel: number;
-    maxEnhancementLevel: number;
-    maxReforges: number;
-    baseRepairCostPerDurability: number;
-    successRateBonus: number;
-    xpPerRepair: number;
-    xpPerUpgrade: number;
-    xpPerLevel: number;
-    maxLevel: number;
-    storageKey: string;
-}
-export declare const DEFAULT_BLACKSMITH_CONFIG: BlacksmithConfig;
-export declare class NiceBlacksmith {
-    private config;
-    private materials;
-    private upgradeRecipes;
-    private reforgeRecipes;
-    private salvageRecipes;
-    private repairRecipes;
-    private items;
-    private players;
-    private eventListeners;
-    constructor(config?: Partial<BlacksmithConfig>);
-    on(event: BlacksmithEventType, callback: BlacksmithEventCallback): () => void;
-    private emit;
-    registerMaterial(material: MaterialDefinition): void;
-    registerUpgradeRecipe(recipe: UpgradeRecipe): void;
-    registerReforgeRecipe(recipe: ReforgeRecipe): void;
-    registerSalvageRecipe(recipe: SalvageRecipe): void;
-    registerRepairRecipe(recipe: RepairRecipe): void;
-    getPlayer(playerId: string): PlayerBlacksmithData;
-    private createPlayerData;
-    registerItem(item: Omit<BlacksmithItem, 'bonusStats' | 'repairCount' | 'totalDurabilityRestored'>): BlacksmithItem;
-    getItem(itemId: string): BlacksmithItem | undefined;
-    addMaterial(playerId: string, materialId: MaterialId, count?: number): boolean;
-    removeMaterial(playerId: string, materialId: MaterialId, count?: number): boolean;
-    getMaterialCount(playerId: string, materialId: MaterialId): number;
-    hasMaterials(playerId: string, materials: Record<MaterialId, number>): boolean;
-    consumeMaterials(playerId: string, materials: Record<MaterialId, number>): boolean;
-    reduceDurability(itemId: string, amount?: number): number;
-    getDurabilityPercent(itemId: string): number;
-    isBroken(itemId: string): boolean;
-    getRepairCost(itemId: string): {
-        gold: number;
-        materials: Record<MaterialId, number>;
-    };
-    canRepair(playerId: string, itemId: string, gold: number): boolean;
-    repair(playerId: string, itemId: string, gold: number): RepairResult;
-    getAvailableUpgrades(itemId: string): UpgradeRecipe[];
-    canUpgrade(playerId: string, itemId: string, recipeId: RecipeId, gold: number): boolean;
-    upgrade(playerId: string, itemId: string, recipeId: RecipeId, gold: number): UpgradeResult;
-    private applyUpgradeBonus;
-    getAvailableReforges(itemId: string): ReforgeRecipe[];
-    canReforge(playerId: string, itemId: string, recipeId: RecipeId, gold: number): boolean;
-    reforge(playerId: string, itemId: string, recipeId: RecipeId, gold: number): ReforgeResult;
-    getSalvagePreview(itemId: string): SalvageResult | null;
-    salvage(playerId: string, itemId: string): SalvageResult;
-    addBlacksmithXP(playerId: string, xp: number): void;
-    getXPForLevel(level: number): number;
-    unlockRecipe(playerId: string, recipeId: RecipeId): boolean;
-    private rarityValue;
-    getMaterial(id: MaterialId): MaterialDefinition | undefined;
-    getAllMaterials(): MaterialDefinition[];
-    getUpgradeRecipe(id: RecipeId): UpgradeRecipe | undefined;
-    getAllUpgradeRecipes(): UpgradeRecipe[];
-    getStats(playerId: string): {
-        level: number;
-        xp: number;
-        xpNeeded: number;
-        itemsRepaired: number;
-        itemsUpgraded: number;
-        successRate: number;
-        longestStreak: number;
-    };
-    save(): void;
-    load(): void;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createBlacksmithSystem(config?: Partial<BlacksmithConfig>): NiceBlacksmith;

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

@@ -1,177 +0,0 @@
-export type BuffId = string;
-export type AuraId = string;
-export type BuffType = 'buff' | 'debuff' | 'aura' | 'hidden';
-export type StackBehavior = 'refresh' | 'add' | 'extend' | 'none';
-export type DispelType = 'magic' | 'curse' | 'poison' | 'disease' | 'physical' | 'none';
-export interface BuffDefinition {
-    id: BuffId;
-    name: string;
-    description: string;
-    type: BuffType;
-    dispelType: DispelType;
-    duration: number;
-    tickInterval?: number;
-    maxStacks: number;
-    stackBehavior: StackBehavior;
-    stacksPerApplication: number;
-    priority: number;
-    exclusive?: BuffId[];
-    exclusiveGroup?: string;
-    effects: BuffEffect[];
-    onApply?: BuffTrigger[];
-    onRemove?: BuffTrigger[];
-    onTick?: BuffTrigger[];
-    onStack?: BuffTrigger[];
-    icon: string;
-    vfx?: string;
-    color?: string;
-    hidden: boolean;
-    persistent: boolean;
-    dispellable: boolean;
-    stealable: boolean;
-    tags?: string[];
-}
-export interface BuffEffect {
-    type: 'stat_mod' | 'damage_over_time' | 'heal_over_time' | 'absorb' | 'immunity' | 'silence' | 'stun' | 'root' | 'slow' | 'haste' | 'stealth' | 'invulnerable' | 'custom';
-    stat?: string;
-    value: number;
-    isPercentage: boolean;
-    tickValue?: number;
-    scaling?: {
-        stat: string;
-        coefficient: number;
-    };
-    absorbType?: 'all' | 'physical' | 'magic' | string;
-    absorbAmount?: number;
-    movementMod?: number;
-    attackSpeedMod?: number;
-    castSpeedMod?: number;
-    effectData?: Record<string, unknown>;
-}
-export interface BuffTrigger {
-    type: 'damage' | 'heal' | 'apply_buff' | 'remove_buff' | 'spawn' | 'custom';
-    value?: number;
-    damageType?: string;
-    buffId?: BuffId;
-    targetType?: 'self' | 'source' | 'allies' | 'enemies';
-    triggerData?: Record<string, unknown>;
-}
-export interface ActiveBuff {
-    buffId: BuffId;
-    definition: BuffDefinition;
-    sourceId: string;
-    targetId: string;
-    stacks: number;
-    remainingDuration: number;
-    totalDuration: number;
-    nextTickAt: number;
-    absorbRemaining?: number;
-    appliedAt: number;
-    expiresAt: number;
-    computedEffects: ComputedBuffEffect[];
-}
-export interface ComputedBuffEffect {
-    effect: BuffEffect;
-    currentValue: number;
-    totalAbsorbed?: number;
-}
-export interface EntityBuffState {
-    entityId: string;
-    buffs: Map<BuffId, ActiveBuff>;
-    immunities: Set<string>;
-    statModifiers: Map<string, number>;
-    isStunned: boolean;
-    isRooted: boolean;
-    isSilenced: boolean;
-    isInvulnerable: boolean;
-    isStealthed: boolean;
-    totalBuffsApplied: number;
-    totalDebuffsApplied: number;
-}
-export interface AuraDefinition {
-    id: AuraId;
-    name: string;
-    description?: string;
-    radius: number;
-    maxAffected?: number;
-    tickInterval: number;
-    appliedBuffId: BuffId;
-    affectsAllies: boolean;
-    affectsEnemies: boolean;
-    affectsSelf: boolean;
-    vfx?: string;
-}
-export type BuffEventType = 'buff-applied' | 'buff-refreshed' | 'buff-stacked' | 'buff-removed' | 'buff-expired' | 'buff-dispelled' | 'buff-stolen' | 'buff-tick' | 'absorb-damage' | 'immunity-triggered';
-export interface BuffEvent {
-    type: BuffEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type BuffEventCallback = (event: BuffEvent) => void;
-export interface BuffConfig {
-    maxBuffs: number;
-    maxDebuffs: number;
-    maxHiddenBuffs: number;
-    updateInterval: number;
-    storageKey: string;
-}
-export declare const DEFAULT_BUFF_CONFIG: BuffConfig;
-export declare class NiceBuff {
-    private config;
-    private definitions;
-    private auras;
-    private entities;
-    private eventListeners;
-    private updateInterval?;
-    private onDamage?;
-    private onHeal?;
-    constructor(config?: Partial<BuffConfig>);
-    on(event: BuffEventType, callback: BuffEventCallback): () => void;
-    private emit;
-    setDamageHandler(handler: typeof this.onDamage): void;
-    setHealHandler(handler: typeof this.onHeal): void;
-    private startUpdateLoop;
-    private update;
-    private processTick;
-    registerBuff(definition: BuffDefinition): void;
-    registerAura(aura: AuraDefinition): void;
-    registerEntity(entityId: string): EntityBuffState;
-    unregisterEntity(entityId: string): void;
-    applyBuff(targetId: string, buffId: BuffId, sourceId: string, stacks?: number, durationOverride?: number): ActiveBuff | null;
-    private handleStacking;
-    removeBuff(entityId: string, buffId: BuffId): boolean;
-    private removeBuffInternal;
-    removeStacks(entityId: string, buffId: BuffId, stacks: number): boolean;
-    dispel(entityId: string, dispelType: DispelType, count?: number): BuffId[];
-    stealBuff(fromId: string, toId: string, buffId: BuffId): boolean;
-    clearBuffs(entityId: string, type?: BuffType): void;
-    absorbDamage(entityId: string, damage: number, damageType: string): {
-        absorbed: number;
-        remaining: number;
-        shields: BuffId[];
-    };
-    private processTriggers;
-    getBuff(id: BuffId): BuffDefinition | undefined;
-    getAllBuffDefinitions(): BuffDefinition[];
-    getActiveBuff(entityId: string, buffId: BuffId): ActiveBuff | undefined;
-    getActiveBuffs(entityId: string, type?: BuffType): ActiveBuff[];
-    getEntityState(entityId: string): EntityBuffState | undefined;
-    hasBuff(entityId: string, buffId: BuffId): boolean;
-    hasBuffWithTag(entityId: string, tag: string): boolean;
-    getStatModifier(entityId: string, stat: string): number;
-    isStunned(entityId: string): boolean;
-    isRooted(entityId: string): boolean;
-    isSilenced(entityId: string): boolean;
-    isInvulnerable(entityId: string): boolean;
-    isStealthed(entityId: string): boolean;
-    addImmunity(entityId: string, immunity: string): void;
-    removeImmunity(entityId: string, immunity: string): void;
-    isImmune(entityId: string, definition: BuffDefinition): boolean;
-    private computeEffects;
-    private updateEntityState;
-    private countBuffsByType;
-    private removeLowestPriorityBuff;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createBuffSystem(config?: Partial<BuffConfig>): NiceBuff;

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

@@ -1,207 +0,0 @@
-export type BuildingId = string;
-export type BlueprintId = string;
-export type EntityId = string;
-export type ResourceId = string;
-export interface GridPosition {
-    x: number;
-    y: number;
-}
-export interface WorldPosition {
-    x: number;
-    y: number;
-    z?: number;
-}
-export interface BuildingFootprint {
-    width: number;
-    height: number;
-    /** Custom shape cells (relative to origin) */
-    cells?: GridPosition[];
-    /** Rotation in degrees (0, 90, 180, 270) */
-    rotation?: number;
-}
-export type BuildingState = 'blueprint' | 'queued' | 'constructing' | 'active' | 'damaged' | 'destroyed' | 'upgrading' | 'paused';
-export interface ResourceCost {
-    resourceId: ResourceId;
-    amount: number;
-}
-export interface BuildingDefinition {
-    id: BlueprintId;
-    name: string;
-    description?: string;
-    icon?: string;
-    model?: string;
-    category?: string;
-    tags: string[];
-    /** Building size */
-    footprint: BuildingFootprint;
-    /** Can be rotated */
-    rotatable: boolean;
-    /** Construction time in seconds */
-    constructionTime: number;
-    /** Resource costs */
-    costs: ResourceCost[];
-    /** Required tech/research */
-    requirements?: string[];
-    /** Max instances (0 = unlimited) */
-    maxInstances: number;
-    /** Health */
-    maxHealth: number;
-    /** Can be upgraded */
-    upgradable: boolean;
-    /** Upgrade path */
-    upgradesTo?: BlueprintId;
-    /** Production/functionality */
-    production?: {
-        resourceId: ResourceId;
-        rate: number;
-    };
-    /** Storage capacity */
-    storage?: {
-        resourceId: ResourceId;
-        capacity: number;
-    }[];
-    /** Worker slots */
-    workerSlots?: number;
-    /** Power consumption */
-    powerConsumption?: number;
-    /** Power production */
-    powerProduction?: number;
-    /** Placement rules */
-    placementRules?: {
-        mustBeOnGround?: boolean;
-        mustBeNearWater?: boolean;
-        mustBeNearResource?: ResourceId;
-        minDistanceFromSame?: number;
-        maxDistanceFromHQ?: number;
-        requiresFoundation?: boolean;
-    };
-}
-export interface BuildingInstance {
-    id: BuildingId;
-    blueprintId: BlueprintId;
-    position: GridPosition;
-    worldPosition: WorldPosition;
-    rotation: number;
-    state: BuildingState;
-    health: number;
-    constructionProgress: number;
-    upgradeProgress?: number;
-    workersAssigned: EntityId[];
-    createdAt: number;
-    completedAt?: number;
-    ownerId?: EntityId;
-    metadata?: Record<string, unknown>;
-}
-export interface BuildQueueItem {
-    id: string;
-    blueprintId: BlueprintId;
-    position: GridPosition;
-    rotation: number;
-    priority: number;
-    queuedAt: number;
-}
-export interface PlacementPreview {
-    blueprintId: BlueprintId;
-    position: GridPosition;
-    rotation: number;
-    isValid: boolean;
-    blockedCells: GridPosition[];
-    invalidReasons: string[];
-}
-export type CellType = 'empty' | 'building' | 'obstacle' | 'water' | 'resource';
-export interface GridCell {
-    position: GridPosition;
-    type: CellType;
-    buildingId?: BuildingId;
-    passable: boolean;
-    metadata?: Record<string, unknown>;
-}
-export type BuildingEventType = 'building-placed' | 'building-queued' | 'construction-started' | 'construction-progress' | 'construction-completed' | 'building-damaged' | 'building-destroyed' | 'building-repaired' | 'upgrade-started' | 'upgrade-completed' | 'worker-assigned' | 'worker-removed' | 'building-removed' | 'placement-invalid';
-export interface BuildingEvent {
-    type: BuildingEventType;
-    timestamp: number;
-    buildingId?: BuildingId;
-    data?: unknown;
-}
-export type BuildingEventCallback = (event: BuildingEvent) => void;
-export interface BuildingConfig {
-    /** Grid cell size in world units */
-    gridSize: number;
-    /** World bounds */
-    worldBounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    /** Show grid */
-    showGrid: boolean;
-    /** Enable instant build (debug) */
-    instantBuild: boolean;
-    /** Construction speed multiplier */
-    constructionSpeedMultiplier: number;
-    /** Allow overlapping */
-    allowOverlap: boolean;
-    /** Max build queue */
-    maxBuildQueue: number;
-    /** Construction range from builder */
-    constructionRange: number;
-    /** Auto-start queued construction */
-    autoStartConstruction: boolean;
-}
-export declare const DEFAULT_BUILDING_CONFIG: BuildingConfig;
-export declare class NiceBuilding {
-    private config;
-    private blueprints;
-    private buildings;
-    private grid;
-    private buildQueue;
-    private idCounter;
-    private eventListeners;
-    /** Resource checker function */
-    private resourceChecker?;
-    /** Resource spender function */
-    private resourceSpender?;
-    constructor(config?: Partial<BuildingConfig>);
-    private initializeGrid;
-    private cellKey;
-    on(event: BuildingEventType, callback: BuildingEventCallback): () => void;
-    private emit;
-    setResourceChecker(checker: (costs: ResourceCost[]) => boolean): void;
-    setResourceSpender(spender: (costs: ResourceCost[]) => boolean): void;
-    registerBlueprint(blueprint: BuildingDefinition): void;
-    unregisterBlueprint(blueprintId: BlueprintId): void;
-    getBlueprint(blueprintId: BlueprintId): BuildingDefinition | undefined;
-    getBlueprints(): BuildingDefinition[];
-    getBlueprintsByCategory(category: string): BuildingDefinition[];
-    getCell(gridX: number, gridY: number): GridCell | undefined;
-    setCellType(gridX: number, gridY: number, type: CellType, passable?: boolean): void;
-    worldToGrid(worldPos: WorldPosition): GridPosition;
-    gridToWorld(gridPos: GridPosition): WorldPosition;
-    private getFootprintCells;
-    private rotateCell;
-    canPlace(blueprintId: BlueprintId, position: GridPosition, rotation?: number): PlacementPreview;
-    placeBuilding(blueprintId: BlueprintId, position: GridPosition, rotation?: number, ownerId?: EntityId): BuildingId | null;
-    queueBuilding(blueprintId: BlueprintId, position: GridPosition, rotation?: number, priority?: number): string | null;
-    dequeueBuilding(queueId: string): void;
-    getNextQueued(): BuildQueueItem | undefined;
-    getBuildQueue(): BuildQueueItem[];
-    processQueue(): BuildingId | null;
-    updateConstruction(deltaTime: number): void;
-    getBuilding(buildingId: BuildingId): BuildingInstance | undefined;
-    getAllBuildings(): BuildingInstance[];
-    getBuildingsByBlueprint(blueprintId: BlueprintId): BuildingInstance[];
-    getBuildingsByOwner(ownerId: EntityId): BuildingInstance[];
-    getBuildingAt(position: GridPosition): BuildingInstance | undefined;
-    damageBuilding(buildingId: BuildingId, damage: number): void;
-    repairBuilding(buildingId: BuildingId, amount: number): void;
-    startUpgrade(buildingId: BuildingId): boolean;
-    cancelUpgrade(buildingId: BuildingId): void;
-    assignWorker(buildingId: BuildingId, workerId: EntityId): boolean;
-    removeWorker(buildingId: BuildingId, workerId: EntityId): void;
-    removeBuilding(buildingId: BuildingId, refundResources?: boolean): void;
-    update(deltaTime: number): void;
-    clear(): void;
-    destroy(): void;
-}
-export declare function createBuildingSystem(config?: Partial<BuildingConfig>): NiceBuilding;