[chunithm] split lamp into combo lamp and clear lamp (#1269)

* [chunithm] split lamp into combo lamp and clear lamp

* ignore nonsense lint

* fix myt converter tests

* fix chunitachi batch manual

* mfw edited wrong file

* fix(migration): only migrate lamp-related showcases

* remove chart lamp showcases

* remove unused imports

* fix: limit re-pb to chunithm scores, migrate chart lamp showcases to comboLamp

* fix migration of comboLamp progress

* fix: updateMany with multi: true

* fix: when updating references, ensure only known IDs are in

* fix(client): make red stand out more

* fix(client): lamp sorting

* feat(server): validate clear and combo lamps based on judgements

* fix(server): validate combo lamps based on score boundary

* fix: reword validation errors to stay consistent

* fix: correct explanation

* fix: how was I this stupid?

* fix: update blacklisted scores too

* fix: bulk write all the updates

* fix: bulkWrite harder

* fix: i probably need sleep

* all of game-settings to bulkWrite

* fix folder lamp goal nonsense

* maybe fix colors

* fix: name PB merges

* chore: properly test PB merge

* mfw reversed

* fix(SessionRaiseBreakdown): lamp name

* rename to noteLamp

* why is eslint even complaining here?

* rename the enums

* fix tests

* tweak colors of lamps

Author: beer-psi

client/src/components/sessions/SessionRaiseBreakdown.tsx

@@ -49,7 +49,7 @@ export default function SessionRaiseBreakdown({
 }) {
 	const game = sessionData.session.game;
 	const playtype = sessionData.session.playtype;
-	const lampName = game === "ongeki" ? "noteLamp" : "lamp";
+	const lampName = game === "ongeki" || game === "chunithm" ? "noteLamp" : "lamp";
 
 	const { user } = useContext(UserContext);
 

client/src/components/tables/cells/CHUNITHMLampCell.tsx

@@ -0,0 +1,49 @@
+import { ChangeOpacity } from "util/color-opacity";
+import React from "react";
+import { GetEnumValue } from "tachi-common/types/metrics";
+
+export default function CHUNITHMLampCell({
+	noteLamp,
+	clearLamp,
+	noteLampColour,
+	clearLampColour,
+}: {
+	clearLamp: GetEnumValue<"chunithm:Single", "clearLamp">;
+	noteLamp: GetEnumValue<"chunithm:Single", "noteLamp">;
+	noteLampColour: string;
+	clearLampColour: string;
+}) {
+	let content = <div>{clearLamp}</div>;
+	let background = ChangeOpacity(clearLampColour, 0.2);
+
+	if (noteLamp !== "NONE") {
+		background = ChangeOpacity(noteLampColour, 0.2);
+
+		if (clearLamp === "CLEAR") {
+			content = <div>{noteLamp}</div>;
+		} else {
+			const clearLampLow = ChangeOpacity(clearLampColour, 0.2);
+			const noteLampLow = ChangeOpacity(noteLampColour, 0.2);
+
+			background = `linear-gradient(-45deg, ${clearLampLow} 0%, ${clearLampLow} 12%, ${noteLampLow} 12%, ${noteLampLow} 100%)`;
+
+			content = (
+				<span>
+					<div>{noteLamp}</div>
+					<div>{clearLamp}</div>
+				</span>
+			);
+		}
+	}
+
+	return (
+		<td
+			style={{
+				background,
+				whiteSpace: "nowrap",
+			}}
+		>
+			<strong>{content}</strong>
+		</td>
+	);
+}

client/src/lib/game-implementations.tsx

@@ -20,6 +20,7 @@ import OngekiJudgementCell from "components/tables/cells/OngekiJudgementCell";
 import React from "react";
 import OngekiLampCell from "components/tables/cells/OngekiLampCell";
 import OngekiPlatinumCell from "components/tables/cells/OngekiPlatinumCell";
+import CHUNITHMLampCell from "components/tables/cells/CHUNITHMLampCell";
 import { bgc, RAINBOW_EX_GRADIENT, RAINBOW_GRADIENT } from "./games/_util";
 import { BMS_14K_IMPL, BMS_7K_IMPL, PMS_IMPL } from "./games/bms-pms";
 import { IIDX_DP_IMPL, IIDX_SP_IMPL } from "./games/iidx";
@@ -45,7 +46,11 @@ export const GPT_CLIENT_IMPLEMENTATIONS: GPTClientImplementations = {
 	"ddr:DP": DDR_DP_IMPL,
 	"chunithm:Single": {
 		sessionImportantScoreCount: 50,
-		enumIcons: defaultEnumIcons,
+		enumIcons: {
+			grade: "sort-alpha-up",
+			clearLamp: "lightbulb",
+			noteLamp: "lightbulb",
+		},
 		classColours: {
 			colour: {
 				BLUE: bgc("var(--bs-info)", "var(--bs-light)"),
@@ -99,10 +104,17 @@ export const GPT_CLIENT_IMPLEMENTATIONS: GPTClientImplementations = {
 				SSS: COLOUR_SET.teal,
 				"SSS+": COLOUR_SET.white,
 			},
-			lamp: {
-				FAILED: COLOUR_SET.red,
-				CLEAR: COLOUR_SET.paleGreen,
-				"FULL COMBO": COLOUR_SET.paleBlue,
+			clearLamp: {
+				FAILED: COLOUR_SET.vibrantRed,
+				CLEAR: COLOUR_SET.green,
+				HARD: "#E12AFB",
+				BRAVE: "#A21CAF",
+				ABSOLUTE: "#701A75",
+				CATASTROPHY: "#4A044E",
+			},
+			noteLamp: {
+				NONE: COLOUR_SET.gray,
+				"FULL COMBO": COLOUR_SET.darkGreen,
 				"ALL JUSTICE": COLOUR_SET.gold,
 				"ALL JUSTICE CRITICAL": COLOUR_SET.white,
 			},
@@ -118,7 +130,14 @@ export const GPT_CLIENT_IMPLEMENTATIONS: GPTClientImplementations = {
 		scoreHeaders: [
 			["Score", "Score", NumericSOV((x) => x.scoreData.score)],
 			["Judgements", "Hits", NumericSOV((x) => x.scoreData.score)],
-			["Lamp", "Lamp", NumericSOV((x) => x.scoreData.enumIndexes.lamp)],
+			[
+				"Lamp",
+				"Lamp",
+				NumericSOV(
+					(x) =>
+						(x.scoreData.enumIndexes.noteLamp << 3) + x.scoreData.enumIndexes.clearLamp
+				),
+			],
 		],
 		scoreCoreCells: ({ sc }) => (
 			<>
@@ -128,7 +147,12 @@ export const GPT_CLIENT_IMPLEMENTATIONS: GPTClientImplementations = {
 					colour={GetEnumColour(sc, "grade")}
 				/>
 				<CHUNITHMJudgementCell score={sc} />
-				<LampCell lamp={sc.scoreData.lamp} colour={GetEnumColour(sc, "lamp")} />
+				<CHUNITHMLampCell
+					clearLamp={sc.scoreData.clearLamp}
+					noteLamp={sc.scoreData.noteLamp}
+					clearLampColour={GetEnumColour(sc, "clearLamp")}
+					noteLampColour={GetEnumColour(sc, "noteLamp")}
+				/>
 			</>
 		),
 		ratingCell: ({ sc, rating }) => <RatingCell score={sc} rating={rating} />,

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

@@ -51,9 +51,15 @@ export const CHUNITHM_SINGLE_CONF = {
 			formatter: FmtNum,
 			description: "The score value. This is between 0 and 1.01 million.",
 		},
-		lamp: {
+		noteLamp: {
 			type: "ENUM",
-			values: ["FAILED", "CLEAR", "FULL COMBO", "ALL JUSTICE", "ALL JUSTICE CRITICAL"],
+			values: ["NONE", "FULL COMBO", "ALL JUSTICE", "ALL JUSTICE CRITICAL"],
+			minimumRelevantValue: "FULL COMBO",
+			description: "The type of combo this was.",
+		},
+		clearLamp: {
+			type: "ENUM",
+			values: ["FAILED", "CLEAR", "HARD", "BRAVE", "ABSOLUTE", "CATASTROPHY"],
 			minimumRelevantValue: "CLEAR",
 			description: "The type of clear this was.",
 		},

common/src/constants/game.ts

@@ -9,12 +9,20 @@ export enum IIDX_LAMPS {
 	FULL_COMBO = 7,
 }
 
-export enum CHUNITHM_LAMPS {
+export enum CHUNITHM_CLEAR_LAMPS {
 	FAILED = 0,
 	CLEAR = 1,
-	FULL_COMBO = 2,
-	ALL_JUSTICE = 3,
-	ALL_JUSTICE_CRITICAL = 4,
+	HARD = 2,
+	BRAVE = 3,
+	ABSOLUTE = 4,
+	CATASTROPHY = 5,
+}
+
+export enum CHUNITHM_NOTE_LAMPS {
+	NONE = 0,
+	FULL_COMBO = 1,
+	ALL_JUSTICE = 2,
+	ALL_JUSTICE_CRITICAL = 3,
 }
 
 export enum SDVX_LAMPS {

server/src/game-implementations/games/chunithm.test.ts

@@ -2,27 +2,30 @@ import { CHUNITHM_IMPL } from "./chunithm";
 import db from "external/mongo/db";
 import CreateLogCtx from "lib/logger/logger";
 import { CreatePBDoc } from "lib/score-import/framework/pb/create-pb-doc";
-import { CHUNITHM_GRADES, CHUNITHM_LAMPS } from "tachi-common";
+import { CHUNITHM_GRADES, CHUNITHM_NOTE_LAMPS, CHUNITHM_CLEAR_LAMPS } from "tachi-common";
 import t from "tap";
 import { dmf, mkMockPB, mkMockScore } from "test-utils/misc";
 import ResetDBState from "test-utils/resets";
 import { CHUNITHMBBKKChart, TestingChunithmScorePB } from "test-utils/test-data";
 import type { ProvidedMetrics, ScoreData } from "tachi-common";
 
 const baseMetrics: ProvidedMetrics["chunithm:Single"] = {
-	lamp: "CLEAR",
+	clearLamp: "CLEAR",
+	noteLamp: "NONE",
 	score: 1_003_000,
 };
 
 const scoreData: ScoreData<"chunithm:Single"> = {
-	lamp: "CLEAR",
+	clearLamp: "CLEAR",
+	noteLamp: "NONE",
 	score: 1_003_000,
 	grade: "SS",
 	judgements: {},
 	optional: { enumIndexes: {} },
 	enumIndexes: {
 		grade: CHUNITHM_GRADES.SS,
-		lamp: CHUNITHM_LAMPS.CLEAR,
+		clearLamp: CHUNITHM_CLEAR_LAMPS.CLEAR,
+		noteLamp: CHUNITHM_NOTE_LAMPS.NONE,
 	},
 };
 
@@ -165,7 +168,8 @@ t.test("CHUNITHM Implementation", (t) => {
 
 			f("grade", { grade: "S+", score: 997_342 }, CHUNITHM_GRADES.SS, "SS-2.7K");
 			f("score", { score: 982_123 }, 1_000_000, "982,123");
-			f("lamp", { lamp: "CLEAR" }, CHUNITHM_LAMPS.CLEAR, "CLEAR");
+			f("clearLamp", { clearLamp: "CLEAR" }, CHUNITHM_CLEAR_LAMPS.CLEAR, "CLEAR");
+			f("noteLamp", { noteLamp: "FULL COMBO" }, CHUNITHM_NOTE_LAMPS.FULL_COMBO, "FULL COMBO");
 
 			t.end();
 		});
@@ -187,21 +191,39 @@ t.test("CHUNITHM Implementation", (t) => {
 			await db.scores.insert(mockScore);
 			await db.scores.insert(
 				dmf(mockScore, {
-					scoreID: "bestLamp",
+					scoreID: "bestNoteLamp",
 					scoreData: {
 						score: 0,
-						lamp: "FULL COMBO",
-						enumIndexes: { lamp: CHUNITHM_LAMPS.FULL_COMBO },
+						noteLamp: "FULL COMBO",
+						enumIndexes: { noteLamp: CHUNITHM_NOTE_LAMPS.FULL_COMBO },
+					},
+				})
+			);
+			await db.scores.insert(
+				dmf(mockScore, {
+					scoreID: "bestClearLamp",
+					scoreData: {
+						score: 0,
+						clearLamp: "ABSOLUTE",
+						enumIndexes: { clearLamp: CHUNITHM_CLEAR_LAMPS.ABSOLUTE },
 					},
 				})
 			);
 
 			t.hasStrict(await CreatePBDoc("chunithm:Single", 1, CHUNITHMBBKKChart, logger), {
-				composedFrom: [{ name: "Best Score" }, { name: "Best Lamp", scoreID: "bestLamp" }],
+				composedFrom: [
+					{ name: "Best Score" },
+					{ name: "Best Note Lamp", scoreID: "bestNoteLamp" },
+					{ name: "Best Clear Lamp", scoreID: "bestClearLamp" },
+				],
 				scoreData: {
 					score: mockScore.scoreData.score,
-					lamp: "FULL COMBO",
-					enumIndexes: { lamp: CHUNITHM_LAMPS.FULL_COMBO },
+					clearLamp: "ABSOLUTE",
+					noteLamp: "FULL COMBO",
+					enumIndexes: {
+						clearLamp: CHUNITHM_CLEAR_LAMPS.ABSOLUTE,
+						noteLamp: CHUNITHM_NOTE_LAMPS.FULL_COMBO,
+					},
 				},
 			});
 

server/src/game-implementations/games/chunithm.ts

@@ -71,28 +71,45 @@ export const CHUNITHM_IMPL: GPTServerImplementation<"chunithm:Single"> = {
 				pb.scoreData.score,
 				CHUNITHM_GBOUNDARIES[gradeIndex]!.name
 			),
-
-		lamp: (pb) => pb.scoreData.lamp,
+		noteLamp: (pb) => pb.scoreData.noteLamp,
+		clearLamp: (pb) => pb.scoreData.clearLamp,
 		score: (pb) => FmtNum(pb.scoreData.score),
 	},
 	goalOutOfFormatters: {
 		score: GoalOutOfFmtScore,
 	},
 	pbMergeFunctions: [
-		CreatePBMergeFor("largest", "enumIndexes.lamp", "Best Lamp", (base, score) => {
-			base.scoreData.lamp = score.scoreData.lamp;
+		CreatePBMergeFor("largest", "enumIndexes.noteLamp", "Best Note Lamp", (base, score) => {
+			base.scoreData.noteLamp = score.scoreData.noteLamp;
+		}),
+		CreatePBMergeFor("largest", "enumIndexes.clearLamp", "Best Clear Lamp", (base, score) => {
+			base.scoreData.clearLamp = score.scoreData.clearLamp;
 		}),
 	],
 	defaultMergeRefName: "Best Score",
 	scoreValidators: [
 		(s) => {
-			if (s.scoreData.lamp === "ALL JUSTICE CRITICAL" && s.scoreData.score !== 1_010_000) {
+			if (
+				s.scoreData.noteLamp === "ALL JUSTICE CRITICAL" &&
+				s.scoreData.score !== 1_010_000
+			) {
 				return "An ALL JUSTICE CRITICAL must have a score of 1.01 million.";
 			}
 
-			if (s.scoreData.lamp !== "ALL JUSTICE CRITICAL" && s.scoreData.score === 1_010_000) {
+			if (
+				s.scoreData.noteLamp !== "ALL JUSTICE CRITICAL" &&
+				s.scoreData.score === 1_010_000
+			) {
 				return "A score of 1.01 million must have a lamp of ALL JUSTICE CRITICAL.";
 			}
+
+			if (s.scoreData.noteLamp === "ALL JUSTICE" && s.scoreData.score < 1_000_000) {
+				return `A score of ${s.scoreData.score} cannot be an ALL JUSTICE.`;
+			}
+
+			if (s.scoreData.noteLamp === "FULL COMBO" && s.scoreData.score < 500_000) {
+				return `A score of ${s.scoreData.score} cannot be a FULL COMBO.`;
+			}
 		},
 		(s) => {
 			let { attack, justice, miss } = s.scoreData.judgements;
@@ -101,23 +118,73 @@ export const CHUNITHM_IMPL: GPTServerImplementation<"chunithm:Single"> = {
 			attack ??= 0;
 			miss ??= 0;
 
-			if (s.scoreData.lamp === "ALL JUSTICE CRITICAL") {
+			if (s.scoreData.noteLamp === "ALL JUSTICE CRITICAL") {
 				if (attack + justice + miss > 0) {
 					return "Cannot have an ALL JUSTICE CRITICAL with any non-jcrit judgements.";
 				}
 			}
 
-			if (s.scoreData.lamp === "ALL JUSTICE") {
+			if (s.scoreData.noteLamp === "ALL JUSTICE") {
 				if (attack + miss > 0) {
 					return "Cannot have an ALL JUSTICE if not all hits were justice or better.";
 				}
 			}
 
-			if (s.scoreData.lamp === "FULL COMBO") {
+			if (s.scoreData.noteLamp === "FULL COMBO") {
 				if (miss > 0) {
 					return "Cannot have a FULL COMBO if the score has misses.";
 				}
 			}
 		},
+		(s) => {
+			const { maxCombo } = s.scoreData.optional;
+			const { attack, jcrit, justice, miss } = s.scoreData.judgements;
+
+			if (
+				IsNullish(maxCombo) ||
+				IsNullish(attack) ||
+				IsNullish(jcrit) ||
+				IsNullish(justice) ||
+				IsNullish(miss)
+			) {
+				return;
+			}
+
+			if (s.scoreData.noteLamp !== "NONE" && jcrit + justice + attack + miss !== maxCombo) {
+				const article = s.scoreData.noteLamp === "FULL COMBO" ? "a" : "an";
+
+				return `Cannot have ${article} ${s.scoreData.noteLamp} if maxCombo is not equal to the sum of judgements.`;
+			}
+		},
+		(s) => {
+			const { attack, justice, miss } = s.scoreData.judgements;
+
+			// Assume the clear lamp is correct if judgements aren't provided.
+			if (IsNullish(attack) || IsNullish(justice) || IsNullish(miss)) {
+				return;
+			}
+
+			if (s.scoreData.clearLamp === "CATASTROPHY" && justice + attack + miss >= 10) {
+				return "Cannot have a CATASTROPHY clear with 10 or more non-jcrit judgements.";
+			}
+
+			if (s.scoreData.clearLamp === "ABSOLUTE" && justice + attack + miss >= 50) {
+				return "Cannot have an ABSOLUTE clear with 50 or more non-jcrit judgements.";
+			}
+
+			if (s.scoreData.clearLamp === "BRAVE" && justice + attack + miss >= 150) {
+				return "Cannot have a BRAVE clear with 150 or more non-jcrit judgements.";
+			}
+
+			// The condition for a HARD clear varies based on the skill used:
+			// - JUDGE: 20 misses
+			// - JUDGE+: 10 misses
+			// - EMBLEM: 300 justices or below
+			// Since we do not have information about the skill used, we simply validate that a
+			// hard clear is not completely impossible, i.e. more than 20 misses and more than 300 justices.
+			if (s.scoreData.clearLamp === "HARD" && justice + attack + miss >= 300 && miss >= 20) {
+				return "Cannot have a HARD clear with 300 or more non-jcrit judgements, and over 20 misses.";
+			}
+		},
 	],
 };