add: class score data

Author: Mitsunee

src/cache/index.ts

@@ -44,3 +44,4 @@ export const freeQuestsCache = new CacheFile<FreeQuest[]>(
   "data/freeQuestsList.json"
 );
 export const warsCache = new CacheFile<War[]>("data/warsList.json");
+export const scoresCache = new CacheFile<ClassScore[]>("data/scoreList.json");

src/cache/prepare-cache/getNiceClassScore.ts

@@ -0,0 +1,48 @@
+import type { ClassBoard } from "@atlasacademy/api-connector/dist/Schema/ClassBoard";
+import { CacheFile } from "..";
+import { log } from "~/utils/logger";
+import { connectorEN, connectorJP } from "./connector";
+
+const cacheFiles = new Map<SupportedRegion, CacheFile<ClassBoard[]>>();
+
+export async function getNiceClassScore(
+  region: SupportedRegion,
+  update = false
+) {
+  const connector = region == "EN" ? connectorEN : connectorJP;
+  const descriptor = `class_score_list for region ${region}`;
+  let scoreList: ClassBoard[];
+  let cacheFile = cacheFiles.get(region);
+  if (!cacheFile) {
+    const filePath = `data/cache/${region}/class_score_list.json`;
+    cacheFile = new CacheFile(filePath);
+    cacheFiles.set(region, cacheFile);
+  }
+
+  if (!update) {
+    const exists = await cacheFile.exists();
+    if (!exists) {
+      log.warn(`${descriptor} does not yet exist, forcing update`);
+      update = true;
+    }
+  }
+
+  if (update) {
+    log.debug(`Fetching ${descriptor}`);
+    scoreList = await connector.classBoardList();
+    await cacheFile.write(scoreList);
+    log.info(`Updated ${descriptor}`);
+  } else {
+    try {
+      const data = await cacheFile.read();
+      if (!Array.isArray(data)) throw new Error("");
+      scoreList = data;
+      log.debug(`Using cached ${descriptor}`);
+    } catch (e) {
+      log.error(`Could not retrieve ${descriptor}`);
+      throw e;
+    }
+  }
+
+  return scoreList;
+}

src/cache/prepare-cache/processClassScore.ts

@@ -0,0 +1,98 @@
+import { ClassBoardSquareFlag } from "@atlasacademy/api-connector/dist/Schema/ClassBoard";
+import type { ClassBoard } from "@atlasacademy/api-connector/dist/Schema/ClassBoard";
+import type { ItemProcessor } from "./processItemData";
+import { convertClassName } from "./classNames";
+
+export function createClassScoreProcessor(itemProcessor: ItemProcessor) {
+  const scoreMap: Record<ID, ClassScore> = {};
+
+  function getClassScoreList() {
+    return Object.values(scoreMap).sort((a, b) => a.id - b.id);
+  }
+
+  function processClassScores(
+    niceScoreJP: ClassBoard[],
+    niceScoreEN: ClassBoard[]
+  ) {
+    for (const boardJP of niceScoreJP) {
+      const boardEN =
+        boardJP.id == 8 // TEMP: Extra 1 is still locked on EN
+          ? undefined
+          : niceScoreEN.find(board => board.id == boardJP.id);
+      const en = Boolean(boardEN);
+      const boardClasses = new Set<ServantClass>();
+
+      for (const boardClass of boardJP.classes) {
+        boardClasses.add(convertClassName(boardClass.className));
+      }
+
+      const score: ClassScore = {
+        id: boardJP.id,
+        name: boardEN?.name || boardJP.name,
+        classes: Array.from(boardClasses),
+        nodes: {},
+        startNodes: []
+      };
+
+      // process squares
+      for (const square of boardJP.squares) {
+        // skip if blank
+        if (square.flags.includes(ClassBoardSquareFlag.BLANK)) continue;
+
+        const node: ClassScoreNode = {
+          id: square.id,
+          qp: 0,
+          items: [],
+          next: []
+        };
+
+        // process items
+        for (const itemAmount of square.items) {
+          // why is QP an item here?
+          if (itemAmount.item.id == 1) {
+            node.qp += itemAmount.amount;
+            continue;
+          }
+
+          // add to node
+          node.items.push([itemAmount.item.id, itemAmount.amount]);
+
+          // if item not previously processed do that now and push it to list
+          itemProcessor.registerItem(itemAmount.item, en);
+        }
+
+        // process lock items
+        if (square.lock) {
+          for (const itemAmount of square.lock.items) {
+            // why is QP an item here?
+            if (itemAmount.item.id == 1) {
+              node.qp += itemAmount.amount;
+              continue;
+            }
+
+            // add to node
+            node.items.push([itemAmount.item.id, itemAmount.amount]);
+
+            // if item not previously processed do that now and push it to list
+            itemProcessor.registerItem(itemAmount.item, en);
+          }
+        }
+
+        // register node in map
+        score.nodes[square.id] = node;
+      }
+
+      // process lines
+      for (const line of boardJP.lines) {
+        const prev = score.nodes[line.prevSquareId];
+        const next = score.nodes[line.nextSquareId];
+        if (!prev || !next) continue;
+        prev.next.push(next.id);
+      }
+
+      scoreMap[score.id] = score;
+    }
+  }
+
+  return { getClassScoreList, processClassScores };
+}

