WIP: user score manager

Author: Mitsunee

src/manager/scores/chooseScore.ts

@@ -0,0 +1,33 @@
+import type { Interface } from "readline/promises";
+
+/**
+ * User-choice menu for picking Class/Grand Score
+ * @param scoresList read cachefile
+ * @param rl Readline Interface
+ * @returns idx in scoresList
+ */
+export async function chooseScore(scoresList: ClassScore[], rl: Interface) {
+  const n = scoresList.length.toString().length;
+  const choice = await rl.question(
+    `Pick Class Score:\n${scoresList
+      .map(
+        (score, idx) =>
+          `  ${" ".repeat(n - (idx + 1).toString().length)}[${idx + 1}] ${score.name}${
+            score.en ? "" : " (JP only)"
+          }\n`
+      )
+      .join("")}\nChoice (1-${scoresList.length}): `
+  );
+
+  // parse input
+  const choiceParsed = parseInt(choice) - 1;
+  if (
+    isNaN(choiceParsed) ||
+    choiceParsed < 0 ||
+    choiceParsed >= scoresList.length
+  ) {
+    return;
+  }
+
+  return choiceParsed;
+}

src/manager/scores/createBlankUserScore.ts

@@ -0,0 +1,10 @@
+import type { UserClassScore } from "./types";
+
+export function createBlankUserScore(id: number) {
+  const score: UserClassScore = {
+    id,
+    unlockedNodes: []
+  };
+
+  return score;
+}

src/manager/scores/index.ts

@@ -0,0 +1,43 @@
+import type { Interface } from "readline/promises";
+import { scoresCache } from "~/cache";
+import { describeServantClass } from "~/utils/describeServantClass";
+import { chooseScore } from "./chooseScore";
+import { loadUserScore } from "./loadUserScores";
+import { createBlankUserScore } from "./createBlankUserScore";
+
+export async function scoresManager(rl: Interface) {
+  const scoresList = await scoresCache.read();
+  let current: undefined | number = undefined;
+
+  while (true) {
+    current ??= await chooseScore(scoresList, rl);
+    if (current === undefined) return;
+    const scoreData = scoresList[current];
+    const userScoreFile = await loadUserScore(scoreData.id);
+    const userScore = await userScoreFile.read();
+    const totalNodes = Object.values(scoreData.nodes).length;
+    console.log(
+      `\n${scoreData.name}${
+        scoreData.classes.length > 1
+          ? ` (${scoreData.classes.map(className => describeServantClass(className)).join(", ")})`
+          : ""
+      }\n${userScore.unlockedNodes.length}/${totalNodes} completed`
+    );
+
+    const opt = await rl.question(
+      `  [1] Unlock Nodes\n  [2] Check required Materials\n  [3] Reset Class Score\nChoice (1-3): `
+    );
+    switch (opt) {
+      case "1":
+      case "2":
+        console.error("UNIMPLEMENTED");
+        continue; // TEMP
+      case "3":
+        await userScoreFile.write(createBlankUserScore(scoreData.id));
+        continue;
+      default:
+        current = undefined;
+        continue;
+    }
+  }
+}

src/manager/script.ts

@@ -0,0 +1,28 @@
+import { parseArgs } from "util";
+import { createInterface } from "readline/promises";
+import { log, logger, createTimer } from "~/utils/logger";
+
+const timer = createTimer();
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+const { values: args } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    verbose: { type: "boolean", short: "v", default: false }
+  }
+});
+
+async function main() {
+  // DEBUG
+  if (args.verbose) logger.setLogLevel("Debug");
+  log.debug(args);
+
+  // CODE GOES HERE
+  const { scoresManager } = await import("./scores");
+  const res = await scoresManager(rl);
+  log.debug(res);
+}
+
+main()
+  .then(() => log.success(`Completed in ${timer()}`))
+  .catch(e => log.fatal(e))
+  .finally(() => rl.close());