ttrpg_manager/src/lib/assistant/director/context.ts

import type { Campaign, Character, Encounter, Combatant } from '@/lib/schemas';
import { getSystem } from '@/lib/rules';
import { deriveState } from '@/lib/mechanics';
import { currentCombatant } from '@/lib/combat/engine';
import type { DirectorPersona, DirectorScene, SceneActor, SceneEncounter } from './types';

/** Default base speed used for a bare combatant (it carries no speed field). */
const DEFAULT_SPEED = 30;

function buildSystemConstraint(systemLabel: string, system: string): string {
  return (
    `This is a ${systemLabel} (system id: ${system}) campaign. ` +
    `Only use ${systemLabel} rules, creatures, classes, feats, and options. ` +
    `Never bring in content from any other game system.`
  );
}

function combatantActor(system: Campaign['system'], c: Combatant): SceneActor {
  const conditions = c.conditions.map((cn) => (cn.value ? `${cn.name} ${cn.value}` : cn.name));
  const badges = deriveState(system, DEFAULT_SPEED, c.conditions).badges;
  return {
    name: c.name,
    kind: c.kind,
    ...(c.characterId ? { characterId: c.characterId } : {}),
    combatantId: c.id,
    hp: c.hp,
    ac: c.ac,
    conditions,
    ...(badges.length ? { badges } : {}),
  };
}

function pcActor(c: Character): SceneActor {
  const conditions = c.conditions.map((cn) => (cn.value ? `${cn.name} ${cn.value}` : cn.name));
  const badges = deriveState(c.system, c.speed, c.conditions).badges;
  return {
    name: c.name,
    kind: c.kind === 'npc' ? 'npc' : 'pc',
    characterId: c.id,
    hp: c.hp,
    conditions,
    ...(badges.length ? { badges } : {}),
  };
}

/**
 * Assemble the grounded scene the director may reference. The roster + addCandidates
 * are a CLOSED set: when an encounter is active the roster is its live combatants;
 * otherwise it is the party (plus tracked NPCs). Pure and synchronous.
 */
export function buildDirectorScene(input: {
  campaign: Campaign;
  characters: Character[];
  encounter?: Encounter | undefined;
  persona: DirectorPersona;
  narrationStyle?: string | undefined;
  controlledCharacterId?: string | undefined;
  transcriptWindow: DirectorScene['transcriptWindow'];
  summary?: string | undefined;
  addCandidates?: string[] | undefined;
}): DirectorScene {
  const { campaign, characters, encounter, persona } = input;
  const system = campaign.system;
  const systemLabel = getSystem(system).label;

  let roster: SceneActor[];
  let sceneEncounter: SceneEncounter | undefined;

  if (encounter && encounter.status === 'active') {
    const cur = currentCombatant(encounter);
    roster = encounter.combatants.map((c) => combatantActor(system, c));
    sceneEncounter = {
      name: encounter.name,
      round: encounter.round,
      ...(cur ? { currentActorName: cur.name } : {}),
      combatants: encounter.combatants.map((c) => ({ name: c.name, kind: c.kind, initiative: c.initiative, current: c.id === cur?.id })),
    };
  } else {
    roster = characters.filter((c) => c.kind === 'pc' || c.kind === 'npc').map(pcActor);
  }

  const controlled = input.controlledCharacterId
    ? roster.find((a) => a.characterId === input.controlledCharacterId)
    : undefined;

  return {
    system,
    systemLabel,
    systemConstraint: buildSystemConstraint(systemLabel, system),
    persona,
    campaignName: campaign.name,
    ...(input.narrationStyle ? { narrationStyle: input.narrationStyle } : {}),
    roster,
    ...(sceneEncounter ? { encounter: sceneEncounter } : {}),
    ...(controlled ? { controlledName: controlled.name } : {}),
    addCandidates: input.addCandidates ?? [],
    transcriptWindow: input.transcriptWindow,
    ...(input.summary ? { summary: input.summary } : {}),
  };
}