DuelOrchestrator
├── Creates DuelCombatAI instances for each fighter
├── Wires sendChatMessage callbacks
└── Passes messages to social system

DuelCombatAI
├── Health monitoring (self + opponent)
├── Threshold tracking (75%, 50%, 25%, 10%)
├── LLM taunt generation (character-specific)
├── Scripted fallback pools
├── Ambient taunt timer (15-25 ticks)
└── 8-second cooldown enforcement

Social System
└── Broadcasts CHAT_MESSAGE to spectators + participants

// Track health thresholds for self and opponent
private lastSelfHealthThreshold = 100;
private lastOpponentHealthThreshold = 100;
private lastTauntTime = 0;
private ambientTauntTimer = 0;

// Health thresholds that trigger taunts
private readonly HEALTH_THRESHOLDS = [75, 50, 25, 10];
private readonly TAUNT_COOLDOWN_MS = 8000;
private readonly AMBIENT_TAUNT_INTERVAL_MIN = 15; // ticks
private readonly AMBIENT_TAUNT_INTERVAL_MAX = 25; // ticks

private async generateTaunt(context: string): Promise<string> {
  // Try LLM generation first
  if (this.runtime) {
    try {
      const prompt = `You are ${this.agentName}, a fighter in a duel arena.
Character: ${this.characterBio}
Context: ${context}
Generate a short, in-character taunt (1-2 sentences max).`;

      const response = await generateText({
        runtime: this.runtime,
        context: prompt,
        modelClass: ModelClass.TEXT_SMALL,
      });

      return response.trim();
    } catch (error) {
      console.warn(`[DuelCombatAI] LLM taunt generation failed:`, error);
    }
  }

  // Fallback to scripted taunts
  return this.getScriptedTaunt(context);
}

private getScriptedTaunt(context: string): string {
  const pools = {
    self_low: [
      "I'm not done yet!",
      "This is just a scratch!",
      "You'll have to do better than that!",
    ],
    opponent_low: [
      "You're looking weak!",
      "Almost got you!",
      "One more hit should do it!",
    ],
    ambient: [
      "Let's see what you've got!",
      "This is what I trained for!",
      "May the best fighter win!",
    ],
  };

  const pool = pools[context] || pools.ambient;
  return pool[Math.floor(Math.random() * pool.length)];
}

private checkHealthThresholds(
  selfHealth: number,
  selfMaxHealth: number,
  opponentHealth: number,
  opponentMaxHealth: number,
): void {
  const now = Date.now();
  if (now - this.lastTauntTime < this.TAUNT_COOLDOWN_MS) return;

  const selfPercent = (selfHealth / selfMaxHealth) * 100;
  const opponentPercent = (opponentHealth / opponentMaxHealth) * 100;

  // Check self health thresholds (descending)
  for (const threshold of this.HEALTH_THRESHOLDS) {
    if (
      selfPercent <= threshold &&
      this.lastSelfHealthThreshold > threshold
    ) {
      this.sendTaunt(`self_health_${threshold}`);
      this.lastSelfHealthThreshold = threshold;
      this.lastTauntTime = now;
      return;
    }
  }

  // Check opponent health thresholds (descending)
  for (const threshold of this.HEALTH_THRESHOLDS) {
    if (
      opponentPercent <= threshold &&
      this.lastOpponentHealthThreshold > threshold
    ) {
      this.sendTaunt(`opponent_health_${threshold}`);
      this.lastOpponentHealthThreshold = threshold;
      this.lastTauntTime = now;
      return;
    }
  }
}

private updateAmbientTaunts(ticksPassed: number): void {
  this.ambientTauntTimer -= ticksPassed;
  
  if (this.ambientTauntTimer <= 0) {
    const now = Date.now();
    if (now - this.lastTauntTime >= this.TAUNT_COOLDOWN_MS) {
      this.sendTaunt("ambient");
      this.lastTauntTime = now;
    }
    
    // Reset timer with randomized interval
    this.ambientTauntTimer =
      this.AMBIENT_TAUNT_INTERVAL_MIN +
      Math.random() * (this.AMBIENT_TAUNT_INTERVAL_MAX - this.AMBIENT_TAUNT_INTERVAL_MIN);
  }
}

// Create combat AIs with chat callbacks
this.combatAI1 = new DuelCombatAI(
  this.world,
  agent1.id,
  agent2.id,
  agent1.name,
  agent1.characterBio,
  agent1.runtime,
  (message: string) => this.sendChatMessage(agent1.id, message),
);

this.combatAI2 = new DuelCombatAI(
  this.world,
  agent2.id,
  agent1.id,
  agent2.name,
  agent2.characterBio,
  agent2.runtime,
  (message: string) => this.sendChatMessage(agent2.id, message),
);

// Send chat message via social system
private sendChatMessage(agentId: string, message: string): void {
  const socialSystem = this.world.getSystem("social") as SocialSystem;
  if (!socialSystem) return;

  socialSystem.handleChatMessage({
    playerId: agentId,
    message,
    channel: "public",
  });
}

// CHAT_MESSAGE action now allowed during combat
const ALLOWED_ACTIONS_DURING_COMBAT = [
  "CHAT_MESSAGE",  // Added for trash talk system
  // ... other actions ...
];

private readonly TAUNT_COOLDOWN_MS = 8000; // 8 seconds between taunts

private readonly AMBIENT_TAUNT_INTERVAL_MIN = 15; // ticks
private readonly AMBIENT_TAUNT_INTERVAL_MAX = 25; // ticks

modelClass: ModelClass.TEXT_SMALL  // Fast, cheap model for taunts

it("should generate LLM taunts with character context", async () => {
  const ai = new DuelCombatAI(
    world,
    "agent1",
    "agent2",
    "Warrior Bob",
    "A fierce warrior who never backs down",
    mockRuntime,
    mockSendChat,
  );

  await ai.sendTaunt("self_health_50");

  expect(mockRuntime.generateText).toHaveBeenCalledWith(
    expect.objectContaining({
      context: expect.stringContaining("Warrior Bob"),
      context: expect.stringContaining("fierce warrior"),
      modelClass: ModelClass.TEXT_SMALL,
    }),
  );
});