@holoscript/engine 6.0.3 → 6.0.4

package/dist/index-nMvkoRm8.d.ts

@@ -0,0 +1,405 @@
+/**
+ * CombatManager.ts
+ *
+ * Combat orchestration: hitbox/hurtbox, combo system,
+ * cooldowns, targeting, and combat state.
+ *
+ * @module combat
+ */
+interface HitBox {
+    id: string;
+    ownerId: string;
+    position: [number, number, number];
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    active: boolean;
+    damage: number;
+    damageType: string;
+    knockback: number;
+}
+interface HurtBox {
+    id: string;
+    ownerId: string;
+    position: [number, number, number];
+    size: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    active: boolean;
+}
+interface ComboStep$1 {
+    name: string;
+    input: string;
+    damage: number;
+    window: number;
+    hitboxId?: string;
+}
+interface ComboChain {
+    id: string;
+    steps: ComboStep$1[];
+    currentStep: number;
+    timer: number;
+    completed: boolean;
+}
+interface Cooldown {
+    abilityId: string;
+    duration: number;
+    remaining: number;
+}
+interface CombatTarget {
+    entityId: string;
+    position: [number, number, number];
+    priority: number;
+    distance: number;
+}
+declare class CombatManager {
+    private hitboxes;
+    private hurtboxes;
+    private combos;
+    private cooldowns;
+    private hitLog;
+    addHitBox(hitbox: HitBox): void;
+    addHurtBox(hurtbox: HurtBox): void;
+    removeHitBox(id: string): void;
+    removeHurtBox(id: string): void;
+    setHitBoxActive(id: string, active: boolean): void;
+    checkCollisions(): Array<{
+        hitbox: HitBox;
+        hurtbox: HurtBox;
+    }>;
+    private aabbOverlap;
+    registerCombo(id: string, steps: ComboStep$1[]): ComboChain;
+    advanceCombo(comboId: string, input: string): {
+        hit: boolean;
+        completed: boolean;
+        step: number;
+    };
+    updateCombos(dt: number): void;
+    resetCombo(comboId: string): void;
+    startCooldown(abilityId: string, duration: number): void;
+    isOnCooldown(abilityId: string): boolean;
+    getCooldownRemaining(abilityId: string): number;
+    updateCooldowns(dt: number): void;
+    findTargets(position: [number, number, number], candidates: Array<{
+        entityId: string;
+        position: [number, number, number];
+        priority?: number;
+    }>, maxRange: number): CombatTarget[];
+    getHitLog(): typeof this.hitLog;
+    getHitBoxCount(): number;
+    getHurtBoxCount(): number;
+}
+
+/**
+ * ComboTracker.ts
+ *
+ * Input combo tracking: sequence matching, timing windows,
+ * chain progression, and reset/timeout handling.
+ *
+ * @module combat
+ */
+interface ComboStep {
+    input: string;
+    maxDelay: number;
+}
+interface ComboDefinition {
+    id: string;
+    name: string;
+    steps: ComboStep[];
+    reward: string;
+}
+interface ComboState {
+    comboId: string;
+    currentStep: number;
+    lastInputTime: number;
+    completed: boolean;
+}
+declare class ComboTracker {
+    private combos;
+    private activeStates;
+    private completedCombos;
+    private currentTime;
+    registerCombo(combo: ComboDefinition): void;
+    pushInput(input: string, timestamp: number): string | null;
+    tick(timestamp: number): void;
+    getActiveComboCount(): number;
+    getCompletedCombos(): string[];
+    reset(): void;
+}
+
+/**
+ * DamageSystem.ts
+ *
+ * Damage calculation: damage types, resistances, critical hits,
+ * damage-over-time, armor penetration, and damage events.
+ *
+ * @module combat
+ */
+type DamageType = 'physical' | 'fire' | 'ice' | 'lightning' | 'poison' | 'holy' | 'dark' | 'true';
+interface DamageInstance {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    baseDamage: number;
+    type: DamageType;
+    isCritical: boolean;
+    finalDamage: number;
+    timestamp: number;
+}
+interface Resistances {
+    physical: number;
+    fire: number;
+    ice: number;
+    lightning: number;
+    poison: number;
+    holy: number;
+    dark: number;
+}
+interface DotEffect {
+    id: string;
+    sourceId: string;
+    targetId: string;
+    type: DamageType;
+    damagePerTick: number;
+    tickInterval: number;
+    duration: number;
+    elapsed: number;
+    lastTick: number;
+    stacks: number;
+}
+interface DamageConfig {
+    critChance: number;
+    critMultiplier: number;
+    armorPenetration: number;
+    globalMultiplier: number;
+}
+declare class DamageSystem {
+    private config;
+    private damageLog;
+    private dots;
+    private resistances;
+    private callbacks;
+    setConfig(config: Partial<DamageConfig>): void;
+    getConfig(): DamageConfig;
+    setResistances(entityId: string, res: Partial<Resistances>): void;
+    getResistances(entityId: string): Resistances;
+    calculateDamage(sourceId: string, targetId: string, baseDamage: number, type: DamageType, forceCrit?: boolean): DamageInstance;
+    applyDoT(sourceId: string, targetId: string, type: DamageType, damagePerTick: number, tickInterval: number, duration: number, stacks?: number): DotEffect;
+    updateDoTs(dt: number): DamageInstance[];
+    getActiveDoTs(targetId?: string): DotEffect[];
+    onDamage(callback: (dmg: DamageInstance) => void): void;
+    getDamageLog(limit?: number): DamageInstance[];
+    getTotalDamageDealt(sourceId: string): number;
+    clearLog(): void;
+}
+
+/**
+ * HitboxSystem.ts
+ *
+ * Hitbox/hurtbox management: active frame windows,
+ * hit registration with deduplication, and knockback vectors.
+ *
+ * @module combat
+ */
+interface Hitbox {
+    id: string;
+    ownerId: string;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    depth: number;
+    damage: number;
+    knockbackX: number;
+    knockbackY: number;
+    activeStart: number;
+    activeEnd: number;
+    group: string;
+}
+interface Hurtbox {
+    id: string;
+    entityId: string;
+    x: number;
+    y: number;
+    z: number;
+    width: number;
+    height: number;
+    depth: number;
+}
+interface HitEvent {
+    hitboxId: string;
+    hurtboxId: string;
+    attackerId: string;
+    defenderId: string;
+    damage: number;
+    knockbackX: number;
+    knockbackY: number;
+}
+declare class HitboxSystem {
+    private hitboxes;
+    private hurtboxes;
+    private currentFrame;
+    private hitLog;
+    private events;
+    addHitbox(hb: Hitbox): void;
+    addHurtbox(hb: Hurtbox): void;
+    removeHitbox(id: string): void;
+    removeHurtbox(id: string): void;
+    update(frame: number): HitEvent[];
+    private overlaps;
+    clearHitLog(): void;
+    getHitCount(): number;
+    getLastEvents(): HitEvent[];
+}
+
+/**
+ * ProjectileSystem.ts
+ *
+ * Projectile management: spawning, travel, lifetime,
+ * homing behavior, piercing, and impact callbacks.
+ *
+ * @module combat
+ */
+interface ProjectileConfig {
+    speed: number;
+    lifetime: number;
+    damage: number;
+    homing: boolean;
+    homingStrength: number;
+    piercing: number;
+    gravity: number;
+}
+interface Projectile {
+    id: string;
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    config: ProjectileConfig;
+    age: number;
+    hitCount: number;
+    alive: boolean;
+    ownerId: string;
+}
+type ImpactCallback = (projectile: Projectile, targetId: string) => void;
+declare class ProjectileSystem {
+    private projectiles;
+    private nextId;
+    private onImpact;
+    spawn(ownerId: string, x: number, y: number, z: number, dx: number, dy: number, dz: number, config: ProjectileConfig): string;
+    setImpactCallback(cb: ImpactCallback): void;
+    update(dt: number, targets?: Array<{
+        id: string;
+        x: number;
+        y: number;
+        z: number;
+        radius: number;
+    }>): void;
+    private findNearest;
+    getProjectile(id: string): Projectile | undefined;
+    getAliveCount(): number;
+    cleanup(): void;
+}
+
+/**
+ * StatusEffects.ts
+ *
+ * Buff/debuff system: stacking, duration, ticking effects,
+ * stat modifiers, immunity, and cleansing.
+ *
+ * @module combat
+ */
+type EffectType = 'buff' | 'debuff';
+type StackBehavior = 'stack' | 'refresh' | 'replace' | 'ignore';
+interface StatModifier {
+    stat: string;
+    flat: number;
+    percent: number;
+}
+interface StatusEffect {
+    id: string;
+    name: string;
+    type: EffectType;
+    duration: number;
+    elapsed: number;
+    stacks: number;
+    maxStacks: number;
+    stackBehavior: StackBehavior;
+    modifiers: StatModifier[];
+    tickInterval: number;
+    lastTick: number;
+    tickDamage: number;
+    onApply?: string;
+    onRemove?: string;
+    onTick?: string;
+}
+declare class StatusEffectSystem {
+    private effects;
+    private immunities;
+    private tickResults;
+    apply(entityId: string, effectDef: Omit<StatusEffect, 'id' | 'elapsed' | 'lastTick' | 'stacks'> & {
+        stacks?: number;
+    }): StatusEffect | null;
+    remove(entityId: string, effectName: string): boolean;
+    removeAllOfType(entityId: string, type: EffectType): number;
+    cleanse(entityId: string, _count?: number): number;
+    update(dt: number): void;
+    getTickResults(): typeof this.tickResults;
+    addImmunity(entityId: string, effectName: string): void;
+    removeImmunity(entityId: string, effectName: string): void;
+    getStatModifiers(entityId: string, stat: string): {
+        flat: number;
+        percent: number;
+    };
+    applyStatModifiers(entityId: string, stat: string, baseValue: number): number;
+    getEffects(entityId: string): StatusEffect[];
+    hasEffect(entityId: string, effectName: string): boolean;
+    getEffectCount(entityId: string): number;
+}
+
+type index_CombatManager = CombatManager;
+declare const index_CombatManager: typeof CombatManager;
+type index_CombatTarget = CombatTarget;
+type index_ComboChain = ComboChain;
+type index_ComboDefinition = ComboDefinition;
+type index_ComboState = ComboState;
+type index_ComboTracker = ComboTracker;
+declare const index_ComboTracker: typeof ComboTracker;
+type index_Cooldown = Cooldown;
+type index_DamageConfig = DamageConfig;
+type index_DamageInstance = DamageInstance;
+type index_DamageSystem = DamageSystem;
+declare const index_DamageSystem: typeof DamageSystem;
+type index_DamageType = DamageType;
+type index_DotEffect = DotEffect;
+type index_EffectType = EffectType;
+type index_HitBox = HitBox;
+type index_HitEvent = HitEvent;
+type index_Hitbox = Hitbox;
+type index_HitboxSystem = HitboxSystem;
+declare const index_HitboxSystem: typeof HitboxSystem;
+type index_HurtBox = HurtBox;
+type index_Hurtbox = Hurtbox;
+type index_ImpactCallback = ImpactCallback;
+type index_Projectile = Projectile;
+type index_ProjectileConfig = ProjectileConfig;
+type index_ProjectileSystem = ProjectileSystem;
+declare const index_ProjectileSystem: typeof ProjectileSystem;
+type index_Resistances = Resistances;
+type index_StackBehavior = StackBehavior;
+type index_StatModifier = StatModifier;
+type index_StatusEffect = StatusEffect;
+type index_StatusEffectSystem = StatusEffectSystem;
+declare const index_StatusEffectSystem: typeof StatusEffectSystem;
+declare namespace index {
+  export { index_CombatManager as CombatManager, type index_CombatTarget as CombatTarget, type index_ComboChain as ComboChain, type index_ComboDefinition as ComboDefinition, type index_ComboState as ComboState, type ComboStep$1 as ComboStep, index_ComboTracker as ComboTracker, type index_Cooldown as Cooldown, type index_DamageConfig as DamageConfig, type index_DamageInstance as DamageInstance, index_DamageSystem as DamageSystem, type index_DamageType as DamageType, type index_DotEffect as DotEffect, type index_EffectType as EffectType, type index_HitBox as HitBox, type index_HitEvent as HitEvent, type index_Hitbox as Hitbox, index_HitboxSystem as HitboxSystem, type index_HurtBox as HurtBox, type index_Hurtbox as Hurtbox, type index_ImpactCallback as ImpactCallback, type index_Projectile as Projectile, type index_ProjectileConfig as ProjectileConfig, index_ProjectileSystem as ProjectileSystem, type index_Resistances as Resistances, type index_StackBehavior as StackBehavior, type index_StatModifier as StatModifier, type index_StatusEffect as StatusEffect, index_StatusEffectSystem as StatusEffectSystem, type ComboStep as TrackerComboStep };
+}
+
+export { CombatManager as C, type DamageConfig as D, type EffectType as E, type HitBox as H, type ImpactCallback as I, type Projectile as P, type Resistances as R, type StackBehavior as S, type CombatTarget as a, type ComboChain as b, type ComboDefinition as c, type ComboState as d, type ComboStep$1 as e, ComboTracker as f, type Cooldown as g, type DamageInstance as h, index as i, DamageSystem as j, type DamageType as k, type DotEffect as l, type HitEvent as m, type Hitbox as n, HitboxSystem as o, type HurtBox as p, type Hurtbox as q, type ProjectileConfig as r, ProjectileSystem as s, type StatModifier as t, type StatusEffect as u, StatusEffectSystem as v, type ComboStep as w };