pf2e-sage-stats 0.2.4 → 0.2.6

package/src/index.ts

@@ -4,10 +4,11 @@ import { Command } from 'commander';
 import fs from 'fs/promises';
 import path from 'path';
 import readline from 'readline';
+import clipboardy from 'clipboardy';
 
 import pack from '../package.json';
 
-import { sortFolder, formatCommand, formatJSON, formatTSV, fromatMap, parseJSON, parseStatblock, stub, adjustmentMap, prediceateMap, formatTable, formatHP, newtracker, parseTracker, formatTracker } from './app';
+import { sortFolder, formatCommand, formatJSON, formatTSV, fromatMap, parseJSON, parseStatblock, stub, flatMap, formatTable, formatHP, newtracker, parseTracker, formatTracker, screenPlay, diceMap } from './app';
 
 const program = new Command(pack.name);
 
@@ -57,27 +58,41 @@ program.command('sort')
     console.log(await sortFolder());
   });
 
+program.command('convert')
+  .description('Convert a discord export file into a txt log')
+  .argument('<file>', 'input file')
+  .option('-o, --output <file>', 'output file')
+  .action(async (argument, option) => {
+    const file = await fs.readFile(argument, { encoding: 'utf-8' });
+
+    if (option.output) {
+      await fs.writeFile(option.output, screenPlay(file), { encoding: 'utf-8' })
+    } else {
+      console.log(screenPlay(file));
+    }
+  });
+
 program.command('flat')
   .description('Generte a special flat npc tsv')
   .option('-n, --name <string>', 'npc name')
   .option('-o, --output <file>', 'output json')
   .action(async (option) => {
     if (option.output) {
-      await fs.writeFile(option.output, fromatMap(option.name ?? 'flat', prediceateMap), { encoding: 'utf-8' })
+      await fs.writeFile(option.output, fromatMap(option.name ?? 'flat', flatMap), { encoding: 'utf-8' })
     } else {
-      console.log(fromatMap(option.name ?? 'flat', prediceateMap));
+      console.log(fromatMap(option.name ?? 'flat', flatMap));
     }
   });
 
-program.command('adjustment')
-  .description('Generte a special adjustment npc tsv')
+program.command('dice')
+  .description('Generte a special dice npc tsv')
   .option('-n, --name <string>', 'npc name')
   .option('-o, --output <file>', 'output json')
   .action(async (option) => {
     if (option.output) {
-      await fs.writeFile(option.output, fromatMap(option.name ?? 'adjustment', adjustmentMap()), { encoding: 'utf-8' })
+      await fs.writeFile(option.output, fromatMap(option.name ?? 'dice', diceMap), { encoding: 'utf-8' })
     } else {
-      console.log(fromatMap(option.name ?? 'adjustment', adjustmentMap()));
+      console.log(fromatMap(option.name ?? 'dice', diceMap));
     }
   });
 
@@ -119,7 +134,6 @@ program.command('tsv')
   .argument('<file>', 'input json')
   .option('-o, --output <file>', 'output tsv')
   .option('-s, --secretDC', 'produce secret DCs')
-  .option('-r, --recallDC', 'produce recall DCs')
   .option('-d, --defaultSkills', 'produce values for untrained skills')
   .action(async (argument, option) => {
     const file = await fs.readFile(argument, { encoding: 'utf-8' });
@@ -128,7 +142,7 @@ program.command('tsv')
 
     const output = option.output ? option.output : path.join(path.parse(argument).dir, path.parse(argument).name + '.tsv');
 
-    await fs.writeFile(output, formatTSV(stats, option.secretDC, option.defaultSkills, option.recallDC), { encoding: 'utf-8' });
+    await fs.writeFile(output, formatTSV(stats, option.secretDC, option.defaultSkills), { encoding: 'utf-8' });
   });
 
 program.command('command')
@@ -136,7 +150,6 @@ program.command('command')
   .argument('<file>', 'input json')
   .option('-o, --output <file>', 'output txt')
   .option('-s, --secretDC', 'produce secret DCs')
