pf2e-sage-stats 0.1.1 → 0.2.1

package/src/app.ts

@@ -1,9 +1,10 @@
 import zod from 'zod';
 import { TSV } from 'tsv';
-import { capitalize, entries, startCase, toLower, kebabCase } from 'lodash';
+import { capitalize, entries, startCase, toLower, kebabCase, keys, difference, groupBy, mapValues } from 'lodash';
 import dedent from 'dedent-js';
 import abbreviate from 'abbreviate';
 import pluralize from 'pluralize';
+import { readdir, rename, stat } from 'fs/promises';
 
 const schema = zod.object({
   name: zod.string(),
@@ -25,6 +26,8 @@ const schema = zod.object({
   }).default({}),
   ac: zod.coerce.number().default(10),
   perception: zod.coerce.number().default(0),
+  perceptionInfo: zod.array(zod.string()).default([]),
+  initiativeInfo: zod.array(zod.string()).default([]),
   skills: zod.object({
     acrobatics: zod.coerce.number().optional(),
     arcana: zod.coerce.number().optional(),
@@ -36,7 +39,7 @@ const schema = zod.object({
     medicine: zod.coerce.number().optional(),
     nature: zod.coerce.number().optional(),
     occultism: zod.coerce.number().optional(),
-    perfomance: zod.coerce.number().optional(),
+    performance: zod.coerce.number().optional(),
     religion: zod.coerce.number().optional(),
     society: zod.coerce.number().optional(),
     stealth: zod.coerce.number().optional(),
@@ -50,12 +53,12 @@ const schema = zod.object({
   melee: zod.record(zod.string(), zod.object({
     mod: zod.coerce.number().default(0),
     desc: zod.string(),
-    damage: zod.string(),
+    damage: zod.string().optional(),
   })).default({}),
   ranged: zod.record(zod.string(), zod.object({
     mod: zod.coerce.number().default(0),
     desc: zod.string(),
-    damage: zod.string(),
+    damage: zod.string().optional(),
   })).default({}),
   spells: zod.object({
     attack: zod.coerce.number().optional(),
@@ -64,7 +67,42 @@ const schema = zod.object({
   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),
+  classDC: zod.coerce.number().default(10),
+  untrained: zod.coerce.number().default(0),
+  bump: zod.object({
+    default: zod.coerce.number().default(0),
+    attack: zod.coerce.number().optional(),
+    ac: zod.coerce.number().optional(),
+    saves: zod.coerce.number().optional(),
+    skills: zod.coerce.number().optional(),
+    spells: zod.coerce.number().optional(),
+    perception: zod.coerce.number().optional(),
+    hp: zod.coerce.number().optional(),
+  }).default({ default: 0 }),
+  bullwark: zod.coerce.number().default(0),
+  saveInfo: zod.object({
+    fortitude: zod.array(zod.string()).default([]),
+    reflex: zod.array(zod.string()).default([]),
+    will: zod.array(zod.string()).default([]),
+  }).default({}),
+  skillInfo: zod.object({
+    acrobatics: zod.array(zod.string()).optional(),
+    arcana: zod.array(zod.string()).optional(),
+    athletics: zod.array(zod.string()).optional(),
+    crafting: zod.array(zod.string()).optional(),
+    deception: zod.array(zod.string()).optional(),
+    diplomacy: zod.array(zod.string()).optional(),
+    intimidation: zod.array(zod.string()).optional(),
+    medicine: zod.array(zod.string()).optional(),
+    nature: zod.array(zod.string()).optional(),
+    occultism: zod.array(zod.string()).optional(),
+    performance: zod.array(zod.string()).optional(),
+    religion: zod.array(zod.string()).optional(),
+    society: zod.array(zod.string()).optional(),
+    stealth: zod.array(zod.string()).optional(),
+    survival: zod.array(zod.string()).optional(),
+    thievery: zod.array(zod.string()).optional(),
+  }).default({}),
 })
 
 export type Schema = zod.infer<typeof schema>;
@@ -89,6 +127,8 @@ export const stub: Required<Schema> = {
   },
   ac: 10,
   perception: 0,
+  perceptionInfo: [],
+  initiativeInfo: [],
   skills: {
     acrobatics: 0,
     arcana: 0,
@@ -100,7 +140,7 @@ export const stub: Required<Schema> = {
     medicine: 0,
     nature: 0,
     occultism: 0,
-    perfomance: 0,
+    performance: 0,
     religion: 0,
     society: 0,
     stealth: 0,
@@ -116,17 +156,16 @@ export const stub: Required<Schema> = {
   extra: {},
   extraDCs: {},
   extraDice: {},
-  improvisation: false,
-};
-
-const formatMap: Record<string, string> = {
-  xxs: 'xxs',
-  xs: 'xs',
-  s: 's',
-  m: 'm',
-  l: 'l',
-  xl: 'xl',
-  xxl: 'xxl',
+  classDC: 10,
+  untrained: 0,
+  bump: { default: 0 },
+  bullwark: 0,
+  saveInfo: {
+    fortitude: [],
+    reflex: [],
+    will: [],
+  },
+  skillInfo: {},
 };
 
 export const prediceateMap: Record<string, string> = {
@@ -137,97 +176,15 @@ export const prediceateMap: Record<string, string> = {
   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⟯',
+  'incredibly-easy': '`(Incredibly Easy)`',
+  'very-easy': '`(Very Easy)`',
+  'easy': '`(Easy)`',
+  'hard': '`(Hard)`',
+  'very-hard': '`(Very Easy)`',
+  'incredibly-hard': '`(Incredibly Hard)`',
 });
 
 export const fromatMap = (name: string, map: Record<string, string>) => {
@@ -317,16 +274,20 @@ const locateStrikes = (statblock: string, alias: string): Record<string, Schema[
 
     if (name && attack && dice) {
       const _name = name.toLowerCase()
-        .replace(/\s+/g, ' ')
         .replace(/\+\d/g, '')
         .replace(/Weapon\s+Striking(\s+\((Greater|Major)\))?/gi, '')
+        .replace(/((Greater|Major)\s+)?Striking/gi, '')
         .replace(/\(Agile\)/gi, '')
+        .replace(/\(Finesse\)/gi, '')
         .replace(/\(\+\)/gi, '')
+        .replace(/\(\)/gi, '')
+        .replace(/\s+/g, ' ')
         .trim();
 
       const bps = /(?<=[^\w']|^)[BbPpSs](?=[^\w]|$)/g;
 
       let _traits = traits && traits.toLowerCase()
+        .replace(/\(\)/gi, '')
         .replace(/\s+/g, ' ')
         .replace(bps, (m) => m.toUpperCase())
         .replace(/1d/, 'd')
@@ -335,6 +296,9 @@ const locateStrikes = (statblock: string, alias: string): Record<string, Schema[
       const _dice = dice
         .replace(/\s+/g, ' ')
         .replace(bps, (m) => ({ b: 'bludgeoning', p: 'piercing', s: 'slashing' }[m.toLowerCase()] ?? m))
+        .replace(/Fire/, 'fire')
+        .replace(/Cold/, 'cold')
+        .replace(/Electricity/, 'electricity')
         .trim();
 
       const twoHand = _traits.match(/(two-hand|two-handed)\s+(d\d+)/);
@@ -389,15 +353,17 @@ const locateSpells = (statblock: string): Schema['spells'] | null => {
 export const parseStatblock = (name: string | null, _statblock: string, alias: string | null): Schema => {
   const defaults = schema.parse({ name: name ?? 'Unknown' });
 
+  const improvisation = _statblock.match(/Untrained\s+Improvisation/);
+  const plate = _statblock.match(/Full\s+Plate/)
+
   const statblock = _statblock
     .replace(/^Items.*$/m, '')
+    .replace('', '')
     .replace(/–/g, '-') + '\n';
 
-  const improvisation = !!statblock.match(/Untrained\s+Improvisation/);
-
   const basic = locateName(statblock);
 
-  return {
+  const result: Schema = {
     ...defaults,
     ...basic,
     ...(name && { name: name }),
@@ -434,7 +400,7 @@ export const parseStatblock = (name: string | null, _statblock: string, alias: s
       ...locateInt('medicine', statblock, 'Skills'),
       ...locateInt('nature', statblock, 'Skills'),
       ...locateInt('occultism', statblock, 'Skills'),
-      ...locateInt('perfomance', statblock, 'Skills'),
+      ...locateInt('performance', statblock, 'Skills'),
       ...locateInt('religion', statblock, 'Skills'),
       ...locateInt('society', statblock, 'Skills'),
       ...locateInt('stealth', statblock, 'Skills'),
@@ -459,26 +425,31 @@ export const parseStatblock = (name: string | null, _statblock: string, alias: s
       ...locateInt('stealth', statblock, null, false, 'Stealth DC'),
     },
     extraDice: {},
-    improvisation,
   };
+
+  result.untrained = improvisation ? (result.level >= 7 ? result.level : result.level >= 5 ? result.level - 1 : result.level - 2) : 0;
+  result.bullwark = plate ? Math.max(3 - result.attributes.dexterity, 0) : 0;
+ 
+  return result;
 }
 
-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 dc2DC = (secret: boolean, bump: number) => ([key, value]: [string | number, number]): [string, string] => [`dc.${key}`, secret ? `||${value + bump}||` : `${value + bump}`];
+const mod2DC = (secret: boolean, bump: number) => ([key, value]: [string | number, number]): [string, string] => [`dc.${key}`, secret ? `||${10 + value + bump}||` : `${10 + value + bump}`];
+const toLoreMod = ([key, value]: [string | number, { mod: number; name: string; }]): [string, number] => [`lore.${key}`, value.mod];
+const toLoreName = ([key, value]: [string | number, { mod: number; name: string; }]): [string, string] => [`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],
+  ...(value.damage ? [[`melee.${key}.damage`, value.damage] as [string, string]] : []),
 ];
 
 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],
+  ...(value.damage ? [[`ranged.${key}.damage`, value.damage] as [string, string]] : []),
 ];
 
-const recallDCs = (level: number, secret: boolean): [string, string][] => ((value) => [
+const recallDCs = (level: number, secret: boolean, bump: number): [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}`],
@@ -487,10 +458,10 @@ const recallDCs = (level: number, secret: boolean): [string, string][] => ((valu
   ['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)]);
+])(dcByLevel[Math.max(Math.min(level + 1, dcByLevel.length - 1), 0)] + bump);
 
-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;
+export const flatten = (stats: Schema, secretDC: boolean = false, defaultSkills: boolean = false, recallDC: boolean = false): Record<string, string | number> => {
+  const untrained = stats.untrained;
   const skills = defaultSkills ? {
     acrobatics: untrained + stats.attributes.dexterity,
     arcana: untrained + stats.attributes.intelligence,
@@ -502,7 +473,7 @@ export const flatten = (stats: Schema, secretDC: boolean = false, defaultSkills:
     medicine: untrained + stats.attributes.wisdom,
     nature: untrained + stats.attributes.wisdom,
     occultism: untrained + stats.attributes.intelligence,
-    perfomance: untrained + stats.attributes.charisma,
+    performance: untrained + stats.attributes.charisma,
     religion: untrained + stats.attributes.wisdom,
     society: untrained + stats.attributes.intelligence,
     stealth: untrained + stats.attributes.dexterity,
@@ -511,7 +482,11 @@ export const flatten = (stats: Schema, secretDC: boolean = false, defaultSkills:
     ...stats.skills,
   } : stats.skills;
 
-  let melee = entries(stats.melee);
+  let melee = entries(stats.melee).map(([k, v]): [string, typeof v] => [k, {
+    mod: v.mod + (stats.bump.attack ?? stats.bump.default),
+    desc: v.desc,
+    damage: stats.bump.default > 0 ? `${v.damage} +${stats.bump.default}` : v.damage,
+  }]);
   if (melee.length > 0) {
     melee = [
       ['default', melee[0][1]],
@@ -519,7 +494,11 @@ export const flatten = (stats: Schema, secretDC: boolean = false, defaultSkills:
     ];
   }
 
-  let ranged = entries(stats.ranged);
+  let ranged = entries(stats.ranged).map(([k, v]): [string, typeof v] => [k, {
+    mod: v.mod + (stats.bump.attack ?? stats.bump.default),
+    desc: v.desc,
+    damage: v.damage && stats.bump.default > 0 ? `${v.damage} +${stats.bump.default}` : v.damage,
+  }]);
   if (ranged.length > 0) {
     ranged = [
       ['default', ranged[0][1]],
@@ -527,61 +506,79 @@ export const flatten = (stats: Schema, secretDC: boolean = false, defaultSkills:
     ];
   }
 
+  const maxhp = stats.bump.default > 0 ? (stats.bump.hp ? (stats.bump.hp + stats.maxhp) : Math.max(Math.floor(stats.maxhp * 1.1), stats.maxhp + 10)) : stats.maxhp;
+
+  const saveInfo = {
+    ...stats.saveInfo,
+    reflex: stats.bullwark > 0 ? [...stats.saveInfo.reflex, `+${stats.bullwark} more vs damage`] : stats.saveInfo.reflex,
+  }
+
+  const untrainedSkillInfo = entries(mapValues(groupBy(difference(keys(skills), keys(stats.skills)), (k) => k), () => ['untrained']));
+  const specifiedSkillInfo = entries(stats.skillInfo);
+
+  const skillInfo = mapValues(groupBy([...untrainedSkillInfo, ...specifiedSkillInfo], ([k]) => k), (list) => list.reduce<string[]>((p, [, v]) => [...p, ...v], []))
+
   return [
     ['name', stats.name],
     ...(stats.alias ? [['alias', stats.alias]] : []),
     ['gamesystem', 'pf2e'],
     ['level', stats.level],
     ['lvl', stats.level],
-    ['maxhp', stats.maxhp],
+    ['hp', maxhp],
+    ['maxhp', 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']] : []),
-    ]: []),
+    ['ac', secretDC ? `||${stats.ac + (stats.bump.ac ?? stats.bump.default)}||` : stats.ac + (stats.bump.ac ?? stats.bump.default)],
+    ...entries(stats.saves).map(([k, v]) => [k, v + (stats.bump.saves ?? stats.bump.default)]),
+    ['fort', stats.saves.fortitude + (stats.bump.saves ?? stats.bump.default)],
+    ['ref', stats.saves.reflex + (stats.bump.saves ?? stats.bump.default)],
+    ['perception', stats.perception + (stats.bump.perception ?? stats.bump.default)],
+    ...entries(skills.performance ? { ...skills, perfomance: skills.performance } : skills).map(([k, v]) => [k, v + (stats.bump.skills ?? stats.bump.default)]),
+    ...entries(stats.lores).map(toLoreMod).map(([k, v]) => [k, v + (stats.bump.skills ?? stats.bump.default)]),
+    ...entries(stats.lores).map(toLoreName),
     ...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)),
+    ...(stats.spells.attack ? [['spells', stats.spells.attack + (stats.bump.attack ?? stats.bump.default)]] : []),
+    ...(stats.spells.dc ? [dc2DC(secretDC, stats.bump.spells ?? stats.bump.default)(['spells', stats.spells.dc])] : []),
+    ...(stats.classDC ? [['classDC', secretDC ? `||${stats.classDC + stats.bump.default}||` : `${stats.classDC + stats.bump.default}`]] : []),
+    ...(stats.classDC ? [dc2DC(secretDC, stats.bump.default)(['class', stats.classDC])] : []),
+    dc2DC(secretDC, stats.bump.default)(['level', dcByLevel[Math.max(Math.min(stats.level + 1, dcByLevel.length - 1), 0)]]),
+    dc2DC(secretDC, stats.bump.ac ?? stats.bump.default)(['ac', stats.ac]),
+    ...entries(stats.extraDCs).map(dc2DC(secretDC, stats.bump.default)),
     ...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)),
+      ...entries(stats.saves).map(mod2DC(true, (stats.bump.saves ?? stats.bump.default))),
+      mod2DC(true, stats.bump.default)(['perception', stats.perception]),
+      mod2DC(true, (stats.bump.saves ?? stats.bump.default))(['fort', stats.saves.fortitude]),
+      mod2DC(true, (stats.bump.saves ?? stats.bump.default))(['ref', stats.saves.reflex]),
+      ...entries(skills).map(mod2DC(true, (stats.bump.skills ?? stats.bump.default))),
+      ...entries(stats.extra).map(mod2DC(true, stats.bump.default)),
     ] : []),
     ...(recallDC ? [
-      ...recallDCs(stats.level, secretDC),
+      ...recallDCs(stats.level, secretDC, stats.bump.default),
+    ] : []),
+    ...(stats.perceptionInfo.length > 0 ? [
+      [`perception.info`, `\`(${stats.perceptionInfo.join(', ')})\``]
     ] : []),
+    ...(stats.initiativeInfo.length > 0 ? [
+      [`initiative.info`, `\`(${stats.initiativeInfo.join(', ')})\``]
+    ] : []),
+    ...entries(saveInfo).filter(([, v]) => v.length > 0).map(([k, v]) => [`${k}.info`, `\`(${v.join(', ')})\``]),
+    ...entries(skillInfo).filter(([, v]) => v.length > 0).map(([k, v]) => [`${k}.info`, `\`(${v.join(', ')})\``]),
+    ['out', secretDC ? 'xs' : 'm'],
   ].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 formatTSV = (stats: Schema, secretDC: boolean = false, defaultSkills: boolean = false, recallDC: boolean = false): string => (
+  TSV.stringify([flatten(stats, secretDC, defaultSkills, recallDC)])
 );
 
-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 formatCommand = (stats: Schema, secretDC: boolean = false, defaultSkills: boolean = false, recallDC: boolean = false): string => (
+  Object.entries(flatten(stats, secretDC, defaultSkills, recallDC)).map(([k, v]) => `${k}="${v}"`).join(' ')
 );
 
-export const formatTable = (table: number, season: number, scenario: number, _name: string, gm: string, players: string) => {
+export const formatTable = (table: string, season: string, scenario: string, _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}`;
@@ -621,3 +618,27 @@ export const formatHP = (arg: string) => {
 
   return _formatHP(negative ? maxhp - hp : hp, maxhp);
 };
+
+export const sortFolder = async () => {
+  const dir = await readdir('.');
+
+  const summary = await Promise.all(dir.map(async (file) => {
+    const stats = await stat(file);
+
+    const timestamp = parseInt(stats.birthtimeMs.toFixed(0));
+
+    return { file, timestamp };
+  }))
+
+  const transformed = summary.sort((a, b) => a.timestamp - b.timestamp).map((s, index) => {
+    const prefix = String(index + 1).padStart(3, '0');
+
+    const name = s.file.replace('RU PFS Online - ', '').replace(/\s\[.+\]/, '');
+
+    return { oldname: s.file, newname: name.startsWith('ooc') ? name : `${prefix} ${name}` };
+  })
+
+  await Promise.all(transformed.map(async (t) => rename(t.oldname, t.newname)));
+
+  return transformed;
+};