games: Add checkword, mods, and allow nesting command files

Author: PartMan7

src/i18n/english.ts

@@ -36,7 +36,7 @@ export default {
 		INVALID_SIDE: 'Invalid side chosen! Valid sides are: {{sides}}',
 		IN_PROGRESS: 'This game is already in progress. Weeb.',
 		IS_FULL: 'The game has no more space for players.',
-		NOT_FOUND: 'Could not find the game you meant...',
+		NOT_FOUND: "Couldn't find the game you meant...",
 		NOT_PLAYING: [
 			"You're not a player!",
 			"You're not playing, weeb.",
@@ -59,6 +59,9 @@ export default {
 		NON_PLAYER_OR_SPEC: 'User not in players/spectators',
 		YOUR_TURN: 'Your turn!',
 		UPLOAD_FAILED: 'Failed to upload game {{id}}.',
+		MOD_NOT_FOUND: "Could not find a mod called '{{mod}}'.",
+		CANNOT_MOD: 'Mods cannot be applied to this game now.',
+		APPLIED_MOD: '{{mod}} has been applied to game {{id}}.',
 		TIMER: {
 			PRIVATE: "Psst it's your turn to play in {{game}} [{{id}}]",
 			PUBLIC: "{{user}} hasn't played in {{game}} [{{id}}] for {{time}}...",
@@ -79,7 +82,9 @@ export default {
 			FIRST_MOVE_MULTIPLE_TILES: 'You may not play a single tile on the first move.',
 			MUST_BE_CONNECTED: 'All moves in Scrabble must be connected to the rest of the tiles on the board!',
 			MUST_PLAY_TILES: 'Your move must play at least one tile.',
-			INVALID_WORD: '{{word}} is not a valid word.',
+			INVALID_WORD: '{{wordList}} is not a valid word.',
+			INVALID_WORDS: '{{wordList}} are not valid words.',
+			VALID_WORD: '{{word}} is a valid word in {{mod}}.',
 			HOW_TO_BLANK:
 				"Hi, you've drawn a blank tile! A blank tile can be used as any letter, but the tile awards 0 points. You can type `BL[A]NK` (for example) to use the blank as an A. Other syntaxes supported are `BL(A)NK`, or adding an apostrophe after the blanked letter (eg: `BLA'NK`).",
 		},

src/ps/commands/games.tsx src/ps/commands/games/core.tsxsrc/ps/commands/games.tsx renamed to src/ps/commands/games/core.tsx

@@ -2,6 +2,7 @@ import { PSGames } from '@/cache';
 import { gameCache } from '@/cache/games';
 import { Games } from '@/ps/games';
 import { renderBackups, renderMenu } from '@/ps/games/menus';
+import { parseMod } from '@/ps/games/mods';
 import { generateId } from '@/ps/games/utils';
 import { toId } from '@/tools';
 import { ChatError } from '@/utils/chatError';
@@ -11,7 +12,6 @@ import type { BaseGame } from '@/ps/games/game';
 import type { PSCommand } from '@/types/chat';
 import type { Room } from 'ps-client';
 import type { HTMLopts } from 'ps-client/classes/common';
-import type { ReactElement } from 'react';
 
 type SearchContext =
 	| { action: 'start'; user: string }
@@ -23,11 +23,12 @@ type SearchContext =
 	| { action: 'sub'; user1?: string; user2?: string }
 	| { action: 'watch'; user: string }
 	| { action: 'unwatch'; user: string }
+	| { action: 'mod'; user: string }
 	| { action: 'any' };
 
 type RoomContext = { room: Room; $T: TranslationFn };
 
-const gameCommands = Object.entries(Games).map(([_gameId, Game]): PSCommand => {
+export const command: PSCommand[] = Object.entries(Games).map(([_gameId, Game]): PSCommand => {
 	const gameId = _gameId as keyof Games;
 
 	type GameFilter = (game: BaseGame) => boolean;
@@ -62,6 +63,8 @@ const gameCommands = Object.entries(Games).map(([_gameId, Game]): PSCommand => {
 					return game.started && !hasJoined && !game.spectators.includes(ctx.user);
 				case 'unwatch':
 					return game.started && !hasJoined && game.spectators.includes(ctx.user);
+				case 'mod':
+					return game.moddable?.() ?? false;
 				default:
 					return true;
 			}
@@ -384,6 +387,24 @@ const gameCommands = Object.entries(Games).map(([_gameId, Game]): PSCommand => {
 					message.reply(`/closehtmlpage ${message.author.id}, ${game.id}` as NoTranslate);
 				},
 			},
+			...(Game.meta.mods
+				? ({
+						mod: {
+							name: 'mod',
+							aliases: ['#'],
+							help: 'Modifies a given game.',
+							syntax: 'CMD [game ref] (mod)',
+							async run({ message, arg, $T }) {
+								const { game, ctx } = getGame(arg, { action: 'mod', user: message.author.id }, { room: message.target, $T });
+								if (!game.moddable?.() || !game.applyMod) throw new ChatError($T('GAME.CANNOT_MOD'));
+								const mod = parseMod(ctx, Game.meta.mods!.list, Game.meta.mods!.data);
+								if (!mod) throw new ChatError($T('GAME.MOD_NOT_FOUND', { mod: ctx }));
+								const applied = game.applyMod(mod);
+								if (applied.success) message.reply(applied.data);
+							},
+						},
+					} satisfies PSCommand['children'])
+				: {}),
 			menu: {
 				name: 'menu',
 				aliases: ['m', 'list'],
@@ -453,54 +474,3 @@ const gameCommands = Object.entries(Games).map(([_gameId, Game]): PSCommand => {
 		},
 	};
 });
-
-const metaCommands: PSCommand = {
-	name: 'games',
-	help: 'Metacommands for games.',
-	syntax: 'CMD [menu]',
-	perms: Symbol.for('games.manage'),
-	async run({ run }) {
-		return run('games menu');
-	},
-	children: {
-		menu: {
-			name: 'menu',
-			aliases: ['list', 'm'],
-			help: 'Displays a menu of all games currently active.',
-			syntax: 'CMD',
-			async run({ message, broadcastHTML }) {
-				const Menu = ({ staff }: { staff?: boolean }): ReactElement => (
-					<>
-						<hr />
-						{Object.values(Games)
-							.map(Game => (
-								<>
-									<h3>{Game.meta.name}</h3>
-									{renderMenu(message.target, Game.meta, !!staff)}
-								</>
-							))
-							.space(<hr />)}
-						<br />
-						<hr />
-					</>
-				);
-				const opts: HTMLopts = { name: 'games-menu' };
-				broadcastHTML(<Menu />, opts);
-				message.target.sendHTML(<Menu staff />, { ...opts, rank: '%' });
-			},
-		},
-	},
-};
-
-export const command: PSCommand[] = [
-	...gameCommands,
-	metaCommands,
-	{
-		name: 'othellosequence',
-		help: 'Sequence of fastest game in Othello.',
-		syntax: 'CMD',
-		async run({ broadcastHTML }) {
-			broadcastHTML([['e6', 'f4'], ['e3', 'f6'], ['g5', 'd6'], ['e7', 'f5'], ['c5']].map(turns => turns.join(', ')).join('<br />'));
-		},
-	},
-];

src/ps/commands/games/meta.tsx

@@ -0,0 +1,44 @@
+import { Games } from '@/ps/games';
+import { renderMenu } from '@/ps/games/menus';
+
+import type { PSCommand } from '@/types/chat';
+import type { HTMLopts } from 'ps-client/classes/common';
+import type { ReactElement } from 'react';
+
+export const command: PSCommand = {
+	name: 'games',
+	help: 'Metacommands for games.',
+	syntax: 'CMD [menu]',
+	perms: Symbol.for('games.manage'),
+	async run({ run }) {
+		return run('games menu');
+	},
+	children: {
+		menu: {
+			name: 'menu',
+			aliases: ['list', 'm'],
+			help: 'Displays a menu of all games currently active.',
+			syntax: 'CMD',
+			async run({ message, broadcastHTML }) {
+				const Menu = ({ staff }: { staff?: boolean }): ReactElement => (
+					<>
+						<hr />
+						{Object.values(Games)
+							.map(Game => (
+								<>
+									<h3>{Game.meta.name}</h3>
+									{renderMenu(message.target, Game.meta, !!staff)}
+								</>
+							))
+							.space(<hr />)}
+						<br />
+						<hr />
+					</>
+				);
+				const opts: HTMLopts = { name: 'games-menu' };
+				broadcastHTML(<Menu />, opts);
+				message.target.sendHTML(<Menu staff />, { ...opts, rank: '%' });
+			},
+		},
+	},
+};

src/ps/commands/games/other.tsx

@@ -0,0 +1,33 @@
+import { parseMod } from '@/ps/games/mods';
+import { checkWord } from '@/ps/games/scrabble/checker';
+import { ScrabbleMods } from '@/ps/games/scrabble/constants';
+import { ScrabbleModData } from '@/ps/games/scrabble/mods';
+import { toId } from '@/tools';
+import { ChatError } from '@/utils/chatError';
+
+import type { PSCommand } from '@/types/chat';
+
+export const command: PSCommand[] = [
+	{
+		name: 'checkword',
+		help: 'Checks the legality of a word according to the Scrabble dictionary.',
+		syntax: 'CMD word[, mod]',
+		aliases: ['cw'],
+		async run({ broadcast, arg, $T }) {
+			const [word, input = ScrabbleMods.CSW21] = arg.lazySplit(',', 1);
+			const mod = parseMod(input, ScrabbleMods, ScrabbleModData);
+			if (!mod) throw new ChatError($T('GAME.MOD_NOT_FOUND', { mod: input }));
+			const check = checkWord(word, mod);
+			if (!check) broadcast($T('GAME.SCRABBLE.INVALID_WORD', { wordList: word }));
+			else broadcast($T('GAME.SCRABBLE.VALID_WORD', { word: toId(word).toUpperCase(), mod: ScrabbleModData[mod].name }));
+		},
+	},
+	{
+		name: 'othellosequence',
+		help: 'Sequence of fastest game in Othello.',
+		syntax: 'CMD',
+		async run({ broadcastHTML }) {
+			broadcastHTML([['e6', 'f4'], ['e3', 'f6'], ['g5', 'd6'], ['e7', 'f5'], ['c5']].map(turns => turns.join(', ')).join('<br />'));
+		},
+	},
+];

src/ps/games/common.ts

@@ -1,23 +1,26 @@
 import type { TranslatedText } from '@/i18n/types';
+import type { ModData, ModEnum } from '@/ps/games/mods';
 import type { Satisfies } from '@/types/common';
 
-export type Meta = {
+export type Meta = Readonly<{
 	name: string;
 	id: GamesList;
 	aliases?: readonly string[];
 	/** Only for single-player games. Required for those. */
 	abbr?: string;
 
 	players: 'single' | 'many';
-	turns?: Record<string, string>;
+	turns?: Readonly<Record<string, string>>;
 	minSize?: number;
 	maxSize?: number;
 
+	mods?: Readonly<{ list: ModEnum<string>; data: ModData<string> }>;
+
 	/** @default Assume true */
 	autostart?: boolean;
 	timer?: number | false;
 	pokeTimer?: number | false | undefined;
-};
+}>;
 
 export enum GamesList {
 	Othello = 'othello',

src/ps/games/game.ts

@@ -86,6 +86,8 @@ export class Game<State extends BaseState> {
 		return 'Game ended';
 	}
 	trySkipPlayer?(turn: BaseState['turn']): boolean;
+	moddable?(): boolean;
+	applyMod?(mod: string): ActionResponse<TranslatedText>;
 
 	throw(msg?: Parameters<TranslationFn>[0], vars?: Parameters<TranslationFn>[1]): never {
 		if (!msg) throw new ChatError(this.$T('GAME.INVALID_INPUT'));
@@ -218,6 +220,7 @@ export class Game<State extends BaseState> {
 			if (staffHTML) this.room.sendHTML(staffHTML, { name: this.id, rank: '+', change: true });
 		}
 	}
+	// TODO: Handle max players state
 	renderCloseSignups?(): ReactElement;
 	closeSignups(change = true): void {
 		const closeSignupsHTML = (this.renderCloseSignups ?? renderCloseSignups).bind(this)();
@@ -293,7 +296,7 @@ export class Game<State extends BaseState> {
 		return {
 			success: true,
 			data: {
-				message: (staffAction ? `${player.name} has been removed from the game.` : 'You have left the game') as ToTranslate,
+				message: (staffAction ? `${player.name} has been removed from the game.` : 'You have left the game.') as ToTranslate,
 			},
 		};
 	}

src/ps/games/index.ts

@@ -1,4 +1,4 @@
-import { GamesList } from '@/ps/games/common';
+import { GamesList, type Meta } from '@/ps/games/common';
 import { ConnectFour, meta as ConnectFourMeta } from '@/ps/games/connectfour';
 import { Mastermind, meta as MastermindMeta } from '@/ps/games/mastermind';
 import { Othello, meta as OthelloMeta } from '@/ps/games/othello';
@@ -21,5 +21,5 @@ export const Games = {
 		meta: ScrabbleMeta,
 		instance: Scrabble,
 	},
-};
+} satisfies Readonly<Record<GamesList, Readonly<{ meta: Meta; instance: unknown }>>>;
 export type Games = typeof Games;

src/ps/games/mods.ts

@@ -0,0 +1,16 @@
+import { toId } from '@/tools';
+
+export type ModEnum<Mod extends string> = Record<string, Mod>;
+export type ModData<Mod extends string> = Partial<Record<Mod, { aliases?: string[] | undefined }>>;
+
+export function parseMod<Mod extends string>(input: string, mods: ModEnum<Mod>, modData: ModData<Mod>): Mod | null {
+	const query = toId(input);
+	if (!query || query === 'constructor') return null;
+	const direct = Object.values(mods).find(mod => mod === query);
+	if (direct) return direct;
+	for (const _mod in modData) {
+		const mod = _mod as Mod;
+		if (modData[mod]?.aliases?.includes(query)) return mod;
+	}
+	return null;
+}

src/ps/games/scrabble/checker.ts

@@ -0,0 +1,38 @@
+import { abilities, items, moves, pokedex } from 'ps-client/data';
+
+import { Dictionaries, ScrabbleMods } from '@/ps/games/scrabble/constants';
+import { CRAZYMONS_SCORING, POKEMON_SCORING, ScrabbleModData } from '@/ps/games/scrabble/mods';
+
+import type { WordScore } from '@/ps/games/scrabble/types';
+
+function isPokeWord(word: string): boolean {
+	if (word in abilities) return true;
+	if (word in items) return true;
+	if (word in moves) return true;
+	if (word in pokedex) return true;
+	return false;
+}
+
+export function checkWord(word: string, appliedMod: ScrabbleMods | null): WordScore | null {
+	const mod = appliedMod ?? ScrabbleMods.CSW21;
+	const modData = ScrabbleModData[mod];
+	const dictionary = Dictionaries[modData.dict];
+	if (!dictionary) throw new Error(`Unrecognized dictionary ${modData.dict}`);
+	let query = word.toLowerCase();
+	switch (mod) {
+		case ScrabbleMods.POKEMON:
+		case ScrabbleMods.CRAZYMONS: {
+			if (isPokeWord(query)) {
+				if (mod === ScrabbleMods.POKEMON) return POKEMON_SCORING;
+				if (mod === ScrabbleMods.CRAZYMONS) return CRAZYMONS_SCORING;
+			}
+			break;
+		}
+		case ScrabbleMods.CLABBERS: {
+			query = query.split('').sort().join('');
+			break;
+		}
+	}
+	if (query in dictionary) return [1, 0];
+	return null;
+}

src/ps/games/scrabble/constants.ts

@@ -105,3 +105,11 @@ export const Dictionaries = {
 	[DICTIONARY.CLABBERS]: Clabbers,
 	// TypeScript gets its pants in a twirl here with JSON stuff
 } as unknown as Record<DICTIONARY, Record<string, boolean>>;
+
+export enum ScrabbleMods {
+	CSW19 = 'csw19',
+	CSW21 = 'csw21',
+	CLABBERS = 'clabbers',
+	POKEMON = 'pokemon',
+	CRAZYMONS = 'crazymons',
+}