-  .option('-r, --recallDC', 'produce recall DCs')
   .option('-d, --defaultSkills', 'produce values for untrained skills')
   .action(async (argument, option) => {
     const file = await fs.readFile(argument, { encoding: 'utf-8' });
@@ -145,7 +158,7 @@ program.command('command')
 
     const output = option.output ? option.output : path.join(path.parse(argument).dir, path.parse(argument).name + '-command.txt');
 
-    await fs.writeFile(output, formatCommand(stats, option.secretDC, option.defaultSkills, option.recallDC), { encoding: 'utf-8' });
+    await fs.writeFile(output, formatCommand(stats, option.secretDC, option.defaultSkills), { encoding: 'utf-8' });
   });
 
 program.command('newtracker')
@@ -193,7 +206,10 @@ program.command('track')
         await fs.writeFile(option.output, formatTracker(tracker), { encoding: 'utf-8' })
       } else {
         console.clear();
-        console.log(formatTracker(tracker));
+
+        const track = formatTracker(tracker);
+        clipboardy.writeSync(track)
+        console.log(track);
       }
     }
 
@@ -214,66 +230,337 @@ program.command('track')
         while (true) {
           await new Promise((resolve) => setTimeout(resolve, 500));
 
-          const input = await new Promise<string>((resolve) => (
+          let input = await new Promise<string>((resolve) => (
             rl.question('> ', resolve)
           ));
 
-          const hpmod = input.match(/([^\d\s+-]+)\s*([+-]?\d+)/);
+          const commands = [{
+            regex: /^\s*[bB]\s*(\d+)/,
+            map: (match: RegExpMatchArray) => ({ command: 'block' as const, index: parseInt(match[1], 10) })
+          }, {
+            regex: /^\s*reset/i,
+            map: () => ({ command: 'reset' as const })
+          }, {
+            regex: /^\s*heal/i,
+            map: () => ({ command: 'heal' as const })
+          }, {
+            regex: /^\s*exit/i,
+            map: () => ({ command: 'exit' as const })
+          }, {
+            regex: /^\s*([^\d\s+-]+)\s*([+-]?\d+)/,
+            map: (match: RegExpMatchArray) => {
+              if (match[2].match(/^[+-]/)) {
+                return { command: 'mod-hp' as const, tag: match[1], value: parseInt(match[2]) };
+              } else {
+                return { command: 'set-hp' as const, tag: match[1], value: parseInt(match[2]) };
+              }
+            }
+          }, {
+            regex: /^\s*(\S+)\s+[tT]\s*([+-]?\d+)/,
+            map: (match: RegExpMatchArray) => {
+              if (match[2].match(/^[+-]/)) {
+                return { command: 'mod-thp' as const, tag: match[1], value: parseInt(match[2]) };
+              } else {
+                return { command: 'set-thp' as const, tag: match[1], value: parseInt(match[2]) };
+              }
+            }
+          }, {
+            regex: /^\s*(\S+)\s+[iI]\s*([+-]?\d+)/,
+            map: (match: RegExpMatchArray) => {
+              if (match[2].match(/^[+-]/)) {
+                return { command: 'mod-init' as const, tag: match[1], value: parseInt(match[2]) };
+              } else {
+                return { command: 'set-init' as const, tag: match[1], value: parseInt(match[2]) };
+              }
+            },
+          }, {
+            regex: /^\s*(\S+)\s+[sS]?\s*=?"([^"]*)"/,
+            map: (match: RegExpMatchArray) => {
+              return { command: 'set-conditions' as const, tag: match[1], value: match[2] };
+            },
+          }, {
+            regex: /^\s*(\S+)\s+[sS]?\s*\+"([^"]*)"/,
+            map: (match: RegExpMatchArray) => {
+              return { command: 'add-conditions' as const, tag: match[1], value: match[2] };
+            },
+          }, {
+            regex: /^\s*(\S+)\s+[sS]?\s*-"([^"]*)"/,
+            map: (match: RegExpMatchArray) => {
+              return { command: 'rem-conditions' as const, tag: match[1], value: match[2] };
+            },
+          }, {
+            regex: /^\s*(\S+)\s+[sS]?\s*\+\+"([^"]*)"/,
+            map: (match: RegExpMatchArray) => {
+              return { command: 'inc-conditions' as const, tag: match[1], value: match[2] };
+            },
+          }, {
+            regex: /^\s*(\S+)\s+[sS]?\s*--"([^"]*)"/,
+            map: (match: RegExpMatchArray) => {
+              return { command: 'dec-conditions' as const, tag: match[1], value: match[2] };
+            },
+          }, {
+            regex: /^\s*(\S+)\s+[cC]/,
+            map: (match: RegExpMatchArray) => ({ command: 'check' as const, tag: match[1] }),
+          }, {
+            regex: /^\s*(\S+)\s+[aA]/,
+            map: (match: RegExpMatchArray) => ({ command: 'arrow' as const, tag: match[1] }),
+          }, {
+            regex: /^\s*(\S+)\s+[eE]/,
+            map: (match: RegExpMatchArray) => ({ command: 'empty' as const, tag: match[1] }),
+          }, {
+            regex: /^\s*(\S+)\s+[xX]/,
+            map: (match: RegExpMatchArray) => ({ command: 'cross' as const, tag: match[1] }),
+          }, {
+            regex: /^\s*(\S+)\s+[dD]/,
+            map: (match: RegExpMatchArray) => ({ command: 'delete' as const, tag: match[1] }),
+          }, {
+            regex: /^\s*(\S+)\s+[wW]/,
+            map: (match: RegExpMatchArray) => ({ command: 'wait' as const, tag: match[1] }),
+          }];
+
+          const actions: ReturnType<typeof commands[number]['map']>[] = [];
+
+          while (true) {
+            const command = commands.find((c) => input.match(c.regex));
+
+            if (!command) {
+              break;
+            }
+
+            const match = input.match(command.regex);
 
-          if (hpmod) {
-            const file = await fs.readFile(argument, { encoding: 'utf-8' });
+            if (!match) {
+              break;
+            }
 
-            const tracker = parseTracker(file);
+            const action = command.map(match);
 
-            const index = tracker.findIndex((c) => c.alias === hpmod[1])
+            input = input.slice(match[0].length);
 
-            if (index >= 0) {
-              let hp = tracker[index].hp;
-              let thp = tracker[index].temphp;
+            actions.push(action)
+          }
 
-              if (hpmod[2].match(/^[+-]/)) {
-                const delta = parseInt(hpmod[2])
+          const file = await fs.readFile(argument, { encoding: 'utf-8' });
 
-                if (delta < 0) {
-                  thp += delta;
-                  hp += Math.min(thp, 0)
+          let tracker = parseTracker(file);
+
+          for (const action of actions) {
+            if (action.command === 'block') {
+              const sorted = [...tracker].sort((a, b) => (a.init === b.init) ? (b.foe ? 1 : 0) - (a.foe ? 1 : 0) : b.init - a.init);
+
+              const blocks = [[sorted[0]]];
+
+              for (let i=1; i < sorted.length; ++i) {
+                if (sorted[i].foe === blocks[blocks.length-1][0].foe) {
+                  blocks[blocks.length-1].push(sorted[i])
                 } else {
-                  hp += delta;
+                  blocks.push([sorted[i]])
+                } 
+              }
+
+              for (let i=0; i < blocks.length; ++i) {
+                if (i < action.index) {
+                  blocks[i].forEach((b) => b.state = 'check')
+                } else if (i === action.index) {
+                  blocks[i].forEach((b) => b.state = 'arrow')
+                } else {
+                  blocks[i].forEach((b) => b.state = 'empty')
                 }
-              } else {
-                hp = parseInt(hpmod[2]);
               }
+            } else if (action.command === 'wait') {
+              const sorted = [...tracker].sort((a, b) => (a.init === b.init) ? (b.foe ? 1 : 0) - (a.foe ? 1 : 0) : b.init - a.init);
 
-              tracker[index].temphp = Math.max(0, thp)
-              tracker[index].hp = Math.min(tracker[index].maxhp, Math.max(0, hp))
+              const blocks = [[sorted[0]]];
 
-              await fs.writeFile(argument, JSON.stringify(tracker, undefined, 2), { encoding: 'utf-8' })
-            }
-          }
+              for (let i=1; i < sorted.length; ++i) {
+                if (sorted[i].foe === blocks[blocks.length-1][0].foe) {
+                  blocks[blocks.length-1].push(sorted[i])
+                } else {
+                  blocks.push([sorted[i]])
+                } 
+              }
 
-          const thpmod = input.match(/(\S+)\s+[tT]\s*([+-]?\d+)/);
+              const blockIndex = blocks.findIndex((b) => b.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag))
+              const block = blocks[blockIndex + 1]
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
 
-          if (thpmod) {
-            const file = await fs.readFile(argument, { encoding: 'utf-8' });
+              if (block && item) {
+                item.init = (block[block.length - 1]?.init ?? 0) - 1;
+              }
+            } else if (action.command === 'check') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
 
-            const tracker = parseTracker(file);
+              if (item) {
+                item.state = "check"
+              }
+            } else if (action.command === 'arrow') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
 
-            const index = tracker.findIndex((c) => c.alias === thpmod[1])
+              if (item) {
+                item.state = "arrow"
+              }
+            } else if (action.command === 'empty') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
 
-            if (index >= 0) {
-              let thp = tracker[index].temphp;
+              if (item) {
+                item.state = "empty"
+              }
+            } else if (action.command === 'cross') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
 
-              if (thpmod[2].match(/^[+-]/)) {
-                thp += parseInt(thpmod[2]);
-              } else {
-                thp = parseInt(thpmod[2]);
+              if (item) {
+                item.state = "cross"
+              }
+            } else if (action.command === 'delete') {
+              tracker = tracker.filter((c) => !(c.id === action.tag || c.alias === action.tag || c.name == action.tag)).map((p) => ({
+                ...p,
+                children: p.children.filter((c) => !(c.id === action.tag || c.alias === action.tag || c.name == action.tag)),
+              }))
+            } else if (action.command === 'exit') {
+              process.exit(0)
+            } else if (action.command === 'heal') {
+              tracker.forEach((char) => {
+                char.hp = char.maxhp
+
+                char.children.forEach((child) => {
+                  child.hp = child.maxhp
+                })
+              })
+            } else if (action.command === 'reset') {
+              tracker.forEach((char) => {
+                char.state = 'empty'
+              })
+            } else if (action.command === 'set-thp') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                item.temphp = Math.max(0, action.value)
+              }
+            } else if (action.command === 'set-hp') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                item.hp = Math.min(item.maxhp, Math.max(0, action.value))
+              }
+            } else if (action.command === 'set-init') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+
+              if (item) {
+                item.init = Math.max(0, action.value)
+              }
+            } else if (action.command === 'set-conditions') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                item.conditions = action.value.trim()
+              }
+            } else if (action.command === 'add-conditions') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                const conditions = [...item.conditions.split(',').map((c) => c.toLowerCase().trim()).filter((c) => c.length), action.value.toLowerCase().trim()];
+
+                item.conditions = conditions.join(', ')
+              }
+            } else if (action.command === 'rem-conditions') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                const conditions = item.conditions.split(',').map((c) => c.toLowerCase().trim()).filter((c) => c.length).filter((c) => !c.includes(action.value.toLowerCase().trim()));
+
+                item.conditions = conditions.join(', ')
+              }
+            } else if (action.command === 'inc-conditions') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                const conditions = item.conditions.split(',').map((c) => c.toLowerCase().trim()).filter((c) => c.length).map((c) => {
+                  if (c.includes(action.value.toLowerCase().trim())) {
+                    const match = c.match(/(.*)\s+(\d+)/);
+
+                    if (match && match[1] && match[2]) {
+                      return `${match[1].trim()} ${parseInt(match[2]) + 1}`
+                    }
+                  }
+
+                  return c;
+                });
+
+                item.conditions = conditions.join(', ')
+              }
+            } else if (action.command === 'dec-conditions') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                const conditions = item.conditions.split(',').map((c) => c.toLowerCase().trim()).filter((c) => c.length).map((c) => {
+                  if (c.includes(action.value.toLowerCase().trim())) {
+                    const match = c.match(/(.*)\s+(\d+)/);
+
+                    if (match && match[1] && match[2]) {
+                      if (parseInt(match[2]) > 1) {
+                        return `${match[1].trim()} ${parseInt(match[2]) - 1}`
+                      } else {
+                        return match[1].trim()
+                      }
+                    }
+                  }
+
+                  return c;
+                });
+
+                item.conditions = conditions.join(', ')
+              }
+            } else if (action.command === 'mod-thp') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
+
+              if (item) {
+                item.temphp = Math.max(0, item.temphp + action.value)
               }
