boardgame-core/src/core/game.ts

import { MutableSignal, mutableSignal } from "@/utils/mutable-signal";
import {
  Command,
  CommandRegistry,
  CommandResult,
  CommandRunnerContextExport,
  CommandSchema,
  createCommandRegistry,
  createCommandRunnerContext,
  parseCommandSchema,
} from "@/utils/command";
import { PromptValidator } from "@/utils/command/command-runner";
import { Mulberry32RNG, ReadonlyRNG, RNG } from "@/utils/rng";

export interface IGameContext<TState extends Record<string, unknown> = {}> {
  get value(): TState;
  get rng(): ReadonlyRNG;
  produce(fn: (draft: TState) => void): void;
  produceAsync(fn: (draft: TState) => void): Promise<void>;
  run<T>(input: string): Promise<CommandResult<T>>;
  runParsed<T>(command: Command): Promise<CommandResult<T>>;
  prompt: <TResult, TArgs extends any[] = any[]>(
    def: PromptDef<TArgs>,
    validator: PromptValidator<TResult, TArgs>,
    currentPlayer?: string | null,
  ) => Promise<TResult>;

  // test only
  _state: MutableSignal<TState>;
  _commands: CommandRunnerContextExport<IGameContext<TState>>;
  _rng: RNG;
}
export type IGameContextExport<TState extends Record<string, unknown> = {}> =
  Omit<IGameContext<TState>, "_state" | "_commands" | "_rng">;

export function createGameContext<TState extends Record<string, unknown> = {}>(
  commandRegistry: CommandRegistry<IGameContext<TState>>,
  initialState?: TState | (() => TState),
): IGameContext<TState> {
  const stateValue =
    typeof initialState === "function"
      ? initialState()
      : (initialState ?? ({} as TState));
  const state = mutableSignal(stateValue);
  let commands: CommandRunnerContextExport<IGameContext<TState>> = null as any;

  const context: IGameContext<TState> = {
    get value(): TState {
      return state.value;
    },
    get rng() {
      return this._rng;
    },
    produce(fn) {
      return state.produce(fn);
    },
    produceAsync(fn) {
      return state.produceAsync(fn);
    },
    run<T>(input: string) {
      return commands.run<T>(input);
    },
    runParsed<T>(command: Command) {
      return commands.runParsed<T>(command);
    },
    prompt(def, validator, currentPlayer) {
      return commands.prompt(
        def.schema,
        validator,
        def.hintText,
        currentPlayer,
      );
    },

    _state: state,
    _commands: commands,
    _rng: new Mulberry32RNG(),
  };

  context._commands = commands = createCommandRunnerContext(
    commandRegistry,
    context,
  );

  return context;
}

export type PromptDef<TArgs extends any[] = any[]> = {
  schema: CommandSchema;
  hintText?: string;
};
export function createPromptDef<TArgs extends any[] = any[]>(
  schema: CommandSchema | string,
  hintText?: string,
): PromptDef<TArgs> {
  schema = typeof schema === "string" ? parseCommandSchema(schema) : schema;
  return { schema, hintText };
}

export function createGameCommandRegistry<
  TState extends Record<string, unknown> = {},
>() {
  return createCommandRegistry<IGameContext<TState>>();
}