@nice2dev/game-engine 1.1.5 → 1.1.7

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

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

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

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

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