src/cache/prepare-cache/processNiceServant.ts

@@ -1,23 +1,28 @@
 import type { ServantWithLore as NiceServant } from "@atlasacademy/api-connector/dist/Schema/Servant";
+import type { ClassBoard } from "@atlasacademy/api-connector/dist/Schema/ClassBoard";
 import { log } from "~/utils/logger";
-import { itemsCache, servantsCache, skillsCache } from "~/cache";
+import { itemsCache, scoresCache, servantsCache, skillsCache } from "~/cache";
 import { indexServantNames } from "./servantNames";
 import { createItemProcessor } from "./processItemData";
 import { createEnhancementProcessor } from "./processEnhancementStage";
 import { createSkillProcessor } from "./processServantSkill";
 import { createServantProcessor } from "./processServant";
 import { processServantMashu } from "./processServantMashu";
 import { createNPsProcessor } from "./processNoblePhantasm";
+import { createClassScoreProcessor } from "./processClassScore";
 
 export async function processNiceServant(
   niceServantJP: NiceServant[],
-  niceServantEN: NiceServant[]
+  niceServantEN: NiceServant[],
+  niceScoreJP: ClassBoard[],
+  niceScoreEN: ClassBoard[]
 ) {
   const servantNames = indexServantNames(niceServantJP, niceServantEN);
   const itemProcessor = createItemProcessor();
   const enhancementProcessor = createEnhancementProcessor(itemProcessor);
   const skillProcessor = createSkillProcessor();
   const npsProcessor = createNPsProcessor();
+  const scoreProcessor = createClassScoreProcessor(itemProcessor);
   const servantsProcessor = createServantProcessor({
     enhancementProcessor,
     skillProcessor,
@@ -48,20 +53,26 @@ export async function processNiceServant(
     servantsProcessor.processServant(servantJP, servantEN);
   }
 
+  // process class scores
+  scoreProcessor.processClassScores(niceScoreJP, niceScoreEN);
+
   const itemsList = itemProcessor.getItemList();
   const servantsList = servantsProcessor.getServantsList();
   const skillsList = skillProcessor.getSkillList();
   const npsList = npsProcessor.getNPsList();
   const costumesList = enhancementProcessor.getCostumesList();
+  const scoreList = scoreProcessor.getClassScoreList();
   log.info(`${itemsList.length} Items found`);
   log.info(`${servantsList.length} Servants found`);
   log.info(`${skillsList.length} Skills found`);
   log.info(`${npsList.length} NPs found`);
   log.info(`${costumesList.length} Costumes found`);
+  log.info(`${scoreList.length} Class Score boards found`);
 
   await Promise.all([
     itemsCache.write(itemsList),
     servantsCache.write(servantsList),
-    skillsCache.write(skillsList)
+    skillsCache.write(skillsList),
+    scoresCache.write(scoreList)
   ]);
 }

src/cache/prepare-cache/script.ts

@@ -7,6 +7,7 @@ import { getNiceServant } from "./getNiceServant";
 import { processNiceServant } from "./processNiceServant";
 import { getNiceWar } from "./getNiceWar";
 import { processNiceWar } from "./processNiceWar";
+import { getNiceClassScore } from "./getNiceClassScore";
 
 const timer = createTimer();
 const { values: args } = parseArgs({
@@ -48,10 +49,19 @@ async function main() {
       getNiceWar("JP"),
       getNiceWar("EN")
     ]);
+    const [niceScoreJP, niceScoreEN] = await Promise.all([
+      getNiceClassScore("JP"),
+      getNiceClassScore("EN")
+    ]);
 
     // perform data update
     await Promise.all([
-      processNiceServant(niceServantJP, niceServantEN),
+      processNiceServant(
+        niceServantJP,
+        niceServantEN,
+        niceScoreJP,
+        niceScoreEN
+      ),
       processNiceWar(niceWarJP, niceWarEN)
     ]);
     log.success("Wrote new data cache");
@@ -88,6 +98,10 @@ async function main() {
     getNiceWar("JP", updateJP),
     getNiceWar("EN", updateEN)
   ]);
+  const [niceScoreJP, niceScoreEN] = await Promise.all([
+    getNiceClassScore("JP"),
+    getNiceClassScore("EN")
+  ]);
 
   if (!noUpdate) {
     // update local info
@@ -102,7 +116,7 @@ async function main() {
 
   // perform data update
   await Promise.all([
-    processNiceServant(niceServantJP, niceServantEN),
+    processNiceServant(niceServantJP, niceServantEN, niceScoreJP, niceScoreEN),
     processNiceWar(
       niceWarJP,
       niceWarEN,

src/cache/types.ts

@@ -20,9 +20,10 @@ export interface CacheInfo {
 /**
  * Current Cache Version
  */
-export const CACHE_VER = 1;
+export const CACHE_VER = 2;
 
 /* Cache Version History:
 v0: Development
 v1: added nice_war
+v2: added nice_class_Score
 */

src/types/score.d.ts

@@ -0,0 +1,11 @@
+interface ClassScoreNode extends EnhancementStage {
+  id: number;
+  detail?: string; // don't know if this can be guaranteed yet
+  next: Array<number>;
+}
+
+interface ClassScore extends EntityBase {
+  classes: ServantClass[];
+  nodes: Record<number, ClassScoreNode>;
+  startNodes: Array<number>;
+}