pf2e-sage-stats 0.1.1

package/src/app.ts

@@ -0,0 +1,623 @@
+import zod from 'zod';
+import { TSV } from 'tsv';
+import { capitalize, entries, startCase, toLower, kebabCase } from 'lodash';
+import dedent from 'dedent-js';
+import abbreviate from 'abbreviate';
+import pluralize from 'pluralize';
+
+const schema = zod.object({
+  name: zod.string(),
+  alias: zod.string().optional(),
+  level: zod.coerce.number().default(0),
+  maxhp: zod.coerce.number().default(0),
+  attributes: zod.object({
+    strength: zod.coerce.number().default(0),
+    dexterity: zod.coerce.number().default(0),
+    constitution: zod.coerce.number().default(0),
+    intelligence: zod.coerce.number().default(0),
+    wisdom: zod.coerce.number().default(0),
+    charisma: zod.coerce.number().default(0),
+  }).default({}),
+  saves: zod.object({
+    fortitude: zod.coerce.number().default(0),
+    reflex: zod.coerce.number().default(0),
+    will: zod.coerce.number().default(0),
+  }).default({}),
+  ac: zod.coerce.number().default(10),
+  perception: zod.coerce.number().default(0),
+  skills: zod.object({
+    acrobatics: zod.coerce.number().optional(),
+    arcana: zod.coerce.number().optional(),
+    athletics: zod.coerce.number().optional(),
+    crafting: zod.coerce.number().optional(),
+    deception: zod.coerce.number().optional(),
+    diplomacy: zod.coerce.number().optional(),
+    intimidation: zod.coerce.number().optional(),
+    medicine: zod.coerce.number().optional(),
+    nature: zod.coerce.number().optional(),
+    occultism: zod.coerce.number().optional(),
+    perfomance: zod.coerce.number().optional(),
+    religion: zod.coerce.number().optional(),
+    society: zod.coerce.number().optional(),
+    stealth: zod.coerce.number().optional(),
+    survival: zod.coerce.number().optional(),
+    thievery: zod.coerce.number().optional(),
+  }).default({}),
+  lores: zod.record(zod.string(), zod.object({
+    mod: zod.coerce.number().default(0),
+    name: zod.string(),
+  })).default({}),
+  melee: zod.record(zod.string(), zod.object({
+    mod: zod.coerce.number().default(0),
+    desc: zod.string(),
+    damage: zod.string(),
+  })).default({}),
+  ranged: zod.record(zod.string(), zod.object({
+    mod: zod.coerce.number().default(0),
+    desc: zod.string(),
+    damage: zod.string(),
+  })).default({}),
+  spells: zod.object({
+    attack: zod.coerce.number().optional(),
+    dc: zod.coerce.number().optional(),
+  }).default({}),
+  extra: zod.record(zod.string(), zod.coerce.number()).default({}),
+  extraDCs: zod.record(zod.string(), zod.coerce.number()).default({}),
+  extraDice: zod.record(zod.string(), zod.coerce.string()).default({}),
+  improvisation: zod.boolean().default(false),
+})
+
+export type Schema = zod.infer<typeof schema>;
+
+export const stub: Required<Schema> = {
+  name: 'name',
+  alias: 'nm',
+  level: 0,
+  maxhp: 0,
+  attributes: {
+    strength: 0,
+    dexterity: 0,
+    constitution: 0,
+    intelligence: 0,
+    wisdom: 0,
+    charisma: 0,
+  },
+  saves: {
+    fortitude: 0,
+    reflex: 0,
+    will: 0,
+  },
+  ac: 10,
+  perception: 0,
+  skills: {
+    acrobatics: 0,
+    arcana: 0,
+    athletics: 0,
+    crafting: 0,
+    deception: 0,
+    diplomacy: 0,
+    intimidation: 0,
+    medicine: 0,
+    nature: 0,
+    occultism: 0,
+    perfomance: 0,
+    religion: 0,
+    society: 0,
+    stealth: 0,
+    survival: 0,
+    thievery: 0,
+  },
+  lores: {},
+  melee: {
+    fist: { mod: 7, desc: 'fist (agile, finesse)', damage: '1d4 bludgeoning' }
+  },
+  ranged: {},
+  spells: {},
+  extra: {},
+  extraDCs: {},
+  extraDice: {},
+  improvisation: false,
+};
+
+const formatMap: Record<string, string> = {
+  xxs: 'xxs',
+  xs: 'xs',
+  s: 's',
+  m: 'm',
+  l: 'l',
+  xl: 'xl',
+  xxl: 'xxl',
+};
+
+export const prediceateMap: Record<string, string> = {
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`${v}`, `d20 >= ${v} flat;`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  c: 'd20 >= 5 flat;',
+  concealed: 'd20 >= 5 flat;',
+  h: 'd20 >= 11 flat;',
+  hidden: 'd20 >= 11 flat;',
+  none: '',
+};
+
+export const flatMap = Object.entries(prediceateMap).flatMap(([k, v]) => Object.entries(formatMap).map(([fk, fv]): [string, string] => (
+  [`${fk}_${k}`, `${fv} ${v}`]
+))).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {});
+
+export const valueNameMap: (tag: string | null) => Record<string, string> = (tag: string | null) => ({
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`+${v}`, tag ? `­ ⟮＋${v} ${tag}⟯` : `­ ⟮＋${v}⟯`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`${v}`, tag ? `­ ⟮＋${v} ${tag}⟯` : `­ ⟮＋${v}⟯`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`-${v}`, tag ? `­ ⟮－${v} ${tag}⟯` : `­ ⟮－${v}⟯`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  '+0': '­',
+  '0': '­',
+});
+
+export const valueMap: () => Record<string, string> = () => ({
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`+${v}`, `+${v}`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`${v}`, `+${v}`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`-${v}`, `-${v}`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  '+0': '+0',
+  '0': '+0',
+});
+
+export const diceNameMap: () => Record<string, string> = () => ({
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`(${v})`, `­ ⟮take ${v}⟯`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  '1': '­',
+  '+1': '­',
+  '-1': '­',
+  '2': '­ ⟮fortune⟯',
+  '+2': '­ ⟮fortune⟯',
+  '-2': '­ ⟮misfortune⟯',
+  'a': '­ ⟮fortune⟯',
+  'adv': '­ ⟮fortune⟯',
+  'advantage': '­ ⟮fortune⟯',
+  'd': '­ ⟮misfortune⟯',
+  'dis': '­ ⟮misfortune⟯',
+  'disadvantage': '­ ⟮misfortune⟯',
+  'f': '­ ⟮fortune⟯',
+  'for': '­ ⟮fortune⟯',
+  'fortune': '­ ⟮fortune⟯',
+  'm': '­ ⟮misfortune⟯',
+  'mis': '­ ⟮misfortune⟯',
+  'misfortune': '­ ⟮misfortune⟯',
+});
+
+export const diceMap: () => Record<string, string> = () => ({
+  ...([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].map((v): [string, string] => (
+    [`(${v})`, `(${v})`]
+  )).reduce<Record<string, string>>((p, [k, v]) => { p[k] = v; return p }, {})),
+  '1': '1',
+  '+1': '1',
+  '-1': '1',
+  '2': '+2',
+  '+2': '+2',
+  '-2': '-2',
+  'a': '+2',
+  'adv': '+2',
+  'advantage': '+2',
+  'd': '-2',
+  'dis': '-2',
+  'disadvantage': '-2',
+  'f': '+2',
+  'for': '+2',
+  'fortune': '+2',
+  'm': '-2',
+  'mis': '-2',
+  'misfortune': '-2',
+});
+
+export const adjustmentMap: () => Record<string, string> = () => ({
+  'incredibly-easy': '­ ⟮Incredibly Easy⟯',
+  'very-easy': '­ ⟮Very Easy⟯',
+  'easy': '­ ⟮Easy⟯',
+  'default': '­',
+  'hard': '­ ⟮Hard⟯',
+  'very-hard': '­ ⟮Very Easy⟯',
+  'incredibly-hard': '­ ⟮Incredibly Hard⟯',
+});
+
+export const fromatMap = (name: string, map: Record<string, string>) => {
+  return TSV.stringify([{
+    name,
+    ...map,
+  }]);
+};
+
+const dcByLevel = [13, 14, 15, 16, 18, 19, 20, 22, 23, 24, 26, 27, 28, 30, 31, 32, 34, 35, 36, 38, 39, 40, 42, 44, 46, 48, 50]
+
+export const formatJSON = (stats: Schema): string => JSON.stringify(stats, undefined, 2);
+export const parseJSON = (json: string): Schema => schema.parse(JSON.parse(json));
+
+const locateName = (statblock: string): { name: string; level: number } | null => {
+  const regex = /^([^()]+?)(\s+\(\d+\))?\s+\S+\s+(-?\d+)$/m;
+
+  const match = statblock.match(regex);
+
+  if (match && match[1] && match[3]) {
+    return { name: pluralize(startCase(toLower(match[1].replace(/\s+/, ' ').trim())), 1), level: parseInt(match[3]) };
+  }
+
+  return null;
+}
+
+const locateInt = <T extends string>(name: T, statblock: string, section: string | null = null, signed: boolean = true, alias?: string): { [k in T]: number } | null => {
+  const match = statblock.match(new RegExp(`${section ? `(${section}|,)\\s+` : '()'}${alias ?? capitalize(name)}\\s+(${signed ? '[+-]' : '-?'}\\d+)`))
+
+  if (match && match[2]) {
+    return { [name]: parseInt(match[2]) } as { [k in T]: number };
+  }
+
+  return null;
+}
+
+const locateInts = (statblock: string, section: string, alias: string, signed: boolean = true): Record<string, { mod: number; name: string; }> => {
+  const regex = new RegExp(`(${section}|,)([^,]*?)${alias}\\s+(${signed ? '[+-]' : '-?'}\\d+)`, 'g');
+
+  let matches:  RegExpExecArray | null = null;
+  const output: [string, string, number][] = [];
+  // eslint-disable-next-line no-cond-assign
+  while (matches = regex.exec(statblock)) {
+    const [,, name, mod] = matches;
+
+    if (name && mod) {
+      output.push([
+        name.toLowerCase().trim().replace(/\s+/g, '-'),
+        name.trim(),
+        parseInt(mod),
+      ]);
+    }
+  }
+
+  return output.reduce<Record<string, { mod: number; name: string; }>>((p, [key, name, value]) => { p[key] = { mod: value, name: name }; return p; }, {});
+}
+
+const locateIntsAfter = (statblock: string, alias: string, signed: boolean = true): Record<string, { mod: number; name: string; }> => {
+  const regex = new RegExp(`${alias}([\\s\\S]*?)(${signed ? '[+-]' : '-?'}\\d+)`, 'g');
+
+  let matches:  RegExpExecArray | null = null;
+  const output: [string, string, number][] = [];
+  // eslint-disable-next-line no-cond-assign
+  while (matches = regex.exec(statblock)) {
+    const [,name, mod] = matches;
+
+    if (name && mod) {
+      output.push([
+        name.toLowerCase().trim().replace(/\s+/g, '-'),
+        name.trim(),
+        parseInt(mod),
+      ]);
+    }
+  }
+
+  return output.reduce<Record<string, { mod: number; name: string; }>>((p, [key, name, value]) => { p[key] = { mod: value, name: name }; return p; }, {});
+}
+
+const locateStrikes = (statblock: string, alias: string): Record<string, Schema['melee'][string]> => {
+  const regex = new RegExp(`${alias}(\\s+\\[.+\\])?\\s+(.+?)\\s+(\\(x\\d+\\)\\s+)?([+-]\\d+)\\s*([\\S\\s]*?),\\s+(Damage|Effect)\\s+(\\S+\\s+\\S+.*?)(?=$|\\s+Melee|\\s+Ranged)`, 'gm');
+
+  let matches:  RegExpExecArray | null = null;
+  const output: [string, number, string, string][] = [];
+  // eslint-disable-next-line no-cond-assign
+  while (matches = regex.exec(statblock)) {
+    const [, , name, , attack, traits, , dice] = matches;
+
+    if (name && attack && dice) {
+      const _name = name.toLowerCase()
+        .replace(/\s+/g, ' ')
+        .replace(/\+\d/g, '')
+        .replace(/Weapon\s+Striking(\s+\((Greater|Major)\))?/gi, '')
+        .replace(/\(Agile\)/gi, '')
+        .replace(/\(\+\)/gi, '')
+        .trim();
+
+      const bps = /(?<=[^\w']|^)[BbPpSs](?=[^\w]|$)/g;
+
+      let _traits = traits && traits.toLowerCase()
+        .replace(/\s+/g, ' ')
+        .replace(bps, (m) => m.toUpperCase())
+        .replace(/1d/, 'd')
+        .trim();
+
+      const _dice = dice
+        .replace(/\s+/g, ' ')
+        .replace(bps, (m) => ({ b: 'bludgeoning', p: 'piercing', s: 'slashing' }[m.toLowerCase()] ?? m))
+        .trim();
+
+      const twoHand = _traits.match(/(two-hand|two-handed)\s+(d\d+)/);
+
+      if (twoHand && twoHand[2]) {
+        _traits = _traits.replace(/(two-hand|two-handed)\s+d\d+/g, 'two-hand');
+
+        const dice2h = _dice.replace(/(?<=\d)d\d+/, twoHand[2]);
+
+        output.push([
+          _name.replace(/\s+/g, '-') + '-2h',
+          parseInt(attack),
+          `2h ${_traits ? `${_name} ${_traits}` : _name}`,
+          dice2h,
+        ], [
+          _name.replace(/\s+/g, '-') + '-1h',
+          parseInt(attack),
+          `1h ${_traits ? `${_name} ${_traits}` : _name}`,
+          _dice,
+        ]);
+      } else {
+        output.push([
+          _name.replace(/\s+/g, '-'),
+          parseInt(attack),
+          _traits ? `${_name} ${_traits}` : _name,
+          _dice,
+        ]);
+      }
+    }
+  }
+
+  return output.reduce<Record<string, Schema['melee'][string]>>((p, [key, m, t, d]) => { p[key] = {
+    mod: m,
+    desc: t,
+    damage: d,
+  }; return p; }, {});
+}
+
+const locateSpells = (statblock: string): Schema['spells'] | null => {
+  const match = statblock.match(new RegExp(/Spells\s+DC\s+(\d+)(,\s+[Aa]ttack\s+([+-]\d+))?/));
+
+  if (match && match[1]) {
+    return {
+      dc: parseInt(match[1]),
+      ...(match[3] ? { attack: parseInt(match[3]) } : null)
+    };
+  }
+
+  return null;
+}
+
+export const parseStatblock = (name: string | null, _statblock: string, alias: string | null): Schema => {
+  const defaults = schema.parse({ name: name ?? 'Unknown' });
+
+  const statblock = _statblock
+    .replace(/^Items.*$/m, '')
+    .replace(/–/g, '-') + '\n';
+
+  const improvisation = !!statblock.match(/Untrained\s+Improvisation/);
+
+  const basic = locateName(statblock);
+
+  return {
+    ...defaults,
+    ...basic,
+    ...(name && { name: name }),
+    ...{ alias: alias ?? abbreviate(name ?? basic?.name ?? defaults.name, { length: 3 }).toLowerCase() },
+    ...locateInt('perception', statblock),
+    ...locateInt('ac', statblock, null, false, 'AC'),
+    ...locateInt('maxhp', statblock, null, false, 'HP'),
+    attributes: {
+      ...defaults.attributes,
+      ...locateInt('strength', statblock, null, true, 'Str'),
+      ...locateInt('dexterity', statblock, null, true, 'Dex'),
+      ...locateInt('constitution', statblock, null, true, 'Con'),
+      ...locateInt('intelligence', statblock, null, true, 'Int'),
+      ...locateInt('wisdom', statblock, null, true, 'Wis'),
+      ...locateInt('charisma', statblock, null, true, 'Cha'),
+    },
+    saves: {
+      ...defaults.saves,
+      ...locateInt('fortitude', statblock, null, true, 'Fortitude'),
+      ...locateInt('reflex', statblock, null, true, 'Reflex'),
+      ...locateInt('fortitude', statblock, null, true, 'Fort'),
+      ...locateInt('reflex', statblock, null, true, 'Ref'),
+      ...locateInt('will', statblock, null, true, 'Will'),
+    },
+    skills: {
+      ...defaults.skills,
+      ...locateInt('acrobatics', statblock, 'Skills'),
+      ...locateInt('arcana', statblock, 'Skills'),
+      ...locateInt('athletics', statblock, 'Skills'),
+      ...locateInt('crafting', statblock, 'Skills'),
+      ...locateInt('deception', statblock, 'Skills'),
+      ...locateInt('diplomacy', statblock, 'Skills'),
+      ...locateInt('intimidation', statblock, 'Skills'),
+      ...locateInt('medicine', statblock, 'Skills'),
+      ...locateInt('nature', statblock, 'Skills'),
+      ...locateInt('occultism', statblock, 'Skills'),
+      ...locateInt('perfomance', statblock, 'Skills'),
+      ...locateInt('religion', statblock, 'Skills'),
+      ...locateInt('society', statblock, 'Skills'),
+      ...locateInt('stealth', statblock, 'Skills'),
+      ...locateInt('survival', statblock, 'Skills'),
+      ...locateInt('thievery', statblock, 'Skills'),
+    },
+    lores: {
+      ...locateInts(statblock, 'Skills', 'Lore'),
+      ...locateIntsAfter(statblock, 'Lore:')
+    },
+    melee: {
+      ...locateStrikes(statblock, 'Melee'),
+    },
+    ranged: {
+      ...locateStrikes(statblock, 'Ranged'),
+    },
+    spells: {
+      ...locateSpells(statblock),
+    },
+    extra: {},
+    extraDCs: {
+      ...locateInt('stealth', statblock, null, false, 'Stealth DC'),
+    },
+    extraDice: {},
+    improvisation,
+  };
+}
+
+const dc2DC = (secret: boolean) => ([key, value]: [string | number, number]): [string, string] => [`dc.${key}`, secret ? `||${value}||` : `${value}`];
+const mod2DC = (secret: boolean) => ([key, value]: [string | number, number]): [string, string] => [`dc.${key}`, secret ? `||${10 + value}||` : `${10 + value}`];
+const toLore = ([key, value]: [string | number, { mod: number; name: string; }]): [string, number| string][] => [[`lore.${key}`, value.mod], [`lore.${key}.name`, value.name]];
+const toMelee = ([key, value]: [string, Schema['melee'][string]]): [string, number | string][] => [
+  [`melee.${key}`, value.mod],
+  [`melee.${key}.desc`, value.desc],
+  [`melee.${key}.damage`, value.damage],
+];
+
+const toRanged = ([key, value]: [string, Schema['ranged'][string]]): [string, number | string][] => [
+  [`ranged.${key}`, value.mod],
+  [`ranged.${key}.desc`, value.desc],
+  [`ranged.${key}.damage`, value.damage],
+];
+
+const recallDCs = (level: number, secret: boolean): [string, string][] => ((value) => [
+  ['dc.recall.incredibly-easy', secret ? `||${value - 10}||` : `${value - 10}`],
+  ['dc.recall.very-easy', secret ? `||${value - 5}||` : `${value - 5}`],
+  ['dc.recall.easy', secret ? `||${value - 2}||` : `${value - 2}`],
+  ['dc.recall.default', secret ? `||${value}||` : `${value}`],
+  ['dc.recall', secret ? `||${value}||` : `${value}`],
+  ['dc.recall.hard', secret ? `||${value + 2}||` : `${value + 2}`],
+  ['dc.recall.very-hard', secret ? `||${value + 5}||` : `${value + 5}`],
+  ['dc.recall.incredibly-hard', secret ? `||${value + 10}||` : `${value + 10}`],
+])(dcByLevel[Math.max(Math.min(level + 1, dcByLevel.length - 1), 0)]);
+
+export const flatten = (stats: Schema, secretDC: boolean = false, defaultSkills: boolean = false, recallDC: boolean = false, desc: boolean): Record<string, string | number> => {
+  const untrained = stats.improvisation ? (stats.level >= 7 ? stats.level : stats.level >= 5 ? stats.level - 1 : stats.level - 2) : 0;
+  const skills = defaultSkills ? {
+    acrobatics: untrained + stats.attributes.dexterity,
+    arcana: untrained + stats.attributes.intelligence,
+    athletics: untrained + stats.attributes.strength,
+    crafting: untrained + stats.attributes.intelligence,
+    deception: untrained + stats.attributes.charisma,
+    diplomacy: untrained + stats.attributes.charisma,
+    intimidation: untrained + stats.attributes.charisma,
+    medicine: untrained + stats.attributes.wisdom,
+    nature: untrained + stats.attributes.wisdom,
+    occultism: untrained + stats.attributes.intelligence,
+    perfomance: untrained + stats.attributes.charisma,
+    religion: untrained + stats.attributes.wisdom,
+    society: untrained + stats.attributes.intelligence,
+    stealth: untrained + stats.attributes.dexterity,
+    survival: untrained + stats.attributes.wisdom,
+    thievery: untrained + stats.attributes.dexterity,
+    ...stats.skills,
+  } : stats.skills;
+
+  let melee = entries(stats.melee);
+  if (melee.length > 0) {
+    melee = [
+      ['default', melee[0][1]],
+      ...melee,
+    ];
+  }
+
+  let ranged = entries(stats.ranged);
+  if (ranged.length > 0) {
+    ranged = [
+      ['default', ranged[0][1]],
+      ...ranged,
+    ];
+  }
+
+  return [
+    ['name', stats.name],
+    ...(stats.alias ? [['alias', stats.alias]] : []),
+    ['gamesystem', 'pf2e'],
+    ['level', stats.level],
+    ['lvl', stats.level],
+    ['maxhp', stats.maxhp],
+    ...entries(stats.attributes),
+    ...entries(stats.attributes).map(([key, value]) => [key.substring(0,3), value]),
+    ['ac', secretDC ? `||${stats.ac}||` : stats.ac],
+    ...entries(stats.saves),
+    ['fort', stats.saves.fortitude],
+    ['ref', stats.saves.reflex],
+    ['perception', stats.perception],
+    ...entries(skills),
+    ...entries(stats.lores).flatMap(toLore),
+    ...(desc ? [
+      ...entries(stats.saves).map(([key]) => [`${key}.desc`, `${capitalize(key)} Save`]),
+      ['fort.desc', 'Fortitude Save'],
+      ['ref.desc', 'Reflex Save'],
+      ['perception.desc', 'Perception Check'],
+      ...entries(skills).map(([key]) => [`${key}.desc`, `${capitalize(key)} Check`]),
+      ...entries(stats.lores).map(([key, value]) => [`lore.${key}.desc`, `${value.name} Lore Check`]),
+      ...(stats.spells.attack ? [['spells.desc', 'Spell Attack']] : []),
+    ]: []),
+    ...melee.flatMap(toMelee),
+    ...ranged.flatMap(toRanged),
+    ...entries(stats.extra),
+    ...(stats.spells.attack ? [['spells', stats.spells.attack]] : []),
+    ...(stats.spells.dc ? [dc2DC(secretDC)(['spells', stats.spells.dc])] : []),
+    ...entries(stats.extraDCs).map(dc2DC(secretDC)),
+    ...entries(stats.extraDice),
+    ...(secretDC ? [
+      ...entries(stats.saves).map(mod2DC(true)),
+      mod2DC(true)(['perception', stats.perception]),
+      mod2DC(true)(['fort', stats.saves.fortitude]),
+      mod2DC(true)(['ref', stats.saves.reflex]),
+      ...entries(skills).map(mod2DC(true)),
+      ...entries(stats.extra).map(mod2DC(true)),
+    ] : []),
+    ...(recallDC ? [
+      ...recallDCs(stats.level, secretDC),
+    ] : []),
+  ].reduce<Record<string | number, string | number>>((p, [key, value]) => { p[key] = value; return p }, {});
+}
+
+export const formatTSV = (stats: Schema, secretDC: boolean = false, defaultSkills: boolean = false, recallDC: boolean = false, desc: boolean = false): string => (
+  TSV.stringify([flatten(stats, secretDC, defaultSkills, recallDC, desc)])
+);
+
+export const formatCommand = (stats: Schema, secretDC: boolean = false, defaultSkills: boolean = false, recallDC: boolean = false, desc: boolean = false): string => (
+  Object.entries(flatten(stats, secretDC, defaultSkills, recallDC, desc)).map(([k, v]) => `${k}="${v}"`).join(' ')
+);
+
+export const formatTable = (table: number, season: number, scenario: number, _name: string, gm: string, players: string) => {
+  const name = _name.replace(/[\s-_]/g, ' ').replace(/[^a-zA-Z0-9 ]/g, '');
+
+  const gameName = `PF2 T${table} S${season} ${String(scenario).padStart(2, '0')} ${name}`;
+  const tableName = `pf2-t${table}-s${season}${String(scenario).padStart(2, '0')}-${kebabCase(name)}`;
+
+  return dedent`
+    \`\`\`
+    @TableBot create "${gameName}" --gm ${gm} --players ${players} --table-name ${tableName} --ooc-table-name ooc-${tableName} --category Game Tables
+    \`\`\`
+    \`\`\`
+    sage! game create name="${gameName}" gameSystem="pf2e" ic=" #${tableName} " ooc=" #ooc-${tableName} " gms=" ${gm} " players=" @${gameName} " dialogPost="post" diceSecret="gm" diceCrit="timestwo" diceOutput=M gmCharName="Хронист" diceSecret="gm"
+    \`\`\`
+  `;
+};
+
+const _formatHP = (hp: number, maxhp: number) => {
+  const base32 = Math.ceil(hp * 32 / maxhp);
+
+  const slabs = Math.floor(base32 / 8);
+  const tail = base32 % 8;
+
+  const tails = [' ', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
+
+  return `▕${new Array(slabs).fill(0).map(() => '█').join('')}${[tails[tail], ...new Array(3).fill(0).map(() => ' ')].slice(0, 4 - slabs).join('')}▏`;
+}
+
+export const formatHP = (arg: string) => {
+  const match = arg.match(/^(m)?(\d+)\/(\d+)$/);
+
+  if (!match) {
+    throw new Error('No match');
+  }
+
+  const negative = !!match[1];
+  const hp = parseInt(match[2]);
+  const maxhp = parseInt(match[3]);
+
+  return _formatHP(negative ? maxhp - hp : hp, maxhp);
+};