Add shared song score aggregation support

gitadora@asphyxia/handlers/SharedScores.ts

@@ -0,0 +1,90 @@
+import { PLUGIN_VER } from "../const";
+import { Scores } from "../models/scores";
+
+type ScoreDiff = Scores['scores'][string]['diffs'][string];
+type ScoreEntry = Scores['scores'][string];
+
+function selectBetterMeter(existing?: string, incoming?: string): string {
+  if (!incoming) return existing ?? "0";
+  if (!existing) return incoming;
+
+  try {
+    return BigInt(incoming) > BigInt(existing) ? incoming : existing;
+  } catch (e) {
+    return incoming || existing;
+  }
+}
+
+function mergeScoreDiff(existing: ScoreDiff | undefined, incoming: ScoreDiff): ScoreDiff {
+  if (!existing) return incoming;
+
+  return {
+    perc: Math.max(existing.perc ?? 0, incoming.perc ?? 0),
+    rank: Math.max(existing.rank ?? 0, incoming.rank ?? 0),
+    meter: selectBetterMeter(existing.meter, incoming.meter),
+    prog: Math.max(existing.prog ?? 0, incoming.prog ?? 0),
+    clear: (existing.clear ?? false) || (incoming.clear ?? false),
+    fc: (existing.fc ?? false) || (incoming.fc ?? false),
+    ex: (existing.ex ?? false) || (incoming.ex ?? false),
+  };
+}
+
+function mergeScoreEntry(existing: ScoreEntry | undefined, incoming: ScoreEntry): ScoreEntry {
+  const mergedDiffs: ScoreEntry['diffs'] = existing ? { ...existing.diffs } : {};
+
+  for (const [seq, diff] of Object.entries(incoming.diffs)) {
+    mergedDiffs[seq] = mergeScoreDiff(mergedDiffs[seq], diff);
+  }
+
+  const mergedUpdate = existing?.update ? [...existing.update] : [0, 0];
+  if (incoming.update && (mergedUpdate[1] ?? 0) < incoming.update[1]) {
+    mergedUpdate[0] = incoming.update[0];
+    mergedUpdate[1] = incoming.update[1];
+  }
+
+  return {
+    update: mergedUpdate,
+    diffs: mergedDiffs,
+  };
+}
+
+function mergeScoreCollections(target: Scores['scores'], incoming: Scores['scores']): Scores['scores'] {
+  const merged = { ...target } as Scores['scores'];
+
+  for (const [mid, entry] of Object.entries(incoming)) {
+    merged[mid] = mergeScoreEntry(merged[mid], entry);
+  }
+
+  return merged;
+}
+
+async function persistSharedScores(refid: string, game: 'gf' | 'dm', scores: Scores['scores']) {
+  await DB.Upsert<Scores>(refid, { collection: 'scores', game, version: 'shared' }, {
+    collection: 'scores',
+    version: 'shared',
+    pluginVer: PLUGIN_VER,
+    game,
+    scores,
+  });
+}
+
+/**
+ * Load and merge scores across all versions for a player/game pair and persist them under version "shared".
+ */
+export async function getMergedSharedScores(refid: string, game: 'gf' | 'dm'): Promise<Scores['scores']> {
+  const scoreDocs = await DB.Find<Scores>(refid, { collection: 'scores', game });
+  const mergedScores = scoreDocs.reduce<Scores['scores']>((acc, doc) => mergeScoreCollections(acc, doc.scores), {} as Scores['scores']);
+
+  await persistSharedScores(refid, game, mergedScores);
+  return mergedScores;
+}
+
+/**
+ * Merge the provided score set into the shared scores document for the player/game pair.
+ */
+export async function mergeScoresIntoShared(refid: string, game: 'gf' | 'dm', scores: Scores['scores']) {
+  const existingShared = await DB.FindOne<Scores>(refid, { collection: 'scores', game, version: 'shared' });
+  const mergedScores = mergeScoreCollections(existingShared?.scores ?? {}, scores);
+
+  await persistSharedScores(refid, game, mergedScores);
+}

gitadora@asphyxia/handlers/profiles.ts

@@ -10,7 +10,7 @@ import { getDefaultScores, Scores } from "../models/scores";
 
 import { PLUGIN_VER } from "../const";
 import Logger from "../utils/logger"