+            } else if (action.command === 'mod-hp') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag) ?? (
+                tracker.flatMap((c) => c.children).find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+              )
 
-              tracker[index].temphp = Math.max(0, thp)
+              if (item) {
+                let hp = item.hp;
+                let thp = item.temphp;
 
-              await fs.writeFile(argument, JSON.stringify(tracker, undefined, 2), { encoding: 'utf-8' })
+                if (action.value < 0) {
+                  thp += action.value;
+                  hp += Math.min(thp, 0)
+                } else {
+                  hp += action.value;
+                }
+
+                item.temphp = Math.max(0, thp)
+                item.hp = Math.min(item.maxhp, Math.max(0, hp))
+              }
+            } else if (action.command === 'mod-init') {
+              const item = tracker.find((c) => c.id === action.tag || c.alias === action.tag || c.name == action.tag)
+
+              if (item) {
+                item.init = Math.max(0, item.init + action.value)
+              }
             }
           }
+
+          await fs.writeFile(argument, JSON.stringify(tracker, undefined, 2), { encoding: 'utf-8' })
         }
       })(),
     ])

package/status.txt

@@ -1,5 +0,0 @@
-## Status: Player Characters
-Асотил (64/64 HP): 
-Брон (24/24 HP): 
-Нтаанди (20/20 HP): 
-Перитон (22/22 HP):

