lr2hook: add fast-slow support (#1367)

* build(client): add 'lintfix' target matching the server

* docs(lr2hook): suggest lr2_chainload instead of BokutachiLauncher.exe

BokutachiLauncher.exe is no longer a part of BokutachiHook.

* refactor(server/lr2hook): G-ATTACK, P-ATTACK and HAZARD are not HARD

* feat(server/lr2hook): parse extendedJudgements

* feat(server/lr2hook): use fast-slow and early/late judgements

* test(server/lr2hook): make clear that in this test notesPlayed != notesTotal

* feat(server/lr2hook): calculate BP by hand when exiting chart early

* feat(server/lr2hook): parse rseed

* feat(server/lr2hook): parse extendedHpGraphs

* feat(server/lr2hook): parse unixTimestamp

* feat(server/lr2hook): use unixTimestamp as score play time

Especially useful as BokutachiHook now retries sending scores after some
time on connections errors.

* feat(common/bms+server/lr2hook+docs): add gaugeHistory{Easy,Groove,Hard}

Could also save graphs for unimplemented gauges, not done here as I
don't know if they are ever going to be implemented while they take some
decent space.

* feat(client/bms): support several gauges

Ugly IIFE inside IIFE is work-around for eslint bug `Expected a 'break'
statement before 'case'`.

Author: chown2

client/Justfile

@@ -9,4 +9,8 @@ start:
 # Test that the client passes typechecking and linting.
 test:
 	pnpm typecheck
-	pnpm lint
+	pnpm lint
+
+# Clean up the code and fix any automatically fixable mistakes.
+lintfix:
+	pnpm lint-fix

client/src/app/pages/dashboard/import/LR2HookPage.tsx

@@ -25,6 +25,10 @@ export default function LR2HookPage() {
 					Download the latest version of the LR2Hook{" "}
 					<ExternalLink href="https://github.com/MatVeiQaaa/BokutachiHook/releases">
 						here
+					</ExternalLink>{" "}
+					and lr2_chainload{" "}
+					<ExternalLink href="https://github.com/SayakaIsBaka/lr2_chainload/releases">
+						here
 					</ExternalLink>
 					.
 				</li>
@@ -39,14 +43,18 @@ export default function LR2HookPage() {
 					Place this file in the same folder as <b>LR2Body.exe</b>.
 				</li>
 				<li>
-					That's it! Launch the game with <code>BokutachiLauncher.exe</code> and start
-					playing, your scores will automatically submit to the server.
+					Create file named <b>chainload.txt</b> in the same folder as <b>LR2Body.exe</b>{" "}
+					and add new line "BokutachiHook.dll" into it.
+				</li>
+				<li>
+					That's it! Launch the game as usual, your scores will automatically submit to
+					the server.
 				</li>
 			</ol>
 			<Divider />
 			<Muted>
 				Note: If you submit a score on a chart that {TachiConfig.NAME} doesn't recognise,
-				you'll need to wait until atleast 2 other players submit scores for that chart
+				you'll need to wait until at least 2 other players submit scores for that chart
 				before it'll show up. This is to combat accidental IR spam.
 			</Muted>
 		</div>

client/src/components/tables/dropdowns/components/BMSScoreDropdownParts.tsx

@@ -13,12 +13,24 @@ export function BMSGraphsComponent({
 	score: ScoreDocument<"bms:7K" | "bms:14K"> | PBScoreDocument<"bms:7K" | "bms:14K">;
 	chart: ChartDocument<"bms:7K" | "bms:14K">;
 }) {
-	const gaugeHistory = score.scoreData.optional.gaugeHistory;
-
 	const [lamp, setLamp] = useState<LampTypes>(LampToKey(score));
 
+	let gaugeStatus: "none" | "single" | "gas" = "none";
+
+	if (
+		score.scoreData.optional.gaugeHistoryEasy &&
+		score.scoreData.optional.gaugeHistoryGroove &&
+		score.scoreData.optional.gaugeHistoryHard
+	) {
+		gaugeStatus = "gas";
+	} else if (score.scoreData.optional.gaugeHistory) {
+		gaugeStatus = "single";
+	}
+
 	const shouldDisable = (r: LampTypes) => {
-		if (gaugeHistory) {
+		if (gaugeStatus === "gas") {
+			return false;
+		} else if (gaugeStatus === "single") {
 			return r !== LampToKey(score);
 		}
 
@@ -29,6 +41,28 @@ export function BMSGraphsComponent({
 		setLamp(LampToKey(score));
 	}, [score]);
 
+	const gaugeHistory = (() => {
+		switch (gaugeStatus) {
+			case "gas":
+				return (() => {
+					switch (lamp) {
+						case "Normal":
+							return score.scoreData.optional.gaugeHistoryGroove!;
+						case "Easy":
+							return score.scoreData.optional.gaugeHistoryEasy!;
+						case "Hard":
+							return score.scoreData.optional.gaugeHistoryHard!;
+						case "EXHard":
+							return null;
+					}
+				})();
+			case "single":
+				return score.scoreData.optional.gaugeHistory!;
+			case "none":
+				return null;
+		}
+	})();
+
 	return (
 		<>
 			<div className="col-12 d-flex justify-content-center">

common/src/config/game-support/bms.ts

@@ -230,6 +230,21 @@ export const BMS_7K_CONF = {
 			description:
 				"A snapshot of the gauge percent throughout the chart. The values should be null from the point the user dies until the end of the chart.",
 		},
+		gaugeHistoryEasy: {
+			type: "GRAPH",
+			validate: p.isBetween(0, 100),
+			description: "The easy gauge history.",
+		},
+		gaugeHistoryGroove: {
+			type: "GRAPH",
+			validate: p.isBetween(0, 100),
+			description: "The groove gauge history.",
+		},
+		gaugeHistoryHard: {
+			type: "GRAPH",
+			validate: p.isBetween(0, 100),
+			description: "The hard gauge history.",
+		},
 		epg: {
 			type: "INTEGER",
 			validate: p.isPositive,

docs/docs/game-support/games/bms-7K.md

@@ -33,6 +33,9 @@ For more information on what metrics are and how they work, see [TODO]!
 | `bp` | Integer | The total bads + poors in this score. |
 | `gauge` | Decimal | The life in percent (between 0 and 100) that was on the gauge at the end of the chart. |
 | `gaugeHistory` | Array<Decimal> | A snapshot of the gauge percent throughout the chart. The values should be null from the point the user dies until the end of the chart. |
+| `gaugeHistoryEasy` | Array<Decimal> | The easy gauge history. |
+| `gaugeHistoryGroove` | Array<Decimal> | The groove gauge history. |
+| `gaugeHistoryHard` | Array<Decimal> | The hard gauge history. |
 | `epg` | Integer | The amount of early PGreats in this score. |
 | `egr` | Integer | The amount of early greats in this score. |
 | `egd` | Integer | The amount of early goods in this score. |

server/src/game-implementations/games/bms-pms.ts

@@ -22,6 +22,9 @@ const BMS_PMS_MERGERS: Array<PBMergeFunction<GPTStrings["bms" | "pms"]>> = [
 		// legal value for these properties it works out.
 		base.scoreData.optional.gauge = lamp.scoreData.optional.gauge;
 		base.scoreData.optional.gaugeHistory = lamp.scoreData.optional.gaugeHistory;
+		base.scoreData.optional.gaugeHistoryEasy = lamp.scoreData.optional.gaugeHistoryEasy;
+		base.scoreData.optional.gaugeHistoryGroove = lamp.scoreData.optional.gaugeHistoryGroove;
+		base.scoreData.optional.gaugeHistoryHard = lamp.scoreData.optional.gaugeHistoryHard;
 	}),
 	CreatePBMergeFor("smallest", "optional.bp", "Lowest BP", (base, bp) => {
 		base.scoreData.optional.bp = bp.scoreData.optional.bp;

server/src/lib/score-import/framework/pb/create-pb-doc.test.ts

@@ -13,7 +13,6 @@ import {
 } from "test-utils/test-data";
 import type { PBScoreDocumentNoRank } from "./create-pb-doc";
 import type { KtLogger } from "lib/logger/logger";
-import type { ScoreDocument } from "tachi-common";
 
 const IIDXScore = TestingIIDXSPScore;
 
@@ -231,6 +230,9 @@ t.test("#CreatePBDoc", (t) => {
 						bp: 15,
 						gauge: 12,
 						gaugeHistory: [20, 20, 21, 12],
+						gaugeHistoryEasy: [20, 20, 21, 13],
+						gaugeHistoryGroove: [20, 20, 21, 14],
+						gaugeHistoryHard: [20, 20, 21, 15],
 					},
 					enumIndexes: {
 						lamp: IIDX_LAMPS.FULL_COMBO,
@@ -254,6 +256,9 @@ t.test("#CreatePBDoc", (t) => {
 			{
 				gauge: 12,
 				gaugeHistory: [20, 20, 21, 12],
+				gaugeHistoryEasy: [20, 20, 21, 13],
+				gaugeHistoryGroove: [20, 20, 21, 14],
+				gaugeHistoryHard: [20, 20, 21, 15],
 			},
 			"Should select the lampPBs gauge data and not the score PBs."
 		);

server/src/lib/score-import/import-types/ir/lr2hook/converter.test.ts

@@ -4,6 +4,7 @@ import t from "tap";
 import { dmf } from "test-utils/misc";
 import ResetDBState from "test-utils/resets";
 import { TestingLR2HookScore } from "test-utils/test-data";
+import { ApplyNTimes } from "utils/misc";
 
 const logger = CreateLogCtx(__filename);
 
@@ -13,7 +14,84 @@ t.test("#ConverterLR2Hook", (t) => {
 	t.test("Should match a score with its song and chart.", async (t) => {
 		const res = await ConverterLR2Hook(
 			TestingLR2HookScore,
-			{ timeReceived: 10 },
+			{ timeReceived: 10_000 },
+			"ir/lr2hook",
+			logger
+		);
+
+		t.hasStrict(res, {
+			song: {
+				id: 27339,
+			},
+			chart: {
+				chartID: "88eb6cc5683e2740cbd07f588a5f3db1db8d467b",
+				data: {
+					hashMD5: TestingLR2HookScore.md5,
+				},
+			},
+			dryScore: {
+				timeAchieved: 10_000,
+				scoreData: {
+					score: TestingLR2HookScore.scoreData.exScore,
+					optional: {
+						bp: 56,
+						epg: undefined,
+						lpg: undefined,
+						egr: undefined,
+						lgr: undefined,
+						egd: undefined,
+						lgd: undefined,
+						ebd: undefined,
+						lbd: undefined,
+						epr: undefined,
+						lpr: undefined,
+						fast: undefined,
+						slow: undefined,
+					},
+				},
+				game: "bms",
+				importType: "ir/lr2hook",
+				scoreMeta: {
+					client: "LR2",
+				},
+			},
+		});
+
+		t.end();
+	});
+
+	t.test("Should use optional and extended properties.", async (t) => {
+		const res = await ConverterLR2Hook(
+			dmf(TestingLR2HookScore, {
+				scoreData: {
+					extendedJudgements: {
+						epg: 1,
+						lpg: 2,
+						egr: 3,
+						lgr: 4,
+						egd: 5,
+						lgd: 6,
+						ebd: 7,
+						lbd: 8,
+						epr: 9,
+						lpr: 10,
+						cb: 11,
+						fast: 12,
+						slow: 13,
+						notesPlayed: TestingLR2HookScore.scoreData.notesPlayed,
+					},
+					extendedHpGraphs: {
+						groove: ApplyNTimes(1000, () => 1),
+						hard: ApplyNTimes(1000, () => 2),
+						hazard: ApplyNTimes(1000, () => 3),
+						easy: ApplyNTimes(1000, () => 4),
+						pattack: ApplyNTimes(1000, () => 5),
+						gattack: ApplyNTimes(1000, () => 6),
+					},
+				},
+				unixTimestamp: 8,
+			} as any),
+			{ timeReceived: 10_000 },
 			"ir/lr2hook",
 			logger
 		);
@@ -29,10 +107,26 @@ t.test("#ConverterLR2Hook", (t) => {
 				},
 			},
 			dryScore: {
+				timeAchieved: 8_000,
 				scoreData: {
 					score: TestingLR2HookScore.scoreData.exScore,
 					optional: {
 						bp: 56,
+						epg: 1,
+						lpg: 2,
+						egr: 3,
+						lgr: 4,
+						egd: 5,
+						lgd: 6,
+						ebd: 7,
+						lbd: 8,
+						epr: 9,
+						lpr: 10,
+						fast: 12,
+						slow: 13,
+						gaugeHistoryGroove: ApplyNTimes(1000, () => 1),
+						gaugeHistoryHard: ApplyNTimes(1000, () => 2),
+						gaugeHistoryEasy: ApplyNTimes(1000, () => 4),
 					},
 				},
 				game: "bms",
@@ -50,7 +144,7 @@ t.test("#ConverterLR2Hook", (t) => {
 		const res = await ConverterLR2Hook(
 			dmf(TestingLR2HookScore, {
 				scoreData: {
-					notesPlayed: 10,
+					notesPlayed: TestingLR2HookScore.scoreData.notesTotal - 1,
 				},
 			} as any),
 			{ timeReceived: 10 },
@@ -86,6 +180,52 @@ t.test("#ConverterLR2Hook", (t) => {
 		t.end();
 	});
 
+	t.test(
+		"Should calculate BP if the score was exited early but there is extendedJudgements.",
+		async (t) => {
+			const res = await ConverterLR2Hook(
+				dmf(TestingLR2HookScore, {
+					scoreData: {
+						notesPlayed: TestingLR2HookScore.scoreData.notesTotal - 1,
+						extendedJudgements: {
+							notesPlayed: TestingLR2HookScore.scoreData.notesTotal - 1,
+						},
+					},
+				} as any),
+				{ timeReceived: 10 },
+				"ir/lr2hook",
+				logger
+			);
+
+			t.hasStrict(res, {
+				song: {
+					id: 27339,
+				},
+				chart: {
+					chartID: "88eb6cc5683e2740cbd07f588a5f3db1db8d467b",
+					data: {
+						hashMD5: TestingLR2HookScore.md5,
+					},
+				},
+				dryScore: {
+					scoreData: {
+						score: TestingLR2HookScore.scoreData.exScore,
+						optional: {
+							bp: 57,
+						},
+					},
+					game: "bms",
+					importType: "ir/lr2hook",
+					scoreMeta: {
+						client: "LR2",
+					},
+				},
+			});
+
+			t.end();
+		}
+	);
+
 	t.test("Should throw an error if song or chart can't be found.", (t) => {
 		t.rejects(
 			() =>