fightbook 1.0.0

package/dist/engine/FightEngine.js

@@ -0,0 +1,605 @@
+import {
+  STRIKING_TECHNIQUES,
+  GRAPPLING_TECHNIQUES,
+  SUBMISSION_TECHNIQUES,
+  GROUND_TECHNIQUES,
+  ROUND_DURATION,
+  TOTAL_ROUNDS,
+  DEFAULT_FIGHTER
+} from "@/types/fight";
+class FightEngine {
+  fight;
+  intervalId = null;
+  onAction = null;
+  onRoundEnd = null;
+  onFightEnd = null;
+  tickRate = 1e3;
+  // 1 second per tick for real-time feel
+  // LLM and CPU callbacks
+  llmCallback;
+  cpuCallback;
+  mixedMode = false;
+  llmFighterId = "fighter1";
+  // Which fighter uses LLM
+  constructor(fighter1Stats, fighter2Stats, callbacks) {
+    this.fight = this.initializeFight(fighter1Stats, fighter2Stats);
+    this.onAction = callbacks?.onAction || null;
+    this.onRoundEnd = callbacks?.onRoundEnd || null;
+    this.onFightEnd = callbacks?.onFightEnd || null;
+    this.llmCallback = callbacks?.llmCallback;
+    this.cpuCallback = callbacks?.cpuCallback;
+    this.mixedMode = callbacks?.mixedMode || false;
+    this.llmFighterId = callbacks?.llmFighterId || "fighter1";
+  }
+  initializeFight(f1, f2) {
+    const fighter1 = {
+      ...f1,
+      id: "fighter1",
+      currentHealth: 100,
+      currentStamina: 100,
+      position: "standing",
+      hasMount: false,
+      hasBack: false,
+      isGrounded: false,
+      cuts: 0,
+      knockdowns: 0,
+      takedownsLanded: 0,
+      takedownsAttempted: 0,
+      significantStrikes: 0,
+      totalStrikes: 0
+    };
+    const fighter2 = {
+      ...f2,
+      id: "fighter2",
+      currentHealth: 100,
+      currentStamina: 100,
+      position: "standing",
+      hasMount: false,
+      hasBack: false,
+      isGrounded: false,
+      cuts: 0,
+      knockdowns: 0,
+      takedownsLanded: 0,
+      takedownsAttempted: 0,
+      significantStrikes: 0,
+      totalStrikes: 0
+    };
+    return {
+      id: Math.random().toString(36).substring(7),
+      fighter1,
+      fighter2,
+      currentRound: 1,
+      rounds: [this.createRound(1)],
+      isComplete: false
+    };
+  }
+  createRound(roundNum) {
+    return {
+      round: roundNum,
+      timeRemaining: ROUND_DURATION,
+      isActive: false,
+      actions: []
+    };
+  }
+  // Start the fight
+  start() {
+    if (this.intervalId) return;
+    this.fight.rounds[this.fight.currentRound - 1].isActive = true;
+    this.intervalId = setInterval(() => this.tick(), this.tickRate);
+  }
+  // Pause the fight
+  pause() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  // Resume the fight
+  resume() {
+    if (!this.intervalId && !this.fight.isComplete) {
+      this.intervalId = setInterval(() => this.tick(), this.tickRate);
+    }
+  }
+  // Stop the fight completely
+  stop() {
+    this.pause();
+    this.fight.isComplete = true;
+  }
+  // Get current fight state
+  getState() {
+    return { ...this.fight };
+  }
+  // Get simplified game state for LLM/CPU context
+  getGameState(actorId) {
+    const actor = actorId === "fighter1" ? this.fight.fighter1 : this.fight.fighter2;
+    const target = actorId === "fighter1" ? this.fight.fighter2 : this.fight.fighter1;
+    const currentRound = this.fight.rounds[this.fight.currentRound - 1];
+    const recentActions = currentRound?.actions.slice(-3).map((a) => a.description) || [];
+    return {
+      round: this.fight.currentRound,
+      timeRemaining: currentRound?.timeRemaining || 0,
+      myHealth: actor.currentHealth,
+      myStamina: actor.currentStamina,
+      myPosition: actor.position,
+      oppHealth: target.currentHealth,
+      oppStamina: target.currentStamina,
+      oppPosition: target.position,
+      recentActions
+    };
+  }
+  // Main game loop tick - runs every second
+  tick() {
+    const currentRound = this.fight.rounds[this.fight.currentRound - 1];
+    if (currentRound.timeRemaining <= 0) {
+      this.endRound();
+      return;
+    }
+    currentRound.timeRemaining--;
+    this.recoverStamina();
+    const actionChance = 0.7 + (this.fight.fighter1.aggression + this.fight.fighter2.aggression) / 2;
+    if (Math.random() < actionChance) {
+      const f1Aggression = this.fight.fighter1.aggression;
+      const f2Aggression = this.fight.fighter2.aggression;
+      const total = f1Aggression + f2Aggression || 1;
+      const actingFighter = Math.random() < f1Aggression / total ? "fighter1" : "fighter2";
+      const action = this.generateAction(actingFighter);
+      if (action) {
+        currentRound.actions.push(action);
+        this.applyAction(action);
+        this.onAction?.(action);
+        if (this.checkFightEnd()) {
+          this.endFight();
+        }
+      }
+    }
+    if (this.checkExhaustion()) {
+      this.endFight();
+    }
+  }
+  recoverStamina() {
+    const recovery1 = this.fight.fighter1.recovery / 100 * 0.3;
+    const recovery2 = this.fight.fighter2.recovery / 100 * 0.3;
+    this.fight.fighter1.currentStamina = Math.min(100, this.fight.fighter1.currentStamina + recovery1);
+    this.fight.fighter2.currentStamina = Math.min(100, this.fight.fighter2.currentStamina + recovery2);
+  }
+  generateAction(actingFighterId) {
+    const actor = actingFighterId === "fighter1" ? this.fight.fighter1 : this.fight.fighter2;
+    const target = actingFighterId === "fighter1" ? this.fight.fighter2 : this.fight.fighter1;
+    let technique = null;
+    if (this.mixedMode) {
+      const gameState = this.getGameState(actingFighterId);
+      if (actingFighterId === this.llmFighterId && this.llmCallback) {
+        return null;
+      }
+      if (actingFighterId !== this.llmFighterId && this.cpuCallback) {
+        const techniqueName = this.cpuCallback(actor.name, target.name, gameState);
+        technique = this.getTechniqueByName(techniqueName);
+      }
+    }
+    if (!technique) {
+      technique = this.selectTechnique(actor, target);
+    }
+    if (!technique) return null;
+    const success = this.calculateSuccess(actor, target, technique);
+    const { damage, staminaCost, description, impact } = this.calculateOutcome(
+      actor,
+      target,
+      technique,
+      success
+    );
+    return {
+      timestamp: Date.now(),
+      round: this.fight.currentRound,
+      timeRemaining: this.fight.rounds[this.fight.currentRound - 1].timeRemaining,
+      actor: actor.name,
+      target: target.name,
+      type: technique.type,
+      technique,
+      success,
+      damage,
+      staminaCost,
+      description,
+      impact
+    };
+  }
+  // Get technique by name (for LLM/CPU callbacks)
+  getTechniqueByName(name) {
+    const allTechs = [
+      ...STRIKING_TECHNIQUES,
+      ...GRAPPLING_TECHNIQUES,
+      ...SUBMISSION_TECHNIQUES,
+      ...GROUND_TECHNIQUES
+    ];
+    let tech = allTechs.find((t) => t.name.toLowerCase() === name.toLowerCase());
+    if (tech) return tech;
+    tech = allTechs.find((t) => t.name.toLowerCase().includes(name.toLowerCase()));
+    return tech || null;
+  }
+  // Generate async action for LLM fighters
+  async generateLlmAction(actingFighterId) {
+    if (!this.llmCallback) return null;
+    const actor = actingFighterId === "fighter1" ? this.fight.fighter1 : this.fight.fighter2;
+    const target = actingFighterId === "fighter1" ? this.fight.fighter2 : this.fight.fighter1;
+    const gameState = this.getGameState(actingFighterId);
+    try {
+      const techniqueName = await this.llmCallback(actor.name, target.name, gameState);
+      const technique = this.getTechniqueByName(techniqueName);
+      if (!technique) {
+        console.warn("Invalid technique from LLM:", techniqueName);
+        return null;
+      }
+      const success = this.calculateSuccess(actor, target, technique);
+      const { damage, staminaCost, description, impact } = this.calculateOutcome(
+        actor,
+        target,
+        technique,
+        success
+      );
+      return {
+        timestamp: Date.now(),
+        round: this.fight.currentRound,
+        timeRemaining: this.fight.rounds[this.fight.currentRound - 1].timeRemaining,
+        actor: actor.name,
+        target: target.name,
+        type: technique.type,
+        technique,
+        success,
+        damage,
+        staminaCost,
+        description,
+        impact
+      };
+    } catch (error) {
+      console.error("LLM callback error:", error);
+      const technique = this.selectTechnique(actor, target);
+      if (!technique) return null;
+      const success = this.calculateSuccess(actor, target, technique);
+      const { damage, staminaCost, description, impact } = this.calculateOutcome(
+        actor,
+        target,
+        technique,
+        success
+      );
+      return {
+        timestamp: Date.now(),
+        round: this.fight.currentRound,
+        timeRemaining: this.fight.rounds[this.fight.currentRound - 1].timeRemaining,
+        actor: actor.name,
+        target: target.name,
+        type: technique.type,
+        technique,
+        success,
+        damage,
+        staminaCost,
+        description,
+        impact
+      };
+    }
+  }
+  selectTechnique(actor, target) {
+    let availableTechs = [];
+    switch (actor.position) {
+      case "standing":
+        availableTechs = [
+          ...STRIKING_TECHNIQUES.filter((t) => t.position.includes("standing")),
+          ...GRAPPLING_TECHNIQUES.filter((t) => t.position.includes("standing"))
+        ];
+        break;
+      case "clinch":
+        availableTechs = [
+          ...STRIKING_TECHNIQUES.filter((t) => t.position.includes("clinch")),
+          ...GRAPPLING_TECHNIQUES.filter((t) => t.position.includes("clinch")),
+          { name: "Break Clinch", type: "break_clinch", baseDamage: 0, staminaCost: 5, accuracy: 0.8, position: ["clinch"] }
+        ];
+        break;
+      case "ground_top":
+        availableTechs = [
+          ...GROUND_TECHNIQUES.filter((t) => t.position.includes("ground_top")),
+          ...SUBMISSION_TECHNIQUES.filter((t) => t.position.includes("ground_top"))
+        ];
+        break;
+      case "ground_bottom":
+        availableTechs = [
+          ...GROUND_TECHNIQUES.filter((t) => t.position.includes("ground_bottom")),
+          ...SUBMISSION_TECHNIQUES.filter((t) => t.position.includes("ground_bottom"))
+        ];
+        break;
+    }
+    if (availableTechs.length === 0) return null;
+    const weightedTechs = availableTechs.map((tech) => {
+      let weight = 1;
+      if (tech.type === "strike") weight *= actor.striking / 50;
+      if (tech.type === "takedown") weight *= actor.wrestling / 50;
+      if (tech.type === "submission_attempt") weight *= actor.submissions / 50;
+      if (tech.type === "ground_pound") weight *= actor.groundGame / 50;
+      if (actor.fightIQ > 70) weight *= tech.accuracy * 2;
+      if (target.currentHealth < 30 && tech.type === "strike") weight *= 1.5;
+      if (actor.currentStamina < 30 && tech.staminaCost > 8) weight *= 0.3;
+      if (target.position === "ground_bottom" && tech.type === "ground_pound") weight *= 1.3;
+      return { tech, weight };
+    });
+    const totalWeight = weightedTechs.reduce((sum, wt) => sum + wt.weight, 0);
+    let random = Math.random() * totalWeight;
+    for (const wt of weightedTechs) {
+      random -= wt.weight;
+      if (random <= 0) return wt.tech;
+    }
+    return weightedTechs[0]?.tech || null;
+  }
+  calculateSuccess(actor, target, tech) {
+    let accuracy = tech.accuracy;
+    if (tech.type === "strike") {
+      accuracy *= actor.striking / 50;
+      accuracy *= 1 - target.headMovement / 200;
+    }
+    if (tech.type === "takedown") {
+      accuracy *= actor.wrestling / 50;
+      accuracy *= 1 - target.takedownDefense / 150;
+    }
+    if (tech.type === "submission_attempt") {
+      accuracy *= actor.submissions / 50;
+      accuracy *= 1 - target.submissionDefense / 150;
+    }
+    accuracy *= 0.5 + actor.currentStamina / 200;
+    if (tech.type === "strike") {
+      accuracy *= 1 + (100 - target.currentHealth) / 300;
+    }
+    return Math.random() < Math.min(0.95, accuracy);
+  }
+  calculateOutcome(actor, target, tech, success) {
+    if (!success) {
+      const misses = [
+        `${actor.name} throws a ${tech.name} but misses!`,
+        `${actor.name} attempts a ${tech.name} but ${target.name} defends well!`,
+        `${actor.name} goes for a ${tech.name} - no connection!`,
+        `${target.name} slips the ${tech.name} from ${actor.name}!`
+      ];
+      return {
+        damage: 0,
+        staminaCost: tech.staminaCost * 0.5,
+        description: misses[Math.floor(Math.random() * misses.length)]
+      };
+    }
+    let damage = tech.baseDamage;
+    let impact = "light";
+    if (tech.type === "strike") {
+      damage *= actor.striking / 50;
+      damage *= 0.8 + actor.punchSpeed / 250;
+      if (Math.random() < 0.1) {
+        damage *= 1.5;
+        impact = "devastating";
+      }
+    }
+    if (tech.type === "ground_pound") {
+      damage *= actor.groundGame / 50;
+      damage *= 0.9 + actor.striking / 500;
+    }
+    if (tech.type === "strike" || tech.type === "ground_pound") {
+      const chinReduction = target.chin / 100;
+      damage *= 1.1 - chinReduction;
+      if (damage > 15) impact = "devastating";
+      else if (damage > 10) impact = "heavy";
+      else if (damage > 5) impact = "moderate";
+    }
+    damage *= 0.85 + Math.random() * 0.3;
+    const desc = this.generateDescription(actor, target, tech, damage, impact);
+    return {
+      damage: Math.round(damage),
+      staminaCost: tech.staminaCost,
+      description: desc,
+      impact
+    };
+  }
+  generateDescription(actor, target, tech, damage, impact) {
+    const adjectives = impact === "devastating" ? ["CRUSHING", "BRUTAL", "DEVASTATING", "MASSIVE"] : impact === "heavy" ? ["SOLID", "HARD", "CLEAN", "STIFF"] : impact === "moderate" ? ["nice", "clean", "good", "sharp"] : ["light", "partial", "glancing"];
+    const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+    if (tech.type === "submission_attempt") {
+      return `${actor.name} locks in a ${tech.name}! ${target.name} is in trouble!`;
+    }
+    if (tech.type === "takedown") {
+      return `${actor.name} scores with a ${tech.name}! Fight goes to the ground!`;
+    }
+    if (damage > 12) {
+      return `${adj} ${tech.name} by ${actor.name}! ${target.name} is hurt!`;
+    } else if (damage > 6) {
+      return `${actor.name} lands a ${adj} ${tech.name}!`;
+    } else {
+      return `${actor.name} connects with a ${tech.name}.`;
+    }
+  }
+  applyAction(action) {
+    const actor = action.actor === this.fight.fighter1.name ? this.fight.fighter1 : this.fight.fighter2;
+    const target = action.target === this.fight.fighter1.name ? this.fight.fighter1 : this.fight.fighter2;
+    actor.currentStamina = Math.max(0, actor.currentStamina - action.staminaCost);
+    if (action.damage > 0) {
+      target.currentHealth = Math.max(0, target.currentHealth - action.damage);
+      if (action.damage >= 5) {
+        if (actor === this.fight.fighter1) this.fight.fighter1.significantStrikes++;
+        else this.fight.fighter2.significantStrikes++;
+      }
+      if (actor === this.fight.fighter1) this.fight.fighter1.totalStrikes++;
+      else this.fight.fighter2.totalStrikes++;
+    }
+    if (action.type === "takedown" && action.success) {
+      actor.position = "ground_top";
+      target.position = "ground_bottom";
+      actor.takedownsLanded++;
+      actor.isGrounded = true;
+      target.isGrounded = true;
+    }
+    if (action.type === "break_clinch" && action.success) {
+      actor.position = "standing";
+      target.position = "standing";
+    }
+    if ((action.type === "strike" || action.type === "ground_pound") && action.impact === "devastating" && action.damage > 10) {
+      if (Math.random() < 0.3) {
+        target.knockdowns++;
+        if (target.position === "standing") {
+          target.position = "ground_bottom";
+          actor.position = "ground_top";
+        }
+      }
+    }
+  }
+  checkFightEnd() {
+    const f1 = this.fight.fighter1;
+    const f2 = this.fight.fighter2;
+    if (f1.currentHealth <= 0) {
+      this.fight.winner = f2.name;
+      this.fight.method = f2.position === "ground_top" || f2.position === "ground_bottom" ? "TKO" : "KO";
+      return true;
+    }
+    if (f2.currentHealth <= 0) {
+      this.fight.winner = f1.name;
+      this.fight.method = f1.position === "ground_top" || f1.position === "ground_bottom" ? "TKO" : "KO";
+      return true;
+    }
+    if (f1.cuts >= 3) {
+      this.fight.winner = f2.name;
+      this.fight.method = "TKO";
+      return true;
+    }
+    if (f2.cuts >= 3) {
+      this.fight.winner = f1.name;
+      this.fight.method = "TKO";
+      return true;
+    }
+    return false;
+  }
+  checkExhaustion() {
+    if (this.fight.fighter1.currentStamina < 5 && this.fight.fighter2.currentStamina < 5) {
+      const f1Damage = 100 - this.fight.fighter2.currentHealth;
+      const f2Damage = 100 - this.fight.fighter1.currentHealth;
+      if (f1Damage > f2Damage) {
+        this.fight.winner = this.fight.fighter1.name;
+      } else if (f2Damage > f1Damage) {
+        this.fight.winner = this.fight.fighter2.name;
+      } else {
+        this.fight.winner = void 0;
+        this.fight.method = "DRAW";
+        return true;
+      }
+      this.fight.method = "TKO";
+      return true;
+    }
+    return false;
+  }
+  endRound() {
+    const currentRound = this.fight.rounds[this.fight.currentRound - 1];
+    currentRound.isActive = false;
+    this.fight.fighter1.currentHealth = Math.min(100, this.fight.fighter1.currentHealth + this.fight.fighter1.recovery * 0.5);
+    this.fight.fighter2.currentHealth = Math.min(100, this.fight.fighter2.currentHealth + this.fight.fighter2.recovery * 0.5);
+    this.fight.fighter1.currentStamina = 100;
+    this.fight.fighter2.currentStamina = 100;
+    this.fight.fighter1.position = "standing";
+    this.fight.fighter2.position = "standing";
+    this.onRoundEnd?.(currentRound);
+    if (this.fight.currentRound >= TOTAL_ROUNDS) {
+      this.endFightByDecision();
+    } else {
+      this.fight.currentRound++;
+      this.fight.rounds.push(this.createRound(this.fight.currentRound));
+      this.fight.rounds[this.fight.currentRound - 1].isActive = true;
+    }
+  }
+  endFightByDecision() {
+    const f1Score = 100 - this.fight.fighter2.currentHealth + this.fight.fighter1.takedownsLanded * 10 + this.fight.fighter1.significantStrikes * 2;
+    const f2Score = 100 - this.fight.fighter1.currentHealth + this.fight.fighter2.takedownsLanded * 10 + this.fight.fighter2.significantStrikes * 2;
+    if (f1Score > f2Score) {
+      this.fight.winner = this.fight.fighter1.name;
+    } else if (f2Score > f1Score) {
+      this.fight.winner = this.fight.fighter2.name;
+    } else {
+      this.fight.winner = void 0;
+    }
+    this.fight.method = this.fight.winner ? "DEC" : "DRAW";
+    this.endFight();
+  }
+  endFight() {
+    this.pause();
+    this.fight.isComplete = true;
+    this.fight.endRound = this.fight.currentRound;
+    this.fight.endTime = this.fight.rounds[this.fight.currentRound - 1]?.timeRemaining;
+    this.onFightEnd?.(this.fight);
+  }
+  // Parse skills.md content into FighterStats
+  static parseSkillsMd(content) {
+    const stats = { ...DEFAULT_FIGHTER };
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const [key, value] = line.split(":").map((s) => s.trim());
+      if (!key || !value) continue;
+      const numValue = parseFloat(value);
+      if (isNaN(numValue)) {
+        if (key === "name") stats.name = value;
+        if (key === "nickname") stats.nickname = value;
+        continue;
+      }
+      switch (key.toLowerCase()) {
+        case "striking":
+        case "boxing":
+          stats.striking = numValue;
+          break;
+        case "punch_speed":
+        case "handspeed":
+          stats.punchSpeed = numValue;
+          break;
+        case "kicks":
+        case "kick_power":
+          stats.kickPower = numValue;
+          break;
+        case "head_movement":
+        case "defense":
+          stats.headMovement = numValue;
+          break;
+        case "wrestling":
+        case "takedowns":
+          stats.wrestling = numValue;
+          break;
+        case "takedown_defense":
+        case "tdd":
+          stats.takedownDefense = numValue;
+          break;
+        case "bjj":
+        case "submissions":
+          stats.submissions = numValue;
+          break;
+        case "submission_defense":
+          stats.submissionDefense = numValue;
+          break;
+        case "ground_game":
+        case "grappling":
+          stats.groundGame = numValue;
+          break;
+        case "cardio":
+        case "stamina":
+          stats.cardio = numValue;
+          break;
+        case "chin":
+        case "durability":
+          stats.chin = numValue;
+          break;
+        case "recovery":
+          stats.recovery = numValue;
+          break;
+        case "iq":
+        case "fight_iq":
+          stats.fightIQ = numValue;
+          break;
+        case "heart":
+          stats.heart = numValue;
+          break;
+        case "aggression":
+          stats.aggression = numValue;
+          break;
+      }
+    }
+    return stats;
+  }
+}
+var FightEngine_default = FightEngine;
+export {
+  FightEngine,
+  FightEngine_default as default
+};
+//# sourceMappingURL=FightEngine.js.map