boardgame-core/src/core/game.ts

import {MutableSignal, mutableSignal} from "@/utils/mutable-signal";
import {
    Command,
    CommandRegistry, CommandResult,
    CommandRunnerContext, CommandRunnerContextExport,
    CommandSchema,
    createCommandRegistry,
    createCommandRunnerContext,
    parseCommandSchema,
    registerCommand
} from "@/utils/command";
import type { GameModule } from './game-host';

export interface IGameContext<TState extends Record<string, unknown> = {} > {
    get value(): TState;
    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(schema: CommandSchema | string, validator?: (command: Command) => string | null, currentPlayer?: string | null): Promise<Command>;
    addInterruption(promise: Promise<void>): void;
    
    // test only
    _state: MutableSignal<TState>;
    _commands: CommandRunnerContextExport<IGameContext<TState>>;
}

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;
        },
        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(schema, validator, currentPlayer) {
            return commands.prompt(schema, validator, currentPlayer);
        },
        addInterruption(promise) {
            state.addInterruption(promise);
        },
        
        _state: state,
        _commands: commands,
    };

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

/**
 * so that we can do `import * as tictactoe from './tic-tac-toe.ts';\n\n createGameContextFromModule(tictactoe);`
 * @param module
 */
export function createGameContextFromModule<TState extends Record<string, unknown> = {} >(
    module: {
        registry: CommandRegistry<IGameContext<TState>>,
        createInitialState: () => TState
    },
): IGameContext<TState> {
    return createGameContext(module.registry, module.createInitialState);
}

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

type CmdFunc<TState extends Record<string, unknown> = {}> = (this: IGameContext<TState>, ...args: any[]) => Promise<unknown>;

export function registerGameCommand<TState extends Record<string, unknown> = {}, TFunc extends CmdFunc<TState> = CmdFunc<TState>>(
    registry: CommandRegistry<IGameContext<TState>>,
    schema: CommandSchema | string,
    run: TFunc
) {
    const parsedSchema = typeof schema === 'string' ? parseCommandSchema(schema) : schema;
    registerCommand(registry, {
        schema: parsedSchema,
        async run(this: CommandRunnerContext<IGameContext<TState>>, command: Command){
            const params = command.params;
            return await run.call(this.context, ...params);
        },
    });
    
    return function(game: IGameContext<TState>, ...args: Parameters<TFunc>){
        return game.runParsed({
            options: {},
            params: args,
            flags: {},
            name: parsedSchema.name,
        });
    }
}

export { GameHost, createGameHost } from './game-host';
export type { GameHostStatus, GameModule } from './game-host';

export function createGameModule<TState extends Record<string, unknown>>(
    module: GameModule<TState>
): GameModule<TState> {
    return module;
}