package/tracker.json

@@ -1,62 +0,0 @@
-[
-  {
-    "init": 19,
-    "foe": false,
-    "state": "empty",
-    "name": "Перитон",
-    "alias": "pe",
-    "hp": 22,
-    "temphp": 0,
-    "maxhp": 22,
-    "conditions": "",
-    "children": []
-  },
-  {
-    "init": 21,
-    "foe": false,
-    "state": "empty",
-    "name": "Асотил",
-    "alias": "as",
-    "hp": 64,
-    "temphp": 0,
-    "maxhp": 64,
-    "conditions": "",
-    "children": []
-  },
-  {
-    "init": 19,
-    "foe": true,
-    "state": "empty",
-    "name": "Псина",
-    "alias": "hnd",
-    "hp": 70,
-    "temphp": 0,
-    "maxhp": 80,
-    "conditions": "-1 to AC and saves",
-    "children": []
-  },
-  {
-    "init": 18,
-    "foe": false,
-    "state": "empty",
-    "name": "Брон",
-    "alias": "br",
-    "hp": 24,
-    "temphp": 0,
-    "maxhp": 24,
-    "conditions": "hidden",
-    "children": []
-  },
-  {
-    "init": 25,
-    "foe": false,
-    "state": "arrow",
-    "name": "Нтаанди",
-    "alias": "nt",
-    "hp": 13,
-    "temphp": 0,
-    "maxhp": 20,
-    "conditions": "",
-    "children": []
-  }
-]