add: ap-calc script

Author: Mitsunee

README.md

@@ -36,6 +36,14 @@ pnpm tsx src/welfares/script.ts
 
 Script that lists event welfare Servants that have not yet been released on the EN server.
 
+### AP Calc
+
+```
+pnpm ap-calc [-m,--max <num>] [-n,--node <num>] <current-ap> [<current-timer>]
+```
+
+Simple AP Calculator that calculates time to Max AP and, if given a node cost via `-n` (or `--node`) time until each possible run can be done. Output is given as a table with time (24h notation) and delta until that point. Max AP is assumed to be `144`, but can be overriden with `-m` (or `--max`). Values for current ap and time until next AP are positional, with current timer being optional.
+
 ## Cache
 
 Instead of constantly redownloading the same data the `pnpm prepare-cache` script downloads all needed data for servants and items at once and stores it in `./data/cache`. Data is transformed to match the data structures descriped in [`./src/types`](./src/types), which avoids duplicates and removes attributes that are not used in any scripts.

package.json

@@ -16,7 +16,8 @@
     "lint:strict": "eslint --max-warnings 0 .",
     "typecheck": "tsc",
     "prepare-cache": "tsx src/cache/prepare-cache/script.ts",
-    "search-servant": "tsx src/search-servant/script.ts"
+    "search-servant": "tsx src/search-servant/script.ts",
+    "ap-calc": "tsx src/ap-calc/script.ts"
   },
   "nano-staged": {
     "**/*.{js,cjs,mjs,ts,mts,cts,json,md,yaml}": [

src/ap-calc/script.ts

@@ -0,0 +1,118 @@
+import spacetime from "spacetime";
+import { parseArgs } from "util";
+import { log, logger, timer } from "~/utils/logger";
+
+const getTime = timer();
+const args = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    verbose: { type: "boolean", short: "v", default: false },
+    max: { type: "string", short: "m", default: "144" },
+    node: { type: "string", short: "n" }
+  },
+  allowPositionals: true
+});
+const usageText = `USAGE: pnpm ap-calc [--max <num>] [--node <num>] <current-ap> [<current-timer>]`;
+
+const timeDiffer = (() => {
+  const now = spacetime.now().startOf("second");
+
+  return function (deltaSeconds: number) {
+    const then = now.add(deltaSeconds, "second");
+    const { diff } = then.since(now);
+    return {
+      time: then.format("{time-24}:{second-pad}"),
+      in: [diff.hours, diff.minutes, diff.seconds]
+        .map(v => v.toString().padStart(2, "0"))
+        .join(":")
+    };
+  };
+})();
+
+async function main() {
+  // DEBUG
+  if (args.values.verbose) logger.setLogLevel("Debug");
+  log.debug(args);
+
+  // parse args
+  let apMax = parseInt(args.values.max);
+  let nodeCost = args.values.node ? parseInt(args.values.node) : undefined;
+  if (isNaN(apMax) || apMax < 20) {
+    log.error(
+      `Could not parse argument for --max '${args.values.max}'. Argument must integer >= 20`
+    );
+    log.warn("Using '5' as fallback value for --max");
+    apMax = 144;
+  }
+  if (nodeCost && isNaN(nodeCost) && nodeCost < 1) {
+    log.error(
+      `Could not parse argument for --node '${args.values.node}'. Argument must integer > 0`
+    );
+    nodeCost = undefined;
+  }
+
+  // parse positionals
+  const apCurr = parseInt(args.positionals[0] || "");
+  if (isNaN(apCurr) || apCurr < 0) {
+    throw new Error(
+      `Could not parse value for current ap: '${args.positionals[0]}'`
+    );
+  }
+  const timerValue = args.positionals[1] || "";
+  let timerSeconds = 300;
+  if (timerValue) {
+    const match = timerValue.match(/^([0-4]):([0-5][0-9])$/);
+    if (!match) {
+      throw new Error(`Could not parse value for current timer: ${timerValue}`);
+    }
+
+    timerSeconds = Number(match[1]) * 60 + Number(match[2]);
+  }
+  log.debug({ apCurr, apMax, timerValue, timerSeconds });
+
+  const table = new Array<{
+    ap: number;
+    title: string;
+    time: string;
+    in: string;
+  }>();
+
+  if (nodeCost) {
+    let runs = 0;
+    for (let ap = nodeCost; ap <= apMax; ap += nodeCost) {
+      const deltaAP = ap - apCurr;
+      const deltaSeconds = (deltaAP - 1) * 300 + timerSeconds;
+      table.push(
+        Object.assign({ ap, title: `Run #${++runs}` }, timeDiffer(deltaSeconds))
+      );
+    }
+  }
+
+  // handle max AP
+  const deltaMaxAP = apMax - apCurr;
+  const deltaMaxSeconds = (deltaMaxAP - 1) * 300 + timerSeconds;
+  table.push(
+    Object.assign({ ap: apMax, title: "Max AP" }, timeDiffer(deltaMaxSeconds))
+  );
+
+  // print table
+  console.table(
+    table
+      .filter(run => run.ap >= apCurr)
+      .reduce(
+        (obj, { title, ...row }) => {
+          obj[title] = row;
+          return obj;
+        },
+        {} as Record<string, Omit<(typeof table)[0], "title">>
+      ),
+    ["ap", "time", "in"]
+  );
+}
+
+main()
+  .then(() => log.success(`Completed in ${getTime()}`))
+  .catch(e => {
+    log.info(usageText);
+    log.fatal(e);
+  });