First Commit

2026-06-30 09:10:05 +10:00
commit 6e0d3d0e1e
14 changed files with 10546 additions and 0 deletions
@@ -0,0 +1,560 @@
+const path = require('path');
+const express = require('express');
+const dbApi = require('./db.js');
+const rq3 = require('./rq3.js');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+app.use(express.json());
+app.use(express.static(path.join(__dirname, 'public')));
+
+function notFound(res, what) {
+  return res.status(404).json({ error: `${what} not found` });
+}
+
+// ---------- NPCs ----------
+
+const NPC_CORE_FIELD_BY_COLUMN = {
+  'first name': 'first_name',
+  'last name': 'last_name',
+  'brief description': 'brief_description',
+  'wants and needs': 'wants_needs',
+  'secret or obstacle': 'secret_obstacle',
+  'also carrying': 'also_carrying',
+};
+
+const NPC_ATTRIBUTE_ROLES = {
+  race: 'npc_race',
+  pronouns: 'npc_pronouns',
+  age: 'npc_age',
+  intelligence: 'npc_intelligence',
+  hair: 'npc_hair',
+  build: 'npc_build',
+};
+
+function rollCoreFields() {
+  const table = dbApi.tables.findByNpcRole('npc_core');
+  if (!table) return {};
+  const result = dbApi.tables.roll(table.id);
+  const fields = {};
+  table.columns.forEach((col, idx) => {
+    const key = NPC_CORE_FIELD_BY_COLUMN[col.column_name.toLowerCase().trim()];
+    if (key) fields[key] = result.row.cells[idx];
+  });
+  return fields;
+}
+
+function rollAttributeField(field) {
+  const role = NPC_ATTRIBUTE_ROLES[field];
+  if (!role) return null;
+  const table = dbApi.tables.findByNpcRole(role);
+  if (!table) return null;
+  const result = dbApi.tables.roll(table.id);
+  return result.row.cells[0];
+}
+
+function generateNpcFields(npcType) {
+  const core = rollCoreFields();
+  if (npcType === 'filler') {
+    return {
+      npc_type: 'filler',
+      first_name: core.first_name,
+      last_name: core.last_name,
+      brief_description: core.brief_description,
+    };
+  }
+  const fields = { npc_type: 'full', ...core };
+  for (const attr of Object.keys(NPC_ATTRIBUTE_ROLES)) {
+    fields[attr] = rollAttributeField(attr);
+  }
+  return fields;
+}
+
+app.get('/api/npcs', (req, res) => {
+  res.json(dbApi.npcs.list());
+});
+
+app.get('/api/npcs/:id', (req, res) => {
+  const npc = dbApi.npcs.get(req.params.id);
+  if (!npc) return notFound(res, 'NPC');
+  res.json(npc);
+});
+
+app.post('/api/npcs', (req, res) => {
+  const npc = dbApi.npcs.create(req.body || {});
+  const name = `${npc.first_name || ''} ${npc.last_name || ''}`.trim();
+  dbApi.log.append({ type: 'npc', summary: `Created NPC "${name}"`, details: npc });
+  res.status(201).json(npc);
+});
+
+app.post('/api/npcs/generate', (req, res) => {
+  const npcType = req.body && req.body.npc_type === 'filler' ? 'filler' : 'full';
+  const fields = generateNpcFields(npcType);
+  const npc = dbApi.npcs.create(fields);
+  const name = `${npc.first_name || '?'} ${npc.last_name || ''}`.trim();
+  dbApi.log.append({ type: 'npc', summary: `Generated ${npcType} NPC "${name}"`, details: npc });
+  res.status(201).json(npc);
+});
+
+app.put('/api/npcs/:id', (req, res) => {
+  const npc = dbApi.npcs.update(req.params.id, req.body || {});
+  if (!npc) return notFound(res, 'NPC');
+  dbApi.log.append({ type: 'npc', summary: `Updated NPC #${npc.id}`, details: npc });
+  res.json(npc);
+});
+
+app.post('/api/npcs/:id/reroll-field', (req, res) => {
+  const npc = dbApi.npcs.get(req.params.id);
+  if (!npc) return notFound(res, 'NPC');
+  const field = req.body && req.body.field;
+  if (!field) return res.status(400).json({ error: 'field is required' });
+
+  let value;
+  if (Object.values(NPC_CORE_FIELD_BY_COLUMN).includes(field)) {
+    const core = rollCoreFields();
+    value = core[field];
+  } else if (NPC_ATTRIBUTE_ROLES[field]) {
+    value = rollAttributeField(field);
+  } else {
+    return res.status(400).json({ error: `Unknown rerollable field "${field}"` });
+  }
+
+  const updated = dbApi.npcs.update(npc.id, { [field]: value });
+  dbApi.log.append({ type: 'npc', summary: `Re-rolled "${field}" for NPC #${npc.id}`, details: { field, value } });
+  res.json(updated);
+});
+
+app.delete('/api/npcs/:id', (req, res) => {
+  const ok = dbApi.npcs.delete(req.params.id);
+  if (!ok) return notFound(res, 'NPC');
+  dbApi.log.append({ type: 'npc', summary: `Deleted NPC #${req.params.id}` });
+  res.status(204).end();
+});
+
+app.post('/api/npcs/:id/generate-stat-block', (req, res) => {
+  const npc = dbApi.npcs.get(req.params.id);
+  if (!npc) return notFound(res, 'NPC');
+  if (npc.stat_block) return res.status(400).json({ error: 'NPC already has a stat block' });
+  const statBlock = rollHumanoidStatBlock();
+  const created = dbApi.statBlocks.create(statBlock);
+  dbApi.statBlocks.setHitLocations(created.id, rq3.computeHitLocations(statBlock.max_hp));
+  const updated = dbApi.npcs.linkStatBlock(npc.id, created.id);
+  dbApi.log.append({ type: 'npc', summary: `Attached stat block to NPC #${npc.id}` });
+  res.status(201).json(updated);
+});
+
+// ---------- Enemies ----------
+
+function applyStatBlockUpdate(enemy, statBlockPatch) {
+  if (!statBlockPatch) return;
+  const { hit_locations, weapons, spells, ...characteristics } = statBlockPatch;
+  if (Object.keys(characteristics).length) {
+    dbApi.statBlocks.update(enemy.stat_block_id, characteristics);
+  }
+  if (hit_locations) dbApi.statBlocks.setHitLocations(enemy.stat_block_id, hit_locations);
+  if (weapons) dbApi.statBlocks.setWeapons(enemy.stat_block_id, weapons);
+  if (spells) dbApi.statBlocks.setSpells(enemy.stat_block_id, spells);
+}
+
+app.get('/api/enemies', (req, res) => {
+  res.json(dbApi.enemies.list());
+});
+
+app.get('/api/enemies/:id', (req, res) => {
+  const enemy = dbApi.enemies.get(req.params.id);
+  if (!enemy) return notFound(res, 'Enemy');
+  res.json(enemy);
+});
+
+app.post('/api/enemies', (req, res) => {
+  const enemy = dbApi.enemies.create(req.body || {});
+  dbApi.log.append({ type: 'enemy', summary: `Created enemy "${enemy.name}"`, details: enemy });
+  res.status(201).json(enemy);
+});
+
+// Rolls a fresh humanoid stat block (characteristics, HP, hit locations) via rq3.js,
+// shared by enemy generation and the NPC "attach stat block" action.
+function rollHumanoidStatBlock() {
+  const chars = rq3.rollCharacteristics();
+  const maxHp = Math.ceil((chars.con + chars.siz) / 2);
+  return {
+    ...chars,
+    max_hp: maxHp,
+    current_hp: maxHp,
+    move: 8,
+    magic_points_max: chars.pow,
+    magic_points_current: chars.pow,
+    culture: rq3.rollCulture(),
+  };
+}
+
+app.post('/api/enemies/generate', (req, res) => {
+  const name = (req.body && req.body.name) || 'Unnamed Enemy';
+  const category = (req.body && req.body.category) || 'Humanoid';
+  const statBlock = rollHumanoidStatBlock();
+  const enemy = dbApi.enemies.create({ name, category, stat_block: statBlock });
+  dbApi.statBlocks.setHitLocations(enemy.stat_block.id, rq3.computeHitLocations(statBlock.max_hp));
+  const refreshed = dbApi.enemies.get(enemy.id);
+  dbApi.log.append({ type: 'enemy', summary: `Generated enemy "${refreshed.name}" (${category})`, details: refreshed });
+  res.status(201).json(refreshed);
+});
+
+app.put('/api/enemies/:id', (req, res) => {
+  const existing = dbApi.enemies.get(req.params.id);
+  if (!existing) return notFound(res, 'Enemy');
+  const { stat_block, ...rest } = req.body || {};
+  const enemy = dbApi.enemies.update(req.params.id, rest);
+  applyStatBlockUpdate(enemy, stat_block);
+  const refreshed = dbApi.enemies.get(req.params.id);
+  dbApi.log.append({ type: 'enemy', summary: `Updated enemy "${refreshed.name}"`, details: refreshed });
+  res.json(refreshed);
+});
+
+app.delete('/api/enemies/:id', (req, res) => {
+  const existing = dbApi.enemies.get(req.params.id);
+  if (!existing) return notFound(res, 'Enemy');
+  dbApi.enemies.delete(req.params.id);
+  dbApi.log.append({ type: 'enemy', summary: `Deleted enemy "${existing.name}"` });
+  res.status(204).end();
+});
+
+// ---------- Log ----------
+
+app.get('/api/log', (req, res) => {
+  res.json(dbApi.log.search(req.query.search || ''));
+});
+
+app.post('/api/log', (req, res) => {
+  const { type, summary, details } = req.body || {};
+  if (!type || !summary) return res.status(400).json({ error: 'type and summary are required' });
+  const entry = dbApi.log.append({ type, summary, details });
+  res.status(201).json(entry);
+});
+
+app.get('/api/export/log', (req, res) => {
+  const entries = dbApi.log.search('');
+  const md = [
+    '# Session Log',
+    '',
+    ...entries.map((e) => {
+      const details = e.details ? `\n\n\`\`\`json\n${JSON.stringify(e.details, null, 2)}\n\`\`\`` : '';
+      return `## ${e.created_at} — ${e.type}\n\n${e.summary}${details}\n`;
+    }),
+  ].join('\n');
+  const filename = `session-log-${new Date().toISOString().replace(/[:.]/g, '-')}.md`;
+  res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+  res.setHeader('Content-Type', 'text/markdown');
+  res.send(md);
+});
+
+// ---------- Combat ----------
+
+app.get('/api/combat', (req, res) => {
+  res.json(dbApi.combat.get());
+});
+
+app.post('/api/combat', (req, res) => {
+  const state = dbApi.combat.set(req.body || {});
+  dbApi.log.append({ type: 'combat', summary: 'Combat state updated', details: req.body });
+  res.json(state);
+});
+
+app.delete('/api/combat', (req, res) => {
+  dbApi.combat.clear();
+  dbApi.log.append({ type: 'combat', summary: 'Combat ended' });
+  res.status(204).end();
+});
+
+function findWeaponDef(weaponName, category) {
+  const pools = [rq3.MELEE_WEAPONS, rq3.NATURAL_WEAPONS, rq3.MISSILE_WEAPONS];
+  for (const pool of pools) {
+    const match = pool.find((w) =>
+      w.weapon.toLowerCase() === weaponName.toLowerCase() && (!category || !w.category || w.category === category)
+    );
+    if (match) return match;
+  }
+  for (const pool of pools) {
+    const match = pool.find((w) => w.weapon.toLowerCase() === weaponName.toLowerCase());
+    if (match) return match;
+  }
+  return null;
+}
+
+function combatantSourceRecord(ref) {
+  if (ref.type === 'enemy') return dbApi.enemies.get(ref.id);
+  if (ref.type === 'npc') return dbApi.npcs.get(ref.id);
+  throw new Error(`Unknown combatant ref type "${ref.type}"`);
+}
+
+function buildCombatantSnapshot(ref) {
+  const source = combatantSourceRecord(ref);
+  if (!source) return null;
+  const sb = source.stat_block;
+  if (!sb) return null;
+  const name = ref.type === 'enemy' ? source.name : `${source.first_name || ''} ${source.last_name || ''}`.trim();
+  return {
+    id: Math.random().toString(36).slice(2, 9),
+    ref,
+    statBlockId: sb.id,
+    name,
+    str: sb.str, con: sb.con, siz: sb.siz, int: sb.int, pow: sb.pow, dex: sb.dex, app: sb.app,
+    currentHp: sb.current_hp,
+    maxHp: sb.max_hp,
+    magicPointsCurrent: sb.magic_points_current,
+    magicPointsMax: sb.magic_points_max,
+    strikeRank: rq3.baseStrikeRank({ dex: sb.dex, siz: sb.siz }),
+    hitLocations: sb.hit_locations.map((l) => ({ ...l })),
+    weapons: sb.weapons.map((w) => ({ ...w })),
+    spells: sb.spells.map((s) => ({ ...s })),
+    status: 'active',
+  };
+}
+
+app.post('/api/combat/add-combatant', (req, res) => {
+  const { type, id } = req.body || {};
+  if (!type || !id) return res.status(400).json({ error: 'type and id are required' });
+  const snapshot = buildCombatantSnapshot({ type, id });
+  if (!snapshot) return notFound(res, 'Combatant source');
+  const current = dbApi.combat.get();
+  const state = current ? current.state : { round: 1, combatants: [] };
+  state.combatants = state.combatants || [];
+  state.combatants.push(snapshot);
+  const saved = dbApi.combat.set(state);
+  dbApi.log.append({ type: 'combat', summary: `${snapshot.name} joined combat (SR ${snapshot.strikeRank})`, details: snapshot });
+  res.status(201).json(saved);
+});
+
+app.post('/api/combat/attack', (req, res) => {
+  const { attackerCombatantId, defenderCombatantId, weaponName, declaredMode, attackKind = 'melee', thrown = false, reaction, modifierIds = [] } = req.body || {};
+  const current = dbApi.combat.get();
+  if (!current) return res.status(400).json({ error: 'No active combat' });
+  const state = current.state;
+  const attacker = (state.combatants || []).find((c) => c.id === attackerCombatantId);
+  const defender = (state.combatants || []).find((c) => c.id === defenderCombatantId);
+  if (!attacker || !defender) return res.status(400).json({ error: 'Unknown attacker or defender combatant id' });
+
+  const weaponEntry = attacker.weapons.find((w) => w.weapon_name.toLowerCase() === (weaponName || '').toLowerCase());
+  if (!weaponEntry) return res.status(400).json({ error: `Attacker has no weapon named "${weaponName}"` });
+  const weaponDef = findWeaponDef(weaponEntry.weapon_name, weaponEntry.category);
+  if (!weaponDef) return res.status(400).json({ error: `No rq3 weapon definition found for "${weaponEntry.weapon_name}"` });
+
+  if (weaponDef.type === rq3.WEAPON_TYPE.DUAL && declaredMode !== 'impale' && declaredMode !== 'slash') {
+    return res.status(400).json({ error: `"${weaponEntry.weapon_name}" is dual-mode; declaredMode must be 'impale' or 'slash'` });
+  }
+
+  const modifierTotal = rq3.sumAttackModifiers(modifierIds, { targetSiz: defender.siz });
+  const effectiveSkillPercent = weaponEntry.skill_percent + modifierTotal;
+  const attackCheck = rq3.resolveSkillCheck(effectiveSkillPercent);
+  const result = { attackCheck, weapon: weaponEntry.weapon_name, modifierTotal, effectiveSkillPercent };
+
+  if (attackCheck.tier === 'fumble') {
+    result.fumble = rq3.rollFumble(attackKind === 'missile' ? 'missile' : 'meleeParry');
+  }
+
+  let damageThrough = 0;
+  let hitLocationRoll = null;
+  let damageResult = null;
+  let parryOrDodge = null;
+
+  if (attackCheck.tier !== 'fumble' && attackCheck.tier !== 'failure') {
+    if (reaction && reaction.type === 'dodge') {
+      parryOrDodge = rq3.resolveDodge({ dodgeSkillPercent: reaction.skillPercent, attackTier: attackCheck.tier });
+      damageThrough = parryOrDodge.avoided ? 0 : null; // null = not yet determined, fall through to damage calc
+    }
+    if (!parryOrDodge || !parryOrDodge.avoided) {
+      damageResult = rq3.resolveAttackDamage({
+        weapon: weaponDef,
+        tier: attackCheck.tier,
+        strPlusSiz: attacker.str + attacker.siz,
+        declaredMode,
+        thrown,
+      });
+      hitLocationRoll = rq3.rollHitLocation(attackKind);
+      const location = defender.hitLocations.find((l) => l.location_name === hitLocationRoll.location);
+
+      if (reaction && reaction.type === 'parry') {
+        parryOrDodge = rq3.resolveParry({ parrySkillPercent: reaction.skillPercent });
+        const parryWeapon = defender.weapons.find((w) => w.weapon_name.toLowerCase() === (reaction.weaponName || '').toLowerCase());
+        const applied = rq3.applyParryToDamage({
+          parryEffect: parryOrDodge.effect,
+          damage: damageResult.damage,
+          parryingItemAp: parryWeapon ? findWeaponDef(parryWeapon.weapon_name, parryWeapon.category)?.ap : 0,
+        });
+        damageThrough = applied.damageThrough;
+      } else {
+        damageThrough = damageResult.damage;
+      }
+
+      if (damageThrough > 0 && location) {
+        const applied = rq3.applyDamageToLocation({
+          hitLocation: location,
+          totalHp: defender.currentHp,
+          damage: damageThrough,
+          ignoresArmor: damageResult.ignoresArmor,
+        });
+        location.current_hp = applied.newLocationHp;
+        location.disabled = applied.disabled;
+        defender.currentHp = applied.newTotalHp;
+        result.damageApplied = applied;
+        defender.status = rq3.checkIncapacitation({ totalHp: defender.currentHp, con: defender.con }) === 'conscious'
+          ? 'active' : rq3.checkIncapacitation({ totalHp: defender.currentHp, con: defender.con });
+      }
+    }
+  }
+
+  result.damageResult = damageResult;
+  result.hitLocationRoll = hitLocationRoll;
+  result.reactionResult = parryOrDodge;
+  result.damageThrough = damageThrough;
+
+  dbApi.combat.set(state);
+  dbApi.statBlocks.update(defender.statBlockId, { current_hp: defender.currentHp });
+  dbApi.statBlocks.setHitLocations(defender.statBlockId, defender.hitLocations);
+
+  dbApi.log.append({
+    type: 'combat',
+    summary: `${attacker.name} attacks ${defender.name} with ${weaponEntry.weapon_name}: ${attackCheck.tier}${damageThrough ? `, ${damageThrough} dmg to ${hitLocationRoll?.location}` : ''}`,
+    details: result,
+  });
+
+  res.json({ combatState: dbApi.combat.get(), result });
+});
+
+app.post('/api/combat/cast-spell', (req, res) => {
+  const { casterCombatantId, targetCombatantId, mechanicId, mpSpent } = req.body || {};
+  const current = dbApi.combat.get();
+  if (!current) return res.status(400).json({ error: 'No active combat' });
+  const state = current.state;
+  const caster = (state.combatants || []).find((c) => c.id === casterCombatantId);
+  if (!caster) return res.status(400).json({ error: 'Unknown caster combatant id' });
+  const target = (state.combatants || []).find((c) => c.id === targetCombatantId) || null;
+
+  const def = rq3.SPELL_MECHANICS[mechanicId];
+  if (!def) return res.status(400).json({ error: `Unknown spell mechanic "${mechanicId}"` });
+  if (caster.magicPointsCurrent < mpSpent) return res.status(400).json({ error: 'Not enough magic points' });
+
+  const spellResult = rq3.castSpell(mechanicId, mpSpent, {
+    casterPow: caster.pow,
+    targetPow: target ? target.pow : undefined,
+  });
+  caster.magicPointsCurrent -= spellResult.mpSpent;
+
+  if (spellResult.damage && target) {
+    const hitLocationRoll = rq3.rollHitLocation('melee');
+    const location = target.hitLocations.find((l) => l.location_name === hitLocationRoll.location);
+    if (location) {
+      const applied = rq3.applyDamageToLocation({
+        hitLocation: location, totalHp: target.currentHp, damage: spellResult.damage, ignoresArmor: spellResult.ignoresArmor,
+      });
+      location.current_hp = applied.newLocationHp;
+      location.disabled = applied.disabled;
+      target.currentHp = applied.newTotalHp;
+      dbApi.statBlocks.update(target.statBlockId, { current_hp: target.currentHp });
+      dbApi.statBlocks.setHitLocations(target.statBlockId, target.hitLocations);
+    }
+  }
+  if (spellResult.healHp && target) {
+    target.currentHp = Math.min(target.maxHp, target.currentHp + spellResult.healHp);
+    dbApi.statBlocks.update(target.statBlockId, { current_hp: target.currentHp });
+  }
+
+  dbApi.combat.set(state);
+  dbApi.statBlocks.update(caster.statBlockId, { magic_points_current: caster.magicPointsCurrent });
+
+  dbApi.log.append({
+    type: 'spell',
+    summary: `${caster.name} casts ${spellResult.name}${target ? ` on ${target.name}` : ''} (${spellResult.mpSpent} MP)`,
+    details: spellResult,
+  });
+
+  res.json({ combatState: dbApi.combat.get(), result: spellResult });
+});
+
+// ---------- Tables (roller) ----------
+
+app.get('/api/tables/tree', (req, res) => {
+  res.json(dbApi.tables.getTree());
+});
+
+app.get('/api/tables/:id', (req, res) => {
+  const table = dbApi.tables.getById(req.params.id);
+  if (!table) return notFound(res, 'Table');
+  res.json(table);
+});
+
+app.post('/api/tables/:id/roll', (req, res) => {
+  const result = dbApi.tables.roll(req.params.id);
+  if (!result) return notFound(res, 'Table');
+  dbApi.log.append({
+    type: 'roll',
+    summary: `Rolled on "${result.table.name}": ${result.row.cells.join(' / ')}`,
+    details: { table_id: result.table.id, row: result.row, links: result.links },
+  });
+  res.json(result);
+});
+
+// ---------- Rules reference (read-only lookups for the frontend) ----------
+
+app.get('/api/rules/attack-modifiers', (req, res) => {
+  res.json(rq3.ATTACK_MODIFIERS);
+});
+
+app.get('/api/rules/armor-table', (req, res) => {
+  res.json(rq3.ARMOR_TABLE);
+});
+
+app.get('/api/rules/cultural-bonus', (req, res) => {
+  const { culture, category, weapon } = req.query;
+  if (!culture || !category) return res.status(400).json({ error: 'culture and category are required' });
+  res.json(rq3.culturalWeaponBonus(culture, category, weapon));
+});
+
+// ---------- Spell mappings ----------
+
+app.get('/api/spell-mappings', (req, res) => {
+  res.json(dbApi.spellMappings.list());
+});
+
+app.post('/api/spell-mappings', (req, res) => {
+  const { custom_name, mechanic_id, default_mp_cost } = req.body || {};
+  if (!custom_name || !mechanic_id) {
+    return res.status(400).json({ error: 'custom_name and mechanic_id are required' });
+  }
+  const mapping = dbApi.spellMappings.upsert({ custom_name, mechanic_id, default_mp_cost });
+  res.status(201).json(mapping);
+});
+
+// ---------- Export / Import ----------
+
+app.get('/api/export', (req, res) => {
+  const dump = dbApi.exportAll();
+  const filename = `story-tool-export-${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
+  res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+  res.json(dump);
+});
+
+app.post('/api/import', (req, res) => {
+  if (!req.body || typeof req.body !== 'object') {
+    return res.status(400).json({ error: 'Request body must be a JSON export dump' });
+  }
+  const dump = dbApi.importAll(req.body);
+  dbApi.log.append({ type: 'note', summary: 'Data imported from JSON dump' });
+  res.json(dump);
+});
+
+// ---------- Errors ----------
+
+app.use((req, res) => {
+  res.status(404).json({ error: 'Not found' });
+});
+
+// eslint-disable-next-line no-unused-vars
+app.use((err, req, res, next) => {
+  console.error(err);
+  res.status(500).json({ error: err.message || 'Internal server error' });
+});
+
+app.listen(PORT, () => {
+  console.log(`RQ3 Story Tool listening on http://localhost:${PORT}`);
+});