@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,193 +0,0 @@
-export type AuraId = string;
-export type ZoneAuraId = string;
-export type AuraShape = 'circle' | 'cone' | 'line' | 'rectangle' | 'ring';
-export type AuraTarget = 'allies' | 'enemies' | 'all' | 'self' | 'party' | 'raid';
-export interface Position {
-    x: number;
-    y: number;
-    z?: number;
-}
-export interface ShapeParams {
-    radius?: number;
-    innerRadius?: number;
-    angle?: number;
-    direction?: number;
-    length?: number;
-    width?: number;
-    width2?: number;
-    height?: number;
-}
-export interface AuraDefinition {
-    id: AuraId;
-    name: string;
-    description: string;
-    shape: AuraShape;
-    shapeParams: ShapeParams;
-    targets: AuraTarget;
-    maxAffected?: number;
-    pulseInterval: number;
-    duration: number;
-    effects: AuraEffect[];
-    appliedBuffId?: string;
-    removeBuffOnExit: boolean;
-    followsSource: boolean;
-    moveSpeed?: number;
-    moveDirection?: number;
-    stackable: boolean;
-    stackId?: string;
-    maxStacks?: number;
-    icon: string;
-    vfx?: string;
-    groundDecal?: string;
-    color?: string;
-    ambientSound?: string;
-    pulseSound?: string;
-    requiresLineOfSight: boolean;
-    blockedByTerrain: boolean;
-    tags?: string[];
-}
-export interface AuraEffect {
-    type: 'damage' | 'heal' | 'buff' | 'debuff' | 'pull' | 'push' | 'slow' | 'haste' | 'stat_mod' | 'resource' | 'custom';
-    value: number;
-    isPercentage: boolean;
-    damageType?: string;
-    scaling?: {
-        stat: string;
-        coefficient: number;
-    };
-    buffId?: string;
-    force?: number;
-    stat?: string;
-    resourceType?: string;
-    effectData?: Record<string, unknown>;
-}
-export interface ActiveAura {
-    id: string;
-    auraId: AuraId;
-    definition: AuraDefinition;
-    sourceId: string;
-    position: Position;
-    direction: number;
-    active: boolean;
-    remainingDuration: number;
-    nextPulseAt: number;
-    currentStacks: number;
-    createdAt: number;
-    expiresAt: number;
-    entitiesInside: Set<string>;
-    entitiesAffected: Map<string, number>;
-    totalPulses: number;
-}
-export interface ZoneAuraDefinition {
-    id: ZoneAuraId;
-    name: string;
-    description?: string;
-    bounds: {
-        minX: number;
-        minY: number;
-        maxX: number;
-        maxY: number;
-    };
-    effects: AuraEffect[];
-    pulseInterval: number;
-    targets: AuraTarget;
-    vfx?: string;
-    weatherEffect?: string;
-}
-export interface ActiveZoneAura {
-    id: string;
-    zoneAuraId: ZoneAuraId;
-    definition: ZoneAuraDefinition;
-    active: boolean;
-    entitiesInside: Set<string>;
-    nextPulseAt: number;
-}
-export interface EntityAuraState {
-    entityId: string;
-    position: Position;
-    faction: 'ally' | 'enemy' | 'neutral';
-    ownedAuras: Set<string>;
-    affectedBy: Map<string, AffectingAura>;
-    totalStatMods: Map<string, number>;
-}
-export interface AffectingAura {
-    auraInstanceId: string;
-    stacks: number;
-    appliedAt: number;
-    lastPulseAt: number;
-}
-export type AuraEventType = 'aura-created' | 'aura-destroyed' | 'aura-pulse' | 'aura-expired' | 'entity-entered' | 'entity-exited' | 'entity-affected' | 'zone-aura-entered' | 'zone-aura-exited';
-export interface AuraEvent {
-    type: AuraEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type AuraEventCallback = (event: AuraEvent) => void;
-export interface AuraConfig {
-    updateInterval: number;
-    maxAurasPerSource: number;
-    maxActiveAuras: number;
-    defaultPulseInterval: number;
-    storageKey: string;
-}
-export declare const DEFAULT_AURA_CONFIG: AuraConfig;
-export declare class NiceAura {
-    private config;
-    private definitions;
-    private zoneDefinitions;
-    private activeAuras;
-    private activeZoneAuras;
-    private entities;
-    private eventListeners;
-    private updateInterval?;
-    private onDamage?;
-    private onHeal?;
-    private onApplyBuff?;
-    private onRemoveBuff?;
-    constructor(config?: Partial<AuraConfig>);
-    on(event: AuraEventType, callback: AuraEventCallback): () => void;
-    private emit;
-    setDamageHandler(handler: typeof this.onDamage): void;
-    setHealHandler(handler: typeof this.onHeal): void;
-    setBuffHandler(apply: typeof this.onApplyBuff, remove: typeof this.onRemoveBuff): void;
-    private startUpdateLoop;
-    private update;
-    registerAura(definition: AuraDefinition): void;
-    registerZoneAura(definition: ZoneAuraDefinition): void;
-    registerEntity(entityId: string, position: Position, faction: EntityAuraState['faction']): void;
-    unregisterEntity(entityId: string): void;
-    updateEntityPosition(entityId: string, position: Position): void;
-    updateEntityFaction(entityId: string, faction: EntityAuraState['faction']): void;
-    createAura(auraId: AuraId, sourceId: string, position: Position, direction?: number, stacks?: number): ActiveAura | null;
-    destroyAura(instanceId: string): boolean;
-    activateZoneAura(zoneAuraId: ZoneAuraId): ActiveZoneAura | null;
-    deactivateZoneAura(instanceId: string): void;
-    private updateEntitiesInAura;
-    private updateEntitiesInZone;
-    private isValidTarget;
-    private isValidZoneTarget;
-    private isInShape;
-    private isInBounds;
-    private handleEntityEnter;
-    private handleEntityExit;
-    private pulseAura;
-    private pulseZoneAura;
-    private applyEffectsToEntity;
-    private applyEffect;
-    addStacks(instanceId: string, stacks: number): number;
-    removeStacks(instanceId: string, stacks: number): number;
-    getAura(id: AuraId): AuraDefinition | undefined;
-    getAllAuras(): AuraDefinition[];
-    getActiveAura(instanceId: string): ActiveAura | undefined;
-    getActiveAuras(): ActiveAura[];
-    getAurasFromSource(sourceId: string): ActiveAura[];
-    getAurasAffectingEntity(entityId: string): ActiveAura[];
-    getEntitiesInAura(instanceId: string): string[];
-    isEntityInAura(entityId: string, instanceId: string): boolean;
-    getEntityStatMods(entityId: string): Map<string, number>;
-    private distanceTo;
-    private normalizeAngle;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createAuraSystem(config?: Partial<AuraConfig>): NiceAura;

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

@@ -1,158 +0,0 @@
-export type BankId = string;
-export type TabId = string;
-export type StoredItemId = string;
-export interface BankDefinition {
-    id: BankId;
-    name: string;
-    description?: string;
-    defaultTabs: number;
-    maxTabs: number;
-    slotsPerTab: number;
-    supportsStacking: boolean;
-    supportsCurrency: boolean;
-    supportsSharedStash: boolean;
-    npcId?: string;
-    locationIds?: string[];
-    anywhereAccess: boolean;
-    tabPurchaseCosts: number[];
-    depositFee?: number;
-    withdrawFee?: number;
-    levelRequired?: number;
-    questRequired?: string;
-    icon?: string;
-}
-export interface BankTab {
-    id: TabId;
-    bankId: BankId;
-    index: number;
-    name: string;
-    icon?: string;
-    color?: string;
-    slots: number;
-    items: Map<number, StoredItem>;
-    locked: boolean;
-    purchasedAt?: number;
-}
-export interface StoredItem {
-    id: StoredItemId;
-    itemId: string;
-    slotIndex: number;
-    quantity: number;
-    maxStack: number;
-    depositedAt: number;
-    depositedBy: string;
-    itemData?: Record<string, unknown>;
-}
-export interface StoredCurrency {
-    currencyType: string;
-    amount: number;
-    depositedAt: number;
-    lastModified: number;
-}
-export interface PlayerBankState {
-    playerId: string;
-    banks: Map<BankId, PlayerBankInstance>;
-    sharedStash?: SharedStash;
-    totalDeposits: number;
-    totalWithdrawals: number;
-}
-export interface PlayerBankInstance {
-    bankId: BankId;
-    tabs: BankTab[];
-    currencies: Map<string, StoredCurrency>;
-    totalItemsStored: number;
-    totalCurrencyStored: number;
-    lastAccessed: number;
-}
-export interface SharedStash {
-    tabs: BankTab[];
-    currencies: Map<string, StoredCurrency>;
-    maxTabs: number;
-    slotsPerTab: number;
-}
-export interface BankTransaction {
-    type: 'deposit' | 'withdraw' | 'move' | 'currency_deposit' | 'currency_withdraw';
-    playerId: string;
-    bankId: BankId;
-    tabId?: TabId;
-    itemId?: string;
-    quantity?: number;
-    fromSlot?: number;
-    toSlot?: number;
-    currencyType?: string;
-    amount?: number;
-    timestamp: number;
-    fee?: number;
-}
-export interface TransactionResult {
-    success: boolean;
-    error?: string;
-    transaction?: BankTransaction;
-    newQuantity?: number;
-    newSlot?: number;
-}
-export type BankEventType = 'bank-accessed' | 'item-deposited' | 'item-withdrawn' | 'item-moved' | 'currency-deposited' | 'currency-withdrawn' | 'tab-unlocked' | 'tab-renamed' | 'stash-accessed';
-export interface BankEvent {
-    type: BankEventType;
-    timestamp: number;
-    data?: unknown;
-}
-export type BankEventCallback = (event: BankEvent) => void;
-export interface BankConfig {
-    enableSharedStash: boolean;
-    sharedStashTabs: number;
-    sharedStashSlotsPerTab: number;
-    enableCurrencyStorage: boolean;
-    maxCurrencyPerType: number;
-    transactionHistoryLimit: number;
-    storageKey: string;
-}
-export declare const DEFAULT_BANK_CONFIG: BankConfig;
-export declare class NiceBank {
-    private config;
-    private banks;
-    private playerStates;
-    private transactionHistory;
-    private eventListeners;
-    private onDeductCurrency?;
-    private onAddItem?;
-    private onRemoveItem?;
-    constructor(config?: Partial<BankConfig>);
-    on(event: BankEventType, callback: BankEventCallback): () => void;
-    private emit;
-    setCurrencyHandler(handler: typeof this.onDeductCurrency): void;
-    setAddItemHandler(handler: typeof this.onAddItem): void;
-    setRemoveItemHandler(handler: typeof this.onRemoveItem): void;
-    registerBank(bank: BankDefinition): void;
-    accessBank(playerId: string, bankId: BankId): PlayerBankInstance | null;
-    private createBankInstance;
-    unlockTab(playerId: string, bankId: BankId): TransactionResult;
-    renameTab(playerId: string, bankId: BankId, tabIndex: number, name: string): boolean;
-    depositItem(playerId: string, bankId: BankId, tabIndex: number, itemId: string, quantity: number, itemData?: Record<string, unknown>, targetSlot?: number): TransactionResult;
-    withdrawItem(playerId: string, bankId: BankId, tabIndex: number, slot: number, quantity?: number): TransactionResult;
-    moveItem(playerId: string, bankId: BankId, fromTab: number, fromSlot: number, toTab: number, toSlot: number): TransactionResult;
-    depositCurrency(playerId: string, bankId: BankId, currencyType: string, amount: number): TransactionResult;
-    withdrawCurrency(playerId: string, bankId: BankId, currencyType: string, amount: number): TransactionResult;
-    getSharedStash(playerId: string): SharedStash | null;
-    getBank(id: BankId): BankDefinition | undefined;
-    getAllBanks(): BankDefinition[];
-    getPlayerBankState(playerId: string): PlayerBankState | undefined;
-    getBankInstance(playerId: string, bankId: BankId): PlayerBankInstance | undefined;
-    getTabContents(playerId: string, bankId: BankId, tabIndex: number): StoredItem[];
-    getStoredCurrency(playerId: string, bankId: BankId, currencyType: string): number;
-    getAllStoredCurrencies(playerId: string, bankId: BankId): StoredCurrency[];
-    getTotalItems(playerId: string, bankId: BankId): number;
-    getTransactionHistory(playerId: string, limit?: number): BankTransaction[];
-    findItemInBank(playerId: string, bankId: BankId, itemId: string): Array<{
-        tabIndex: number;
-        slot: number;
-        item: StoredItem;
-    }>;
-    private getOrCreatePlayerState;
-    private recordTransaction;
-    private save;
-    private load;
-    reset(): void;
-    destroy(): void;
-}
-export declare function createBankSystem(config?: Partial<BankConfig>): NiceBank;

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

@@ -1,150 +0,0 @@
-export type SeasonId = string;
-export type RewardId = string;
-export type ChallengeId = string;
-export type ChallengeType = 'daily' | 'weekly' | 'seasonal' | 'special';
-export type ChallengeStatus = 'locked' | 'active' | 'completed' | 'claimed';
-export type RewardType = 'item' | 'currency' | 'cosmetic' | 'experience' | 'title' | 'emote';
-export interface BattlePassReward {
-    id: RewardId;
-    level: number;
-    isPremium: boolean;
-    type: RewardType;
-    itemId: string;
-    quantity: number;
-    name: string;
-    description?: string;
-    icon?: string;
-    rarity?: string;
-}
-export interface ChallengeObjective {
-    type: string;
-    target: number;
-    current: number;
-    description: string;
-}
-export interface Challenge {
-    id: ChallengeId;
-    name: string;
-    description: string;
-    type: ChallengeType;
-    objectives: ChallengeObjective[];
-    xpReward: number;
-    bonusReward?: {
-        type: string;
-        itemId: string;
-        quantity: number;
-    };
-    expiresAt?: number;
-    unlocksAt?: number;
-    repeatLimit?: number;
-    repeatCount: number;
-    status: ChallengeStatus;
-}
-export interface SeasonDefinition {
-    id: SeasonId;
-    name: string;
-    description: string;
-    theme: string;
-    startDate: Date | number;
-    endDate: Date | number;
-    maxLevel: number;
-    xpPerLevel: number | number[];
-    premiumPrice: number;
-    premiumCurrency: string;
-    rewards: BattlePassReward[];
-    challenges: Omit<Challenge, 'status' | 'repeatCount'>[];
-    banner?: string;
-    icon?: string;
-    catchUpEnabled?: boolean;
-    catchUpMultiplier?: number;
-    xpBoostAvailable?: boolean;
-}
-export interface SeasonProgress {
-    seasonId: SeasonId;
-    level: number;
-    currentXp: number;
-    totalXp: number;
-    isPremium: boolean;
-    premiumPurchaseDate?: number;
-    claimedRewards: Set<RewardId>;
-    challenges: Map<ChallengeId, Challenge>;
-    activeBooster?: {
-        multiplier: number;
-        expiresAt: number;
-    };
-    dailyChallengesCompleted: number;
-    weeklyChallengesCompleted: number;
-    lastDailyReset: string;
-    lastWeeklyReset: string;
-}
-export type BattlePassEventType = 'season-started' | 'season-ended' | 'xp-gained' | 'level-up' | 'reward-claimed' | 'premium-unlocked' | 'challenge-progress' | 'challenge-completed' | 'challenge-claimed' | 'booster-activated' | 'booster-expired';
-export interface BattlePassEvent {
-    type: BattlePassEventType;
-    timestamp: number;
-    seasonId: SeasonId;
-    data?: unknown;
-}
-export type BattlePassEventCallback = (event: BattlePassEvent) => void;
-export interface BattlePassConfig {
-    dailyResetHour: number;
-    weeklyResetDay: number;
-    xpPerChallengeCompletion: number;
-    maxDailyChallenges: number;
-    maxWeeklyChallenges: number;
-    storageKey: string;
-}
-export declare const DEFAULT_BATTLEPASS_CONFIG: BattlePassConfig;
-export declare class NiceBattlePass {
-    private config;
-    private seasons;
-    private progress;
-    private currentSeasonId;
-    private eventListeners;
-    constructor(config?: Partial<BattlePassConfig>);
-    on(event: BattlePassEventType, callback: BattlePassEventCallback): () => void;
-    private emit;
-    registerSeason(season: SeasonDefinition): void;
-    private initializeProgress;
-    startSeason(seasonId: SeasonId): boolean;
-    endSeason(): void;
-    unlockPremium(seasonId?: SeasonId): boolean;
-    isPremium(seasonId?: SeasonId): boolean;
-    addXp(amount: number, seasonId?: SeasonId): {
-        xpGained: number;
-        levelsGained: number;
-    };
-    private getXpForLevel;
-    private getExpectedLevel;
-    getAvailableRewards(seasonId?: SeasonId): BattlePassReward[];
-    claimReward(rewardId: RewardId, seasonId?: SeasonId): BattlePassReward | null;
-    claimAllRewards(seasonId?: SeasonId): BattlePassReward[];
-    updateChallengeProgress(challengeId: ChallengeId, objectiveIndex: number, progress: number, seasonId?: SeasonId): boolean;
-    claimChallenge(challengeId: ChallengeId, seasonId?: SeasonId): {
-        xp: number;
-        bonus?: unknown;
-    } | null;
-    getActiveChallenges(type?: ChallengeType, seasonId?: SeasonId): Challenge[];
-    activateBooster(multiplier: number, durationMs: number, seasonId?: SeasonId): boolean;
-    checkResets(seasonId?: SeasonId): void;
-    private getWeekStart;
-    getCurrentSeason(): SeasonDefinition | undefined;
-    getProgress(seasonId?: SeasonId): SeasonProgress | undefined;
-    getLevelProgress(seasonId?: SeasonId): {
-        level: number;
-        currentXp: number;
-        requiredXp: number;
-        progress: number;
-        maxLevel: number;
-    } | null;
-    getSeasonTimeRemaining(seasonId?: SeasonId): {
-        days: number;
-        hours: number;
-        minutes: number;
-        total: number;
-    } | null;
-    private save;
-    private load;
-    reset(seasonId?: SeasonId): void;
-    destroy(): void;
-}
-export declare function createBattlePassSystem(config?: Partial<BattlePassConfig>): NiceBattlePass;

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

@@ -1,160 +0,0 @@
-import { EventEmitter } from 'events';
-export type NodeId = string;
-export type TreeId = string;
-export type BlackboardKey = string;
-export type NodeStatus = 'success' | 'failure' | 'running';
-export type BehaviorNode = SequenceNode | SelectorNode | ParallelNode | InverterNode | RepeaterNode | SucceederNode | UntilFailNode | UntilSuccessNode | CooldownNode | ActionNode | ConditionNode | WaitNode | SubtreeNode;
-export interface SequenceNode {
-    type: 'sequence';
-    id: NodeId;
-    children: BehaviorNode[];
-}
-export interface SelectorNode {
-    type: 'selector';
-    id: NodeId;
-    children: BehaviorNode[];
-}
-export interface ParallelNode {
-    type: 'parallel';
-    id: NodeId;
-    successThreshold: number;
-    children: BehaviorNode[];
-}
-export interface InverterNode {
-    type: 'inverter';
-    id: NodeId;
-    child: BehaviorNode;
-}
-export interface RepeaterNode {
-    type: 'repeater';
-    id: NodeId;
-    times: number;
-    child: BehaviorNode;
-}
-export interface SucceederNode {
-    type: 'succeeder';
-    id: NodeId;
-    child: BehaviorNode;
-}
-export interface UntilFailNode {
-    type: 'until-fail';
-    id: NodeId;
-    child: BehaviorNode;
-}
-export interface UntilSuccessNode {
-    type: 'until-success';
-    id: NodeId;
-    child: BehaviorNode;
-}
-export interface CooldownNode {
-    type: 'cooldown';
-    id: NodeId;
-    cooldown: number;
-    child: BehaviorNode;
-}
-export interface ActionNode {
-    type: 'action';
-    id: NodeId;
-    name: string;
-    action: (blackboard: Blackboard) => NodeStatus | Promise<NodeStatus>;
-}
-export interface ConditionNode {
-    type: 'condition';
-    id: NodeId;
-    name: string;
-    condition: (blackboard: Blackboard) => boolean;
-}
-export interface WaitNode {
-    type: 'wait';
-    id: NodeId;
-    duration: number;
-}
-export interface SubtreeNode {
-    type: 'subtree';
-    id: NodeId;
-    treeId: TreeId;
-}
-export declare class Blackboard {
-    private data;
-    get<T>(key: BlackboardKey): T | undefined;
-    set<T>(key: BlackboardKey, value: T): void;
-    has(key: BlackboardKey): boolean;
-    delete(key: BlackboardKey): boolean;
-    clear(): void;
-    keys(): BlackboardKey[];
-    toJSON(): Record<string, unknown>;
-    fromJSON(data: Record<string, unknown>): void;
-}
-export interface ExecutionContext {
-    blackboard: Blackboard;
-    runningNodes: Set<NodeId>;
-    nodeState: Map<NodeId, NodeExecutionState>;
-    treeSystem: NiceBehavior;
-}
-export interface NodeExecutionState {
-    runCount?: number;
-    lastRunTime?: number;
-    waitStartTime?: number;
-    parallelResults?: NodeStatus[];
-    currentChildIndex?: number;
-}
-export type BehaviorEventType = 'node-started' | 'node-completed' | 'tree-started' | 'tree-completed';
-export interface BehaviorEvent {
-    type: BehaviorEventType;
-    treeId?: TreeId;
-    nodeId?: NodeId;
-    status?: NodeStatus;
-}
-export interface BehaviorConfig {
-    tickRate?: number;
-    maxIterationsPerTick?: number;
-}
-export declare const DEFAULT_BEHAVIOR_CONFIG: BehaviorConfig;
-export declare class NiceBehavior extends EventEmitter {
-    private trees;
-    private activeAgents;
-    private nextNodeId;
-    private config;
-    constructor(config?: Partial<BehaviorConfig>);
-    registerTree(treeId: TreeId, root: BehaviorNode): void;
-    unregisterTree(treeId: TreeId): boolean;
-    hasTree(treeId: TreeId): boolean;
-    getTree(treeId: TreeId): BehaviorNode | undefined;
-    attachTree(agentId: string, treeId: TreeId): boolean;
-    detachTree(agentId: string): boolean;
-    getBlackboard(agentId: string): Blackboard | undefined;
-    tick(agentId: string, treeId: TreeId): NodeStatus;
-    tickAll(treeId: TreeId): Map<string, NodeStatus>;
-    private executeNode;
-    private executeSequence;
-    private executeSelector;
-    private executeParallel;
-    private executeInverter;
-    private executeRepeater;
-    private executeSucceeder;
-    private executeUntilFail;
-    private executeUntilSuccess;
-    private executeCooldown;
-    private executeAction;
-    private executeCondition;
-    private executeWait;
-    private executeSubtree;
-    private getNodeState;
-    generateNodeId(): NodeId;
-    sequence(...children: BehaviorNode[]): SequenceNode;
-    selector(...children: BehaviorNode[]): SelectorNode;
-    parallel(successThreshold: number, ...children: BehaviorNode[]): ParallelNode;
-    inverter(child: BehaviorNode): InverterNode;
-    repeater(times: number, child: BehaviorNode): RepeaterNode;
-    succeeder(child: BehaviorNode): SucceederNode;
-    untilFail(child: BehaviorNode): UntilFailNode;
-    untilSuccess(child: BehaviorNode): UntilSuccessNode;
-    cooldown(cooldown: number, child: BehaviorNode): CooldownNode;
-    action(name: string, action: (blackboard: Blackboard) => NodeStatus | Promise<NodeStatus>): ActionNode;
-    condition(name: string, condition: (blackboard: Blackboard) => boolean): ConditionNode;
-    wait(duration: number): WaitNode;
-    subtree(treeId: TreeId): SubtreeNode;
-}
-export declare function createBehaviorTree(config?: Partial<BehaviorConfig>): NiceBehavior;
-export declare function createBlackboard(): Blackboard;
-export default NiceBehavior;