@holoscript/engine 6.0.3 → 6.0.4

package/dist/chunk-OWSN2Q3Q.js

@@ -0,0 +1,690 @@
+import {
+  __export
+} from "./chunk-AKLW2MUS.js";
+
+// src/combat/index.ts
+var combat_exports = {};
+__export(combat_exports, {
+  CombatManager: () => CombatManager,
+  ComboTracker: () => ComboTracker,
+  DamageSystem: () => DamageSystem,
+  HitboxSystem: () => HitboxSystem,
+  ProjectileSystem: () => ProjectileSystem,
+  StatusEffectSystem: () => StatusEffectSystem
+});
+
+// src/combat/CombatManager.ts
+var CombatManager = class {
+  hitboxes = /* @__PURE__ */ new Map();
+  hurtboxes = /* @__PURE__ */ new Map();
+  combos = /* @__PURE__ */ new Map();
+  cooldowns = /* @__PURE__ */ new Map();
+  hitLog = [];
+  // ---------------------------------------------------------------------------
+  // Hitbox / Hurtbox
+  // ---------------------------------------------------------------------------
+  addHitBox(hitbox) {
+    this.hitboxes.set(hitbox.id, hitbox);
+  }
+  addHurtBox(hurtbox) {
+    this.hurtboxes.set(hurtbox.id, hurtbox);
+  }
+  removeHitBox(id) {
+    this.hitboxes.delete(id);
+  }
+  removeHurtBox(id) {
+    this.hurtboxes.delete(id);
+  }
+  setHitBoxActive(id, active) {
+    const hb = this.hitboxes.get(id);
+    if (hb) hb.active = active;
+  }
+  checkCollisions() {
+    const hits = [];
+    for (const hb of this.hitboxes.values()) {
+      if (!hb.active) continue;
+      for (const hr of this.hurtboxes.values()) {
+        if (!hr.active) continue;
+        if (hb.ownerId === hr.ownerId) continue;
+        if (this.aabbOverlap(hb.position, hb.size, hr.position, hr.size)) {
+          hits.push({ hitbox: hb, hurtbox: hr });
+          this.hitLog.push({ hitboxId: hb.id, hurtboxId: hr.id, time: Date.now() });
+        }
+      }
+    }
+    return hits;
+  }
+  aabbOverlap(posA, sizeA, posB, sizeB) {
+    return Math.abs(posA.x - posB.x) < (sizeA.x + sizeB.x) / 2 && Math.abs(posA.y - posB.y) < (sizeA.y + sizeB.y) / 2 && Math.abs(posA.z - posB.z) < (sizeA.z + sizeB.z) / 2;
+  }
+  // ---------------------------------------------------------------------------
+  // Combo System
+  // ---------------------------------------------------------------------------
+  registerCombo(id, steps) {
+    const chain = { id, steps, currentStep: 0, timer: 0, completed: false };
+    this.combos.set(id, chain);
+    return chain;
+  }
+  advanceCombo(comboId, input) {
+    const combo = this.combos.get(comboId);
+    if (!combo || combo.completed) return { hit: false, completed: false, step: -1 };
+    const step = combo.steps[combo.currentStep];
+    if (step.input === input) {
+      combo.currentStep++;
+      combo.timer = 0;
+      const completed = combo.currentStep >= combo.steps.length;
+      if (completed) combo.completed = true;
+      return { hit: true, completed, step: combo.currentStep - 1 };
+    }
+    combo.currentStep = 0;
+    combo.timer = 0;
+    return { hit: false, completed: false, step: 0 };
+  }
+  updateCombos(dt) {
+    for (const combo of this.combos.values()) {
+      if (combo.completed || combo.currentStep === 0) continue;
+      combo.timer += dt;
+      const window = combo.steps[combo.currentStep - 1]?.window ?? 1;
+      if (combo.timer > window) {
+        combo.currentStep = 0;
+        combo.timer = 0;
+      }
+    }
+  }
+  resetCombo(comboId) {
+    const combo = this.combos.get(comboId);
+    if (combo) {
+      combo.currentStep = 0;
+      combo.timer = 0;
+      combo.completed = false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Cooldowns
+  // ---------------------------------------------------------------------------
+  startCooldown(abilityId, duration) {
+    this.cooldowns.set(abilityId, { abilityId, duration, remaining: duration });
+  }
+  isOnCooldown(abilityId) {
+    const cd = this.cooldowns.get(abilityId);
+    return cd ? cd.remaining > 0 : false;
+  }
+  getCooldownRemaining(abilityId) {
+    return this.cooldowns.get(abilityId)?.remaining ?? 0;
+  }
+  updateCooldowns(dt) {
+    for (const cd of this.cooldowns.values()) {
+      cd.remaining = Math.max(0, cd.remaining - dt);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Targeting
+  // ---------------------------------------------------------------------------
+  findTargets(position, candidates, maxRange) {
+    return candidates.map((c) => {
+      const dx = c.position[0] - position[0];
+      const dy = c.position[1] - position[1];
+      const dz = c.position[2] - position[2];
+      const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      return { entityId: c.entityId, position: c.position, priority: c.priority ?? 0, distance };
+    }).filter((t) => t.distance <= maxRange).sort((a, b) => b.priority - a.priority || a.distance - b.distance);
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getHitLog() {
+    return [...this.hitLog];
+  }
+  getHitBoxCount() {
+    return this.hitboxes.size;
+  }
+  getHurtBoxCount() {
+    return this.hurtboxes.size;
+  }
+};
+
+// src/combat/ComboTracker.ts
+var ComboTracker = class {
+  combos = [];
+  activeStates = [];
+  completedCombos = [];
+  currentTime = 0;
+  // ---------------------------------------------------------------------------
+  // Combo Registration
+  // ---------------------------------------------------------------------------
+  registerCombo(combo) {
+    this.combos.push(combo);
+  }
+  // ---------------------------------------------------------------------------
+  // Input Processing
+  // ---------------------------------------------------------------------------
+  pushInput(input, timestamp) {
+    this.currentTime = timestamp;
+    this.completedCombos = [];
+    for (let i = this.activeStates.length - 1; i >= 0; i--) {
+      const state = this.activeStates[i];
+      const combo = this.combos.find((c) => c.id === state.comboId);
+      const step = combo.steps[state.currentStep];
+      if (timestamp - state.lastInputTime > step.maxDelay) {
+        this.activeStates.splice(i, 1);
+        continue;
+      }
+      if (step.input === input) {
+        state.currentStep++;
+        state.lastInputTime = timestamp;
+        if (state.currentStep >= combo.steps.length) {
+          state.completed = true;
+          this.completedCombos.push(combo.reward);
+          this.activeStates.splice(i, 1);
+        }
+      }
+    }
+    for (const combo of this.combos) {
+      if (combo.steps[0].input === input) {
+        const exists = this.activeStates.some((s) => s.comboId === combo.id && s.currentStep === 1);
+        if (!exists) {
+          if (combo.steps.length === 1) {
+            this.completedCombos.push(combo.reward);
+          } else {
+            this.activeStates.push({
+              comboId: combo.id,
+              currentStep: 1,
+              lastInputTime: timestamp,
+              completed: false
+            });
+          }
+        }
+      }
+    }
+    return this.completedCombos.length > 0 ? this.completedCombos[0] : null;
+  }
+  // ---------------------------------------------------------------------------
+  // State
+  // ---------------------------------------------------------------------------
+  tick(timestamp) {
+    this.currentTime = timestamp;
+    this.activeStates = this.activeStates.filter((state) => {
+      const combo = this.combos.find((c) => c.id === state.comboId);
+      const step = combo.steps[state.currentStep];
+      return timestamp - state.lastInputTime <= step.maxDelay;
+    });
+  }
+  getActiveComboCount() {
+    return this.activeStates.length;
+  }
+  getCompletedCombos() {
+    return [...this.completedCombos];
+  }
+  reset() {
+    this.activeStates = [];
+    this.completedCombos = [];
+  }
+};
+
+// src/combat/DamageSystem.ts
+var _dmgId = 0;
+var _dotId = 0;
+var DamageSystem = class {
+  config = {
+    critChance: 0.1,
+    critMultiplier: 2,
+    armorPenetration: 0,
+    globalMultiplier: 1
+  };
+  damageLog = [];
+  dots = /* @__PURE__ */ new Map();
+  resistances = /* @__PURE__ */ new Map();
+  callbacks = [];
+  // ---------------------------------------------------------------------------
+  // Configuration
+  // ---------------------------------------------------------------------------
+  setConfig(config) {
+    Object.assign(this.config, config);
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  setResistances(entityId, res) {
+    const base = {
+      physical: 0,
+      fire: 0,
+      ice: 0,
+      lightning: 0,
+      poison: 0,
+      holy: 0,
+      dark: 0
+    };
+    this.resistances.set(entityId, { ...base, ...res });
+  }
+  getResistances(entityId) {
+    return this.resistances.get(entityId) ?? {
+      physical: 0,
+      fire: 0,
+      ice: 0,
+      lightning: 0,
+      poison: 0,
+      holy: 0,
+      dark: 0
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Damage Calculation
+  // ---------------------------------------------------------------------------
+  calculateDamage(sourceId, targetId, baseDamage, type, forceCrit = false) {
+    const isCrit = forceCrit || Math.random() < this.config.critChance;
+    let damage = baseDamage;
+    if (isCrit) damage *= this.config.critMultiplier;
+    if (type !== "true") {
+      const res = this.getResistances(targetId);
+      const resValue = res[type] ?? 0;
+      const effectiveRes = resValue * (1 - this.config.armorPenetration);
+      damage *= Math.max(0, 1 - effectiveRes);
+    }
+    damage *= this.config.globalMultiplier;
+    damage = Math.max(0, Math.round(damage * 100) / 100);
+    const instance = {
+      id: `dmg_${_dmgId++}`,
+      sourceId,
+      targetId,
+      baseDamage,
+      type,
+      isCritical: isCrit,
+      finalDamage: damage,
+      timestamp: Date.now()
+    };
+    this.damageLog.push(instance);
+    this.callbacks.forEach((cb) => cb(instance));
+    return instance;
+  }
+  // ---------------------------------------------------------------------------
+  // Damage Over Time
+  // ---------------------------------------------------------------------------
+  applyDoT(sourceId, targetId, type, damagePerTick, tickInterval, duration, stacks = 1) {
+    const dot = {
+      id: `dot_${_dotId++}`,
+      sourceId,
+      targetId,
+      type,
+      damagePerTick,
+      tickInterval,
+      duration,
+      elapsed: 0,
+      lastTick: 0,
+      stacks
+    };
+    this.dots.set(dot.id, dot);
+    return dot;
+  }
+  updateDoTs(dt) {
+    const ticked = [];
+    const expired = [];
+    for (const dot of this.dots.values()) {
+      dot.elapsed += dt;
+      while (dot.elapsed - dot.lastTick >= dot.tickInterval && dot.lastTick < dot.duration) {
+        dot.lastTick += dot.tickInterval;
+        const dmg = this.calculateDamage(
+          dot.sourceId,
+          dot.targetId,
+          dot.damagePerTick * dot.stacks,
+          dot.type
+        );
+        ticked.push(dmg);
+      }
+      if (dot.elapsed >= dot.duration) expired.push(dot.id);
+    }
+    for (const id of expired) this.dots.delete(id);
+    return ticked;
+  }
+  getActiveDoTs(targetId) {
+    const all = [...this.dots.values()];
+    return targetId ? all.filter((d) => d.targetId === targetId) : all;
+  }
+  // ---------------------------------------------------------------------------
+  // Events & Queries
+  // ---------------------------------------------------------------------------
+  onDamage(callback) {
+    this.callbacks.push(callback);
+  }
+  getDamageLog(limit = 100) {
+    return this.damageLog.slice(-limit);
+  }
+  getTotalDamageDealt(sourceId) {
+    return this.damageLog.filter((d) => d.sourceId === sourceId).reduce((sum, d) => sum + d.finalDamage, 0);
+  }
+  clearLog() {
+    this.damageLog = [];
+  }
+};
+
+// src/combat/HitboxSystem.ts
+var HitboxSystem = class {
+  hitboxes = /* @__PURE__ */ new Map();
+  hurtboxes = /* @__PURE__ */ new Map();
+  currentFrame = 0;
+  hitLog = /* @__PURE__ */ new Set();
+  // "hitboxGroup:hurtboxEntity" dedup
+  events = [];
+  // ---------------------------------------------------------------------------
+  // Registration
+  // ---------------------------------------------------------------------------
+  addHitbox(hb) {
+    this.hitboxes.set(hb.id, hb);
+  }
+  addHurtbox(hb) {
+    this.hurtboxes.set(hb.id, hb);
+  }
+  removeHitbox(id) {
+    this.hitboxes.delete(id);
+  }
+  removeHurtbox(id) {
+    this.hurtboxes.delete(id);
+  }
+  // ---------------------------------------------------------------------------
+  // Frame Update
+  // ---------------------------------------------------------------------------
+  update(frame) {
+    this.currentFrame = frame;
+    this.events = [];
+    for (const hitbox of this.hitboxes.values()) {
+      if (frame < hitbox.activeStart || frame > hitbox.activeEnd) continue;
+      for (const hurtbox of this.hurtboxes.values()) {
+        if (hitbox.ownerId === hurtbox.entityId) continue;
+        const key = `${hitbox.group}:${hurtbox.entityId}`;
+        if (this.hitLog.has(key)) continue;
+        if (this.overlaps(hitbox, hurtbox)) {
+          this.hitLog.add(key);
+          this.events.push({
+            hitboxId: hitbox.id,
+            hurtboxId: hurtbox.id,
+            attackerId: hitbox.ownerId,
+            defenderId: hurtbox.entityId,
+            damage: hitbox.damage,
+            knockbackX: hitbox.knockbackX,
+            knockbackY: hitbox.knockbackY
+          });
+        }
+      }
+    }
+    return [...this.events];
+  }
+  // ---------------------------------------------------------------------------
+  // Collision Test
+  // ---------------------------------------------------------------------------
+  overlaps(hb, hr) {
+    return hb.x < hr.x + hr.width && hb.x + hb.width > hr.x && hb.y < hr.y + hr.height && hb.y + hb.height > hr.y && hb.z < hr.z + hr.depth && hb.z + hb.depth > hr.z;
+  }
+  // ---------------------------------------------------------------------------
+  // State
+  // ---------------------------------------------------------------------------
+  clearHitLog() {
+    this.hitLog.clear();
+  }
+  getHitCount() {
+    return this.hitLog.size;
+  }
+  getLastEvents() {
+    return [...this.events];
+  }
+};
+
+// src/combat/ProjectileSystem.ts
+var ProjectileSystem = class {
+  projectiles = /* @__PURE__ */ new Map();
+  nextId = 0;
+  onImpact = null;
+  // ---------------------------------------------------------------------------
+  // Spawning
+  // ---------------------------------------------------------------------------
+  spawn(ownerId, x, y, z, dx, dy, dz, config) {
+    const id = `proj_${this.nextId++}`;
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+    this.projectiles.set(id, {
+      id,
+      x,
+      y,
+      z,
+      vx: dx / len * config.speed,
+      vy: dy / len * config.speed,
+      vz: dz / len * config.speed,
+      config,
+      age: 0,
+      hitCount: 0,
+      alive: true,
+      ownerId
+    });
+    return id;
+  }
+  setImpactCallback(cb) {
+    this.onImpact = cb;
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt, targets) {
+    for (const proj of this.projectiles.values()) {
+      if (!proj.alive) continue;
+      proj.age += dt;
+      if (proj.age >= proj.config.lifetime) {
+        proj.alive = false;
+        continue;
+      }
+      proj.vy -= proj.config.gravity * dt;
+      if (proj.config.homing && targets && targets.length > 0) {
+        const nearest = this.findNearest(proj, targets);
+        if (nearest) {
+          const dx = nearest.x - proj.x, dy = nearest.y - proj.y, dz = nearest.z - proj.z;
+          const dist = Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+          const str = proj.config.homingStrength * dt;
+          proj.vx += dx / dist * str;
+          proj.vy += dy / dist * str;
+          proj.vz += dz / dist * str;
+          const sp = Math.sqrt(proj.vx * proj.vx + proj.vy * proj.vy + proj.vz * proj.vz) || 1;
+          proj.vx = proj.vx / sp * proj.config.speed;
+          proj.vy = proj.vy / sp * proj.config.speed;
+          proj.vz = proj.vz / sp * proj.config.speed;
+        }
+      }
+      proj.x += proj.vx * dt;
+      proj.y += proj.vy * dt;
+      proj.z += proj.vz * dt;
+      if (targets) {
+        for (const t of targets) {
+          const dx = t.x - proj.x, dy = t.y - proj.y, dz = t.z - proj.z;
+          if (Math.sqrt(dx * dx + dy * dy + dz * dz) <= t.radius) {
+            proj.hitCount++;
+            if (this.onImpact) this.onImpact(proj, t.id);
+            if (proj.hitCount > proj.config.piercing) {
+              proj.alive = false;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  findNearest(proj, targets) {
+    let best = null;
+    let bestDist = Infinity;
+    for (const t of targets) {
+      const d = Math.sqrt((t.x - proj.x) ** 2 + (t.y - proj.y) ** 2 + (t.z - proj.z) ** 2);
+      if (d < bestDist) {
+        bestDist = d;
+        best = t;
+      }
+    }
+    return best;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getProjectile(id) {
+    return this.projectiles.get(id);
+  }
+  getAliveCount() {
+    return [...this.projectiles.values()].filter((p) => p.alive).length;
+  }
+  cleanup() {
+    for (const [id, p] of this.projectiles) if (!p.alive) this.projectiles.delete(id);
+  }
+};
+
+// src/combat/StatusEffects.ts
+var _effectId = 0;
+var StatusEffectSystem = class {
+  effects = /* @__PURE__ */ new Map();
+  // entityId → effectName → effect
+  immunities = /* @__PURE__ */ new Map();
+  // entityId → immune effect names
+  tickResults = [];
+  // ---------------------------------------------------------------------------
+  // Application
+  // ---------------------------------------------------------------------------
+  apply(entityId, effectDef) {
+    const immune = this.immunities.get(entityId);
+    if (immune?.has(effectDef.name)) return null;
+    let entityEffects = this.effects.get(entityId);
+    if (!entityEffects) {
+      entityEffects = /* @__PURE__ */ new Map();
+      this.effects.set(entityId, entityEffects);
+    }
+    const existing = entityEffects.get(effectDef.name);
+    if (existing) {
+      switch (effectDef.stackBehavior) {
+        case "stack":
+          existing.stacks = Math.min(existing.stacks + (effectDef.stacks ?? 1), existing.maxStacks);
+          return existing;
+        case "refresh":
+          existing.elapsed = 0;
+          return existing;
+        case "replace":
+          break;
+        case "ignore":
+          return existing;
+      }
+    }
+    const effect = {
+      ...effectDef,
+      id: `effect_${_effectId++}`,
+      elapsed: 0,
+      lastTick: 0,
+      stacks: effectDef.stacks ?? 1
+    };
+    entityEffects.set(effect.name, effect);
+    return effect;
+  }
+  // ---------------------------------------------------------------------------
+  // Removal
+  // ---------------------------------------------------------------------------
+  remove(entityId, effectName) {
+    const entityEffects = this.effects.get(entityId);
+    return entityEffects ? entityEffects.delete(effectName) : false;
+  }
+  removeAllOfType(entityId, type) {
+    const entityEffects = this.effects.get(entityId);
+    if (!entityEffects) return 0;
+    let count = 0;
+    for (const [name, effect] of entityEffects) {
+      if (effect.type === type) {
+        entityEffects.delete(name);
+        count++;
+      }
+    }
+    return count;
+  }
+  cleanse(entityId, _count = Infinity) {
+    return this.removeAllOfType(entityId, "debuff");
+  }
+  // ---------------------------------------------------------------------------
+  // Update
+  // ---------------------------------------------------------------------------
+  update(dt) {
+    this.tickResults = [];
+    const toRemove = [];
+    for (const [entityId, entityEffects] of this.effects) {
+      for (const [name, effect] of entityEffects) {
+        effect.elapsed += dt;
+        if (effect.tickInterval > 0 && effect.tickDamage > 0) {
+          while (effect.elapsed - effect.lastTick >= effect.tickInterval) {
+            effect.lastTick += effect.tickInterval;
+            this.tickResults.push({
+              entityId,
+              effectName: name,
+              damage: effect.tickDamage * effect.stacks
+            });
+          }
+        }
+        if (effect.duration > 0 && effect.elapsed >= effect.duration) {
+          toRemove.push({ entityId, name });
+        }
+      }
+    }
+    for (const { entityId, name } of toRemove) {
+      this.remove(entityId, name);
+    }
+  }
+  getTickResults() {
+    return [...this.tickResults];
+  }
+  // ---------------------------------------------------------------------------
+  // Immunity
+  // ---------------------------------------------------------------------------
+  addImmunity(entityId, effectName) {
+    let set = this.immunities.get(entityId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.immunities.set(entityId, set);
+    }
+    set.add(effectName);
+  }
+  removeImmunity(entityId, effectName) {
+    this.immunities.get(entityId)?.delete(effectName);
+  }
+  // ---------------------------------------------------------------------------
+  // Stat Queries
+  // ---------------------------------------------------------------------------
+  getStatModifiers(entityId, stat) {
+    let flat = 0, percent = 1;
+    const entityEffects = this.effects.get(entityId);
+    if (entityEffects) {
+      for (const effect of entityEffects.values()) {
+        for (const mod of effect.modifiers) {
+          if (mod.stat === stat) {
+            flat += mod.flat * effect.stacks;
+            percent *= Math.pow(mod.percent, effect.stacks);
+          }
+        }
+      }
+    }
+    return { flat, percent };
+  }
+  applyStatModifiers(entityId, stat, baseValue) {
+    const { flat, percent } = this.getStatModifiers(entityId, stat);
+    return (baseValue + flat) * percent;
+  }
+  // ---------------------------------------------------------------------------
+  // Queries
+  // ---------------------------------------------------------------------------
+  getEffects(entityId) {
+    const entityEffects = this.effects.get(entityId);
+    return entityEffects ? [...entityEffects.values()] : [];
+  }
+  hasEffect(entityId, effectName) {
+    return this.effects.get(entityId)?.has(effectName) ?? false;
+  }
+  getEffectCount(entityId) {
+    return this.effects.get(entityId)?.size ?? 0;
+  }
+};
+
+export {
+  CombatManager,
+  ComboTracker,
+  DamageSystem,
+  HitboxSystem,
+  ProjectileSystem,
+  StatusEffectSystem,
+  combat_exports
+};