-import { isAsphyxiaDebugMode } from "../utils/index";
+import { isAsphyxiaDebugMode, isSharedSongScoresEnabled } from "../utils/index";
 import { SecretMusicEntry } from "../models/secretmusicentry";
 import { CheckPlayerResponse, getCheckPlayerResponse } from "../models/Responses/checkplayerresponse";
 import { getPlayerStickerResponse, PlayerStickerResponse } from "../models/Responses/playerstickerresponse";
@@ -20,6 +20,7 @@ import { getDefaultBattleDataResponse } from "../models/Responses/battledataresp
 import { applySharedFavoriteMusicToExtra, saveSharedFavoriteMusicFromExtra } from "./FavoriteMusic";
 import { getPlayerRecordResponse } from "../models/Responses/playerrecordresponse";
 import { getPlayerPlayInfoResponse, PlayerPlayInfoResponse } from "../models/Responses/playerplayinforesponse";
+import { getMergedSharedScores, mergeScoresIntoShared } from "./SharedScores";
 
 const logger = new Logger("profiles")
 
@@ -72,6 +73,7 @@ export const getPlayer: EPR = async (info, data, send) => {
   const time = BigInt(31536000);
   const dm = isDM(info);
   const game = dm ? 'dm' : 'gf';
+  const sharedScoresEnabled = isSharedSongScoresEnabled();
 
   logger.debugInfo(`Loading ${game} profile for player ${no} with refid: ${refid}`)
   const name = await DB.FindOne<PlayerInfo>(refid, {
@@ -84,8 +86,8 @@ export const getPlayer: EPR = async (info, data, send) => {
   const gfRecord = await getRecord(refid, version, 'gf')
   const dmExtra = await getExtra(refid, version, 'dm')
   const gfExtra = await getExtra(refid, version, 'gf')
-  const dmScores = (await getScore(refid, version, 'dm')).scores
-  const gfScores = (await getScore(refid, version, 'gf')).scores
+  const dmScores = sharedScoresEnabled ? await getMergedSharedScores(refid, 'dm') : (await getScore(refid, version, 'dm')).scores
+  const gfScores = sharedScoresEnabled ? await getMergedSharedScores(refid, 'gf') : (await getScore(refid, version, 'gf')).scores
 
   const profile = dm ? dmProfile : gfProfile;
   const extra = dm ? dmExtra : gfExtra;
@@ -524,6 +526,7 @@ export const savePlayers: EPR = async (info, data, send) => {
   const version = getVersion(info);
   const dm = isDM(info);
   const game = dm ? 'dm' : 'gf';
+  const sharedScoresEnabled = isSharedSongScoresEnabled();
 
   let players = $(data).elements("player")
 
@@ -549,7 +552,7 @@ export const savePlayers: EPR = async (info, data, send) => {
         throw "Request data is missing required parameter: player.refid"
       }
 
-      await saveSinglePlayer(player, refid, no, version, game);
+      await saveSinglePlayer(player, refid, no, version, game, sharedScoresEnabled);
 
       let ranking = await getPlayerRanking(refid, version, game)
       let responsePart = getSaveProfileResponse(no, ranking)
@@ -569,7 +572,7 @@ export const savePlayers: EPR = async (info, data, send) => {
   }
 };
 
-async function saveSinglePlayer(dataplayer: KDataReader, refid: string, no: number, version: string, game: 'gf' | 'dm')
+async function saveSinglePlayer(dataplayer: KDataReader, refid: string, no: number, version: string, game: 'gf' | 'dm', sharedScoresEnabled: boolean)
 {
   logger.debugInfo(`Saving ${game} profile for player ${no} with refid: ${refid}`)
   const profile = await getProfile(refid, version, game) as any;
@@ -712,7 +715,11 @@ async function saveSinglePlayer(dataplayer: KDataReader, refid: string, no: numb
   logStagesPlayed(playedStages)
   
   const scores = await updatePlayerScoreCollection(refid, playedStages, version, game)
-  await saveScore(refid, version, game, scores); 
+  await saveScore(refid, version, game, scores);
+
+  if (sharedScoresEnabled) {
+    await mergeScoresIntoShared(refid, game, scores);
+  }
   await saveSharedFavoriteMusicFromExtra(refid, extra)
 }