src/core/game-host.ts

@@ -12,7 +12,6 @@ export type GameHostStatus = "created" | "running" | "disposed";
 export class GameHost<
   TState extends Record<string, unknown>,
   TResult = unknown,
-  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
 > {
   readonly state: ReadonlySignal<TState>;
   readonly status: ReadonlySignal<GameHostStatus>;
@@ -30,16 +29,16 @@ export class GameHost<
   private _eventListeners: Map<"start" | "dispose", Set<() => void>>;
   private _isDisposed = false;
 
-  constructor(public readonly gameModule: TModule) {
-    const { createInitialState, registry, start } = gameModule;
+  constructor(
+    registry: CommandRegistry<IGameContext<TState>>,
+    createInitialState: () => TState,
+    start: (ctx: IGameContext<TState>) => Promise<TResult>,
+  ) {
     this._createInitialState = createInitialState;
     this._eventListeners = new Map();
 
     const initialState = createInitialState();
-    this._context = createGameContext(
-      registry ?? createGameCommandRegistry(),
-      initialState,
-    );
+    this._context = createGameContext(registry, initialState);
     this._start = start;
     this.state = this._context._state;
 
@@ -180,7 +179,10 @@ export type GameModule<
 export function createGameHost<
   TState extends Record<string, unknown>,
   TResult = unknown,
-  TModule extends GameModule<TState, TResult> = GameModule<TState, TResult>,
->(gameModule: TModule): GameHost<TState, TResult> {
-  return new GameHost(gameModule);
+>(gameModule: GameModule<TState, TResult>): GameHost<TState, TResult> {
+  return new GameHost(
+    gameModule.registry || createGameCommandRegistry(),
+    gameModule.createInitialState,
+    gameModule.start,
+  );
 }

src/index.ts

@@ -71,6 +71,4 @@ export { createRNG, Mulberry32RNG } from "./utils/rng";
 export type { MiddlewareChain } from "./utils/middleware";
 export { createMiddlewareChain } from "./utils/middleware";
 
-export * from "./utils/spawner";
-
 export * from "@preact/signals-core";

src/samples/slay-the-spire-like/data/types.ts

@@ -5,14 +5,14 @@ import type * as desert from "./desert";
 import { IRunContext } from "../system/combat";
 
 export type ContentModule = {
-  readonly getCards: () => readonly desert.Card[];
-  readonly getEffects: () => readonly desert.Effect[];
-  readonly getEncounters: () => readonly desert.Encounter[];
-  readonly getEnemies: () => readonly desert.Enemy[];
-  readonly getIntents: () => readonly desert.Intent[];
-  readonly getItems: () => readonly desert.Item[];
-  readonly getStartingItems: () => readonly desert.Item[];
+  getCards: () => desert.Card[];
+  getEffects: () => desert.Effect[];
+  getEncounters: () => desert.Encounter[];
+  getEnemies: () => desert.Enemy[];
+  getIntents: () => desert.Intent[];
+  getItems: () => desert.Item[];
+  getStartingItems: () => desert.Item[];
 
-  readonly dialogues: YarnDialogues;
-  readonly addTriggers: (triggers: Triggers, run: IRunContext) => void;
+  dialogues: YarnDialogues;
+  addTriggers: (triggers: Triggers, run: IRunContext) => void;
 };

src/samples/slay-the-spire-like/system/combat/index.ts

@@ -3,3 +3,27 @@ export * from "./factory";
 export * from "./prompts";
 export * from "./triggers";
 export * from "./types";
+
+import { GameHost } from "@/core/game-host";
+import { ContentModule } from "../types";
+import { createCommandRegistry } from "@/utils/command";
+import { createStart, createTriggers, Triggers } from "./triggers";
+import { CombatState, IRunContext } from "./types";
+
+export class CombatGameHost extends GameHost<CombatState> {
+  public readonly triggers: Triggers;
+  constructor(
+    private module: ContentModule,
+    private runContext: IRunContext,
+    private initialState: CombatState,
+  ) {
+    let triggers: Triggers;
+    super(
+      createCommandRegistry(),
+      () => initialState,
+      createStart((triggers = createTriggers(runContext)), runContext),
+    );
+    module.addTriggers(triggers, runContext);
+    this.triggers = triggers;
+  }
+}

src/utils/spawner.ts

@@ -1,39 +0,0 @@
-import { effect } from "@preact/signals-core";
-
-export type SpawnerFunction = (id: string) => () => void;
-
-export function createSpawner(spawner: SpawnerFunction) {
-  const entries = new Map<string, () => void>();
-
-  function update(set: Set<string>) {
-    for (const key of set) {
-      if (!entries.has(key)) {
-        entries.set(key, spawner(key));
-      }
-    }
-
-    for (const [key, entry] of entries) {
-      if (!set.has(key)) {
-        entry();
-        entries.delete(key);
-      }
-    }
-  }
-
-  return update;
-}
-
-export function spawnerEffect(
-  iterable: () => Iterable<string>,
-  spawner: SpawnerFunction,
-) {
-  const update = createSpawner(spawner);
-
-  return effect(() => {
-    const set = new Set<string>();
-    for (const each of iterable()) {
-      set.add(each);
-    }
-    update(set);
-  });
-}