From 4c24f367eb7a4e0ea53685b4b78075a7b6e27050 Mon Sep 17 00:00:00 2001
From: Simon Lemieux <1105380+simlmx@users.noreply.github.com>
Date: Tue, 25 Jun 2024 16:30:07 +0000
Subject: [PATCH] backup

---
 game-template/game/src/index.ts   |  61 ++++---
 game-template/ui/src/Board.tsx    |   6 +-
 packages/dev-server/src/App.tsx   |  36 ++--
 packages/dev-server/src/match.ts  |  33 ++--
 packages/game/src/gameDef.ts      | 266 ++++++++++++++++--------------
 packages/game/src/testing.ts      |  71 +++++---
 packages/ui-testing/src/index.tsx |  16 +-
 packages/ui/src/index.tsx         | 122 +++++---------
 8 files changed, 327 insertions(+), 284 deletions(-)

diff --git a/game-template/game/src/index.ts b/game-template/game/src/index.ts
index a5e139f..f507644 100644
--- a/game-template/game/src/index.ts
+++ b/game-template/game/src/index.ts
@@ -1,8 +1,10 @@
 import { UserId } from "@lefun/core";
 import {
+  makeGameDef,
   GameDef,
-  GameMoves,
-  PlayerMove,
+  GameState,
+  PlayerMoveDef,
+  BoardMoveDefs,
 } from "@lefun/game";
 
 type Player = {
@@ -17,36 +19,56 @@ export type Board = {
 
 type EmptyObject = Record<string, never>;
 
-type GS = {
-  B: Board;
-  PB: EmptyObject;
-  SB: EmptyObject;
-};
+type GS = GameState<Board>;
 
-type MoveWithArgPayload = { someArg: number };
+type BoardMoveTypes = {
+  _initMove: EmptyObject;
+  someBoardMove: EmptyObject;
+  someBoardMoveWithArgs: { someArg: number };
+};
 
 const moveWithArg = {
-  execute({ board, userId, payload }) {
-    //
+  execute({ board, userId, payload, delayMove }) {
+    // execute content
   },
-} satisfies PlayerMove<GS, MoveWithArgPayload>;
+} satisfies PlayerMoveDef<GS, BoardMoveTypes, { someArg: string }>;
 
 const roll = {
   executeNow({ board, userId }) {
     board.players[userId].isRolling = true;
   },
-  execute({ board, userId, random, playerboards }) {
+  execute({ board, userId, random, playerboards, delayMove }) {
     board.players[userId].diceValue = random.d6();
     board.players[userId].isRolling = false;
+    delayMove({ name: "someBoardMove" }, 100);
+    delayMove({ name: "someBoardMoveWithArgs", payload: { someArg: 3 } }, 100);
   },
-} satisfies PlayerMove<GS, EmptyObject>;
+} satisfies PlayerMoveDef<GS, BoardMoveTypes>;
 
-const moves = {
+const playerMoves = {
   moveWithArg,
   roll,
-}
+};
 
-type GM = typeof moves;
+type PM = typeof playerMoves;
+
+const boardMoves = {
+  _initMove: {
+    execute({ board }) {
+      //
+    },
+  },
+  someBoardMove: {
+    execute({ board }) {
+      //
+    },
+  },
+  someBoardMoveWithArgs: {
+    execute({ board, payload }) {
+      //
+    },
+  },
+} satisfies BoardMoveDefs<GS, BoardMoveTypes>;
 
 const game = {
   initialBoards: ({ players }) => ({
@@ -57,9 +79,10 @@ const game = {
       ),
     },
   }),
-  moves,
+  playerMoves,
+  boardMoves,
   minPlayers: 1,
   maxPlayers: 10,
-} satisfies GameDef<GS, GM>;
+} satisfies GameDef<GS, PM, typeof boardMoves, BoardMoveTypes>;
 
-export { GS, GM, game };
+export { GS, PM, game };
diff --git a/game-template/ui/src/Board.tsx b/game-template/ui/src/Board.tsx
index fcd455b..19493a1 100644
--- a/game-template/ui/src/Board.tsx
+++ b/game-template/ui/src/Board.tsx
@@ -10,7 +10,7 @@ import {
   makeUseMakeMove,
 } from "@lefun/ui";
 
-import { GS, GM } from "roll-game";
+import { GS, PM } from "roll-game";
 
 import { Trans } from "@lingui/macro";
 
@@ -19,7 +19,7 @@ const DICE = ["", "\u2680", "\u2681", "\u2682", "\u2683", "\u2684", "\u2685"];
 
 const useSelector = makeUseSelector<GS>();
 const useSelectorShallow = makeUseSelectorShallow<GS>();
-const useMakeMove = makeUseMakeMove<GS, GM>();
+const useMakeMove = makeUseMakeMove<GS, PM>();
 
 function Player({ userId }: { userId: UserId }) {
   const itsMe = useSelector((state) => state.userId === userId);
@@ -67,7 +67,7 @@ function Board() {
       </button>
       <button
         onClick={() =>
-          makeMove({ name: "moveWithArg", payload: { someArg: 3 } })
+          makeMove({ name: "moveWithArg", payload: { someArg: "123" } })
         }
       >
         Go
diff --git a/packages/dev-server/src/App.tsx b/packages/dev-server/src/App.tsx
index 61ae880..c3399a7 100644
--- a/packages/dev-server/src/App.tsx
+++ b/packages/dev-server/src/App.tsx
@@ -18,7 +18,7 @@ import { createRoot } from "react-dom/client";
 import { createStore as _createStore, useStore as _useStore } from "zustand";
 
 import type { Locale, MatchSettings, UserId, UsersState } from "@lefun/core";
-import { GameDef, GameMoves, GameState } from "@lefun/game";
+import { GameDef, GameStateBase } from "@lefun/game";
 import { setMakeMove, Store, storeContext } from "@lefun/ui";
 
 import { loadMatch, Match, saveMatch } from "./match";
@@ -35,7 +35,7 @@ type MatchState<B, PB> = {
   users: UsersState;
 };
 
-const BoardForPlayer = <GS extends GameState>({
+const BoardForPlayer = <GS extends GameStateBase>({
   board,
   userId,
   messages,
@@ -196,10 +196,11 @@ function useSetDimensionCssVariablesOnResize(ref: RefObject<HTMLElement>) {
   return { height, width };
 }
 
-function MatchStateView<GS extends GameState>({
+function MatchStateView({
   matchRef,
 }: {
-  matchRef: RefObject<Match<GS>>;
+  // FIXME
+  matchRef: RefObject<Match<any, any, any>>;
 }) {
   const state = _useStore(matchRef.current?.store as any, (state) =>
     deepCopy(state),
@@ -251,11 +252,12 @@ function ButtonRow({ children }: { children: ReactNode }) {
   return <div className="flex space-x-1">{children}</div>;
 }
 
-function Settings<GS extends GameState>({
+function Settings({
   matchRef,
   resetMatch,
 }: {
-  matchRef: RefObject<Match<GS>>;
+  // FIXME
+  matchRef: RefObject<Match<any, any, any>>;
   resetMatch: ({
     locale,
     numPlayers,
@@ -372,17 +374,17 @@ function Settings<GS extends GameState>({
           </Button>
         </ButtonRow>
       </div>
-      <MatchStateView<GS> matchRef={matchRef} />
+      <MatchStateView matchRef={matchRef} />
     </div>
   );
 }
 
-function Main<GS extends GameState, GM extends GameMoves<GS>>({
+function Main({
   gameDef,
   matchSettings,
   matchData,
 }: {
-  gameDef: GameDef<GS, GM>;
+  gameDef: GameDef<any, any, any>;
   matchSettings: MatchSettings;
   matchData?: any;
 }) {
@@ -393,7 +395,7 @@ function Main<GS extends GameState, GM extends GameMoves<GS>>({
 
   const [loading, setLoading] = useState(true);
 
-  const matchRef = useRef<Match<GS> | null>(null);
+  const matchRef = useRef<Match<any, any, any> | null>(null);
 
   const resetMatch = useCallback(
     ({
@@ -407,10 +409,11 @@ function Main<GS extends GameState, GM extends GameMoves<GS>>({
     }) => {
       const userIds = getUserIds(numPlayers);
 
-      let match: Match<GS> | null = null;
+      // FIXME
+      let match: Match<any, any, any> | null = null;
 
       if (tryToLoad) {
-        match = loadMatch<GS>(gameDef);
+        match = loadMatch(gameDef);
       }
 
       const players = Object.fromEntries(
@@ -434,7 +437,8 @@ function Main<GS extends GameState, GM extends GameMoves<GS>>({
           userIds.map((userId, i) => [userId, { color: i.toString() }]),
         );
 
-        match = new Match<GS>({
+        // FIXME
+        match = new Match<any, any, any>({
           gameDef,
           matchSettings,
           matchPlayersSettings,
@@ -505,7 +509,7 @@ function Main<GS extends GameState, GM extends GameMoves<GS>>({
         })}
       </div>
       {matchRef && (
-        <Settings<GS>
+        <Settings
           matchRef={matchRef}
           resetMatch={({
             numPlayers,
@@ -522,7 +526,7 @@ function Main<GS extends GameState, GM extends GameMoves<GS>>({
 
 type AllMessages = Record<string, Record<string, string>>;
 
-async function render<GS extends GameState>({
+async function render({
   gameDef,
   board,
   matchSettings = {},
@@ -531,7 +535,7 @@ async function render<GS extends GameState>({
   messages = { en: {} },
 }: {
   // FIXME
-  gameDef: GameDef<GS, any>;
+  gameDef: GameDef<any, any, any>;
   board: () => Promise<ReactNode>;
   matchSettings?: MatchSettings;
   matchData?: any;
diff --git a/packages/dev-server/src/match.ts b/packages/dev-server/src/match.ts
index ac367c0..bb8b7cf 100644
--- a/packages/dev-server/src/match.ts
+++ b/packages/dev-server/src/match.ts
@@ -2,24 +2,34 @@ import { Draft, Patch, produceWithPatches } from "immer";
 import { createStore, StoreApi } from "zustand";
 
 import {
-  // Move,
   Locale,
   MatchPlayersSettings,
   MatchSettings,
   User,
   UserId,
 } from "@lefun/core";
-import { GameDef, GameMove, GameState, Random } from "@lefun/game";
+import {
+  GameDef,
+  GameStateBase,
+  PlayerMoveDefs,
+  PlayerMoveName,
+  PlayerMoveWithOptionalPayload,
+  Random,
+} from "@lefun/game";
 
 type EmptyObject = Record<string, never>;
 
-type State<GS extends GameState> = {
+type State<GS extends GameStateBase> = {
   board: GS["B"];
   playerboards: Record<UserId, GS["PB"] | EmptyObject>;
   secretboard: GS["SB"] | EmptyObject;
 };
 
-class Match<GS extends GameState> extends EventTarget {
+class Match<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, BMT>,
+  BMT,
+> extends EventTarget {
   userIds: UserId[];
   random: Random;
   // FIXME
@@ -135,7 +145,10 @@ class Match<GS extends GameState> extends EventTarget {
     }
   }
 
-  makeMove(userId: UserId, move: GameMove<GS, any>) {
+  makeMove<K extends PlayerMoveName<GS, PM>>(
+    userId: UserId,
+    move: PlayerMoveWithOptionalPayload<GS, PM, K>,
+  ) {
     const now = new Date().getTime();
 
     // Here the `store` is the store for the player making the move, since
@@ -149,7 +162,7 @@ class Match<GS extends GameState> extends EventTarget {
     }
 
     const { name, payload } = move;
-    const { executeNow, execute } = this.gameDef.moves[name];
+    const { executeNow, execute } = this.gameDef.playerMoves[name];
 
     const patchesByUserId: Record<UserId, Patch[]> = Object.fromEntries(
       this.userIds.map((userId) => [userId, []]),
@@ -267,17 +280,17 @@ function separatePatchesByUser(
 }
 
 /* Save match to localStorage */
-function saveMatch<GS extends GameState>(match: Match<GS>) {
+function saveMatch(match: Match<any, any, any>) {
   const state = match.store.getState();
   const userIds = match.userIds;
   localStorage.setItem("match", JSON.stringify({ state, userIds }));
 }
 
 /* Load match from localStorage */
-function loadMatch<GS extends GameState>(
+function loadMatch(
   // FIXME
-  gameDef: GameDef<GS, any>,
-): Match<GS> | null {
+  gameDef: GameDef<any, any>,
+): Match<any, any, any> | null {
   const data = localStorage.getItem("match");
   if (!data) {
     return null;
diff --git a/packages/game/src/gameDef.ts b/packages/game/src/gameDef.ts
index b2cd5e1..3c2d619 100644
--- a/packages/game/src/gameDef.ts
+++ b/packages/game/src/gameDef.ts
@@ -1,7 +1,5 @@
 import {
   AkaType,
-  // Move,
-  AnyMove,
   Credits,
   EndMatchOptions,
   GamePlayerSettings,
@@ -18,14 +16,9 @@ import {
 
 import { Random } from "./random";
 
-// Think about how to name those:
-// GameStateBase?
-// GameStateUnknonw? UnkownGameState?
-//
-export type GameState = { B: unknown; PB: unknown; SB: unknown };
+export type GameStateBase = { B: unknown; PB: unknown; SB: unknown };
 
-// This one should be "GameState" I think
-export type GameStateDefault<B, PB = EmptyObject, SB = EmptyObject> = {
+export type GameState<B, PB = EmptyObject, SB = EmptyObject> = {
   B: B;
   PB: PB;
   SB: SB;
@@ -33,18 +26,6 @@ export type GameStateDefault<B, PB = EmptyObject, SB = EmptyObject> = {
 
 type EmptyObject = Record<string, never>;
 
-// We provide a default payload for when we don't need one (for example for moves
-// without any options). This has the side effect of allowing for a missing
-// payload when one should be required.
-export const createMove = <K extends string, P = EmptyObject>(
-  name: K,
-): [K, (payload?: P) => { name: K; payload: P }] => {
-  const f = (payload: P = {} as any) => {
-    return { name, payload };
-  };
-  return [name, f];
-};
-
 export const DELAYED_MOVE = "lefun/delayedMove";
 
 export type Move<K extends string, P = object> = {
@@ -55,11 +36,11 @@ export type Move<K extends string, P = object> = {
 /*
  * Construct a delayed move "action"
  */
-export const delayedMove = <K extends string, P = object>(
-  move: Move<K, P>,
+export const delayedMove = <BMT, K extends BoardMoveName<BMT>>(
+  move: BoardMoveWithOptionalPayload<BMT, K>,
   // Timestamp (using something like `new Date().getTime()`)
   ts: number,
-): DelayedMove<K, P> => {
+): DelayedMove<BMT, K> => {
   return {
     type: DELAYED_MOVE,
     ts,
@@ -67,12 +48,12 @@ export const delayedMove = <K extends string, P = object>(
   };
 };
 
-export type DelayedMove<K extends string, P = object> = {
+export type DelayedMove<BMT, T extends BoardMoveName<BMT>> = {
   type: typeof DELAYED_MOVE;
   // Time at which we want the move to be executed.
   ts: number;
   // The update itself.
-  move: Move<K, P>;
+  move: BoardMoveWithOptionalPayload<BMT, T>;
 };
 
 export type RewardPayload = {
@@ -80,29 +61,33 @@ export type RewardPayload = {
   stats?: Record<UserId, Record<string, number>>;
 };
 
-export type SpecialFuncs = {
-  delayMove: (move: AnyMove, delay: number) => { ts: number };
+// FIXME here we need to extend the board game moves.
+export type SpecialFuncs<BMT> = {
+  delayMove: <K extends BoardMoveName<BMT>>(
+    move: BoardMoveWithOptionalPayload<BMT, K>,
+    delay: number,
+  ) => { ts: number };
   itsYourTurn: (arg0: ItsYourTurnPayload) => void;
   endMatch: (arg0?: EndMatchOptions) => void;
   reward?: (options: RewardPayload) => void;
   logStat: (key: string, value: number) => void;
 };
 
-type ExecuteNowOptions<G extends GameState, P> = {
+type ExecuteNowOptions<GS extends GameStateBase, BMT, P> = {
   userId: UserId;
-  board: G["B"];
+  board: GS["B"];
   // Assume that the game developer has defined the playerboard if they're using it.
-  playerboard: G["PB"];
+  playerboard: GS["PB"];
   payload: P;
-  delayMove: SpecialFuncs["delayMove"];
+  delayMove: SpecialFuncs<BMT>["delayMove"];
 };
 
-export type ExecuteNow<G extends GameState, P> = (
-  options: ExecuteNowOptions<G, P>,
+export type ExecuteNow<G extends GameStateBase, BMT, P> = (
+  options: ExecuteNowOptions<G, BMT, P>,
   // TODO: We should support returning anything and it would be passed to `execute`.
 ) => void | false;
 
-export type ExecuteOptions<G extends GameState, P> = {
+export type ExecuteOptions<G extends GameStateBase, BMT, P> = {
   userId: UserId;
   board: G["B"];
   // Even though `playerboards` and `secretboard` are optional, we'll assume that the
@@ -114,13 +99,17 @@ export type ExecuteOptions<G extends GameState, P> = {
   ts: number;
   gameData: any;
   matchData?: any;
-} & SpecialFuncs;
+} & SpecialFuncs<BMT>;
 
-export type Execute<G extends GameState, P> = (
-  options: ExecuteOptions<G, P>,
+export type Execute<G extends GameStateBase, BMT, P> = (
+  options: ExecuteOptions<G, BMT, P>,
 ) => void;
 
-export type PlayerMove<G extends GameState, P = EmptyObject> = {
+export type PlayerMoveDef<
+  G extends GameStateBase,
+  BMT = EmptyObject,
+  P = EmptyObject,
+> = {
   canDo?: (options: {
     userId: UserId;
     board: G["B"];
@@ -129,23 +118,18 @@ export type PlayerMove<G extends GameState, P = EmptyObject> = {
     // We'll pass `null` on the client, where we don't have the server time.
     ts: number | null;
   }) => boolean;
-  executeNow?: ExecuteNow<G, P>;
-  execute?: Execute<G, P>;
+  executeNow?: ExecuteNow<G, BMT, P>;
+  execute?: Execute<G, BMT, P>;
 };
 
-export type BoardExecute<G extends GameState, P> = (
-  options: Omit<ExecuteOptions<G, P>, "userId">,
+export type BoardExecute<G extends GameStateBase, BMT, P> = (
+  options: Omit<ExecuteOptions<G, BMT, P>, "userId">,
 ) => void;
 
-export type BoardMove<G extends GameState, P> = {
-  execute?: BoardExecute<G, P>;
+export type BoardMoveDef<G extends GameStateBase, BMT, P = EmptyObject> = {
+  execute?: BoardExecute<G, BMT, P>;
 };
 
-export type BoardMoves<G extends GameState> = Record<
-  string,
-  BoardMove<G, unknown>
->;
-
 export type InitialBoardsOptions<B> = {
   players: UserId[];
   matchSettings: MatchSettings;
@@ -161,7 +145,7 @@ export type InitialBoardsOptions<B> = {
   locale: Locale;
 };
 
-export type InitialPlayerboardOptions<G extends GameState> = {
+export type InitialPlayerboardOptions<G extends GameStateBase> = {
   userId: UserId;
   board: G["B"];
   secretboard: G["SB"];
@@ -206,21 +190,29 @@ export type AutoMoveInfo = {
   time?: number;
 };
 
-export type AutoMoveRet<GS extends GameState, GM extends GameMoves<GS>> =
+// FIXME any
+export type AutoMoveRet<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+> =
   | {
-      move: GameMove<GS, GM>;
+      move: PlayerMove<GS, PM, any>;
       duration?: number;
     }
-  | GameMove<GS, GM>;
+  | PlayerMove<GS, PM, any>;
 
-type AutoMoveType<GS extends GameState, GM extends GameMoves<GS>> = (arg0: {
+type AutoMoveType<
+  GS extends GameStateBase,
+  // FIXME
+  PM extends PlayerMoveDefs<GS, any>,
+> = (arg0: {
   userId: UserId;
   board: GS["B"];
   playerboard: GS["PB"];
   secretboard: GS["SB"];
   random: Random;
   returnAutoMoveInfo: boolean;
-}) => AutoMoveRet<GS, GM>;
+}) => AutoMoveRet<GS, PM>;
 
 type GetAgent<B, PB> = (arg0: {
   matchSettings: MatchSettings;
@@ -228,10 +220,12 @@ type GetAgent<B, PB> = (arg0: {
   numPlayers: number;
 }) => Promise<Agent<B, PB>>;
 
-// export type AgentGetMoveRet<K extends string, P> = {
-export type AgentGetMoveRet<GS extends GameState, GM extends GameMoves<GS>> = {
+export type AgentGetMoveRet<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+> = {
   // The `move` that should be performed.
-  move: GameMove<GS, GM>;
+  move: PlayerMove<GS, PM, any>;
   // Some info used for training.
   autoMoveInfo?: AutoMoveInfo;
   // How much "thinking time" should be pretend this move took.
@@ -262,41 +256,72 @@ export type GetMatchScoreTextOptions<B> = {
   board: B;
 };
 
-// FIXME GameMovesBase
-export type GameMoves<G extends GameState> = Record<string, PlayerMove<G, any>>;
+export type PlayerMoveDefs<G extends GameStateBase, BMT = EmptyObject> = {
+  [key: string]: PlayerMoveDef<G, BMT, any>;
+};
 
-export type MoveName<GS extends GameState, GM extends GameMoves<GS>> = Extract<
-  keyof GM,
-  string
+export type BoardMoveDefs<G extends GameStateBase, BMT> = Record<
+  keyof BMT,
+  BoardMoveDef<G, BMT, any>
 >;
 
-export type MovePayload<
-  GS extends GameState,
-  GM extends GameMoves<GS>,
-  K extends MoveName<GS, GM>,
-> = GM[K] extends PlayerMove<GS, infer P> ? P : never;
-
-type GameMove<
-  GS extends GameState,
-  GM extends GameMoves<GS>,
-  K extends MoveName<GS, GM> = MoveName<GS, GM>,
+export type PlayerMoveName<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+> = Extract<keyof PM, string>;
+
+export type PlayerMovePayload<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+  K extends PlayerMoveName<GS, PM>,
+> = PM[K] extends PlayerMoveDef<GS, any, infer P> ? P : never;
+
+type PlayerMove<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+  K extends PlayerMoveName<GS, PM> = PlayerMoveName<GS, PM>,
 > = {
   name: K;
-  payload: MovePayload<GS, GM, K>;
+  payload: PlayerMovePayload<GS, PM, K>;
 };
 
 type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
 
-export type GameMoveWithOptionalPayload<
-  GS extends GameState,
-  GM extends GameMoves<GS>,
-  K extends MoveName<GS, GM>,
-> = [MovePayload<GS, GM, K>[keyof MovePayload<GS, GM, K>]] extends [never]
-  ? Optional<GameMove<GS, GM, K>, "payload">
-  : GameMove<GS, GM, K>;
+export type PlayerMoveWithOptionalPayload<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+  K extends PlayerMoveName<GS, PM>,
+> = [PlayerMovePayload<GS, PM, K>[keyof PlayerMovePayload<GS, PM, K>]] extends [
+  never,
+]
+  ? Optional<PlayerMove<GS, PM, K>, "payload">
+  : PlayerMove<GS, PM, K>;
+
+export type BoardMoveName<BMT> = Extract<keyof BMT, string>;
+
+type BoardMovePayload<BMT, K extends keyof BMT> = BMT[K];
+
+export type BoardMove<BMT, K extends BoardMoveName<BMT>> = {
+  name: K;
+  payload: BMT[K];
+};
+
+export type BoardMoveWithOptionalPayload<BMT, K extends BoardMoveName<BMT>> = [
+  BoardMovePayload<BMT, K>[keyof BoardMovePayload<BMT, K>],
+] extends [never]
+  ? Optional<BoardMove<BMT, K>, "payload">
+  : BoardMove<BMT, K>;
+
+type BMTFromBoardMoveDefs<BM extends BoardMoveDefs<any, any>> =
+  BM extends BoardMoveDefs<any, infer BMT> ? BMT : never;
 
 // This is what the game developer must implement.
-export type GameDef<G extends GameState, GM extends GameMoves<G>> = {
+export type GameDef<
+  G extends GameStateBase,
+  PM extends PlayerMoveDefs<G, BMT>,
+  BM extends BoardMoveDefs<G, BMT> = any,
+  BMT = BMTFromBoardMoveDefs<BM>,
+> = {
   initialBoards: (options: InitialBoardsOptions<G["B"]>) => {
     board: G["B"];
     playerboards?: Record<UserId, G["PB"]>;
@@ -308,8 +333,8 @@ export type GameDef<G extends GameState, GM extends GameMoves<G>> = {
   initialPlayerboard?: (options: InitialPlayerboardOptions<G>) => G["PB"];
 
   // For those the key is the `name` of the move/update
-  moves: GM;
-  boardMoves?: BoardMoves<G>;
+  playerMoves: PM;
+  boardMoves?: BM;
   gameSettings?: GameSettings;
   gamePlayerSettings?: GamePlayerSettings;
 
@@ -330,7 +355,7 @@ export type GameDef<G extends GameState, GM extends GameMoves<G>> = {
   // could be used to play for an unactive user.
   // Not that technically we don't need the `secretboard` in here. In practice sometimes
   // we put data in the secretboard to optimize calculations.
-  autoMove?: AutoMoveType<G, GM>;
+  autoMove?: AutoMoveType<G, PM>;
   getAgent?: GetAgent<G["B"], G["PB"]>;
 
   // Game-level bot move duration.
@@ -355,15 +380,34 @@ export type GameDef<G extends GameState, GM extends GameMoves<G>> = {
   stats?: GameStats;
 };
 
+// export function makeGameDef<
+//   GS extends GameStateBase,
+//   PM extends PlayerMoveDefs<GS, BMT>,
+//   BM extends BoardMoveDefs<GS, BMT>,
+//   BMT,
+// >(gameDef: GameDef<GS, PM, BM, BMT>) {
+//   return gameDef;
+// }
+export const makeGameDef = <
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, BMT>,
+  BM extends BoardMoveDefs<GS, BMT>,
+  BMT = BMTFromBoardMoveDefs<BM>,
+>(
+  gameDef: GameDef<GS, PM, BM, BMT>,
+) => gameDef;
+
 /*
  * Internal representation of the game definition.
  *
  * When developing a game, use `GameDef` instead.
  */
-export type GameDef_<GS extends GameState, GM extends GameMoves<GS>> = Omit<
-  GameDef<GS, GM>,
-  "stats"
-> & {
+export type GameDef_<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, BMT>,
+  BM extends BoardMoveDefs<GS, BMT>,
+  BMT,
+> = Omit<GameDef<GS, PM, BM, BMT>, "stats"> & {
   stats?: {
     allIds: string[];
     // Note that we don't have any flags for stats yet, hence the `EmptyObject`.
@@ -374,13 +418,16 @@ export type GameDef_<GS extends GameState, GM extends GameMoves<GS>> = Omit<
 /*
  * Parse a @lefun/game game definition into our internal game definition.
  */
-export function parseGameDef<GS extends GameState, GM extends GameMoves<GS>>(
-  gameDef: GameDef<GS, GM>,
-): GameDef_<GS, GM> {
+export function parseGameDef<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, BMT>,
+  BM extends BoardMoveDefs<GS, BMT>,
+  BMT,
+>(gameDef: GameDef<GS, PM, BM, BMT>): GameDef_<GS, PM, BM, BMT> {
   // Normalize the stats.
   const { stats: stats_ } = gameDef;
 
-  const stats: GameDef_<GS, GM>["stats"] = {
+  const stats: GameDef_<GS, PM, BM, BMT>["stats"] = {
     allIds: [],
     byId: {},
   };
@@ -394,37 +441,6 @@ export function parseGameDef<GS extends GameState, GM extends GameMoves<GS>>(
   return { ...gameDef, stats };
 }
 
-//
-// Special Move
-//
-
-// This is a special move that game developers can implement rules for. If they
-// do, players will be able to join in the middle of a match.
-export const [ADD_PLAYER, addPlayer] = createMove<
-  "lefun/addPlayerMove",
-  {
-    userId: UserId;
-  }
->("lefun/addPlayerMove");
-
-// Note that there is also a kickFromMatch "action" in the 'common' package.
-export const [KICK_PLAYER, kickPlayer] = createMove<
-  "lefun/kickPlayer",
-  {
-    userId: UserId;
-  }
->("lefun/kickPlayer");
-
-// This is a special move that will be triggered at the start of the match.
-// This way games can implement some logic before any player makes a move, for instance
-// triggering a delayed move.
-export const [INIT_MOVE, initMove] = createMove("lefun/initMove");
-
-// Move triggered by the server when we need to abruptly end a match.
-export const [MATCH_WAS_ABORTED, matchWasAborted] = createMove(
-  "lefun/matchWasAborted",
-);
-
 // Game Manifest
 export type GameManifest = {
   // TODO: It's a string but currently we are assuming it can be parse to an integer!
diff --git a/packages/game/src/testing.ts b/packages/game/src/testing.ts
index d79e439..34a67a3 100644
--- a/packages/game/src/testing.ts
+++ b/packages/game/src/testing.ts
@@ -20,15 +20,15 @@ import {
   AgentGetMoveRet,
   AutoMoveInfo,
   AutoMoveRet,
+  BoardMoveDefs,
+  BoardMoveName,
+  BoardMoveWithOptionalPayload,
   DelayedMove,
   delayedMove,
   GameDef,
   GameDef_,
-  GameMoves,
-  GameMoveWithOptionalPayload,
-  GameState,
+  GameStateBase,
   Move,
-  MoveName,
   // GameType,
   // INIT_MOVE,
   // initMove,
@@ -36,13 +36,21 @@ import {
   // MATCH_WAS_ABORTED,
   // matchWasAborted,
   parseGameDef,
+  PlayerMoveDefs,
+  PlayerMoveName,
+  PlayerMoveWithOptionalPayload,
   // PlayerMove,
   RewardPayload,
 } from "./gameDef";
 import { Random } from "./random";
 
-type MatchTesterOptions<G extends GameState, GM extends GameMoves<G>> = {
-  gameDef: GameDef<G, GM>;
+type MatchTesterOptions<
+  G extends GameStateBase,
+  PM extends PlayerMoveDefs<G, BMT>,
+  BM extends BoardMoveDefs<G, BMT>,
+  BMT,
+> = {
+  gameDef: GameDef<G, PM, BM, BMT>;
   gameData?: any;
   matchData?: any;
   numPlayers: number;
@@ -86,12 +94,19 @@ type UsersState = { byId: Record<UserId, User> };
 //   payload: M[keyof M];
 // };
 
+type EmptyObject = Record<string, never>;
+
 /*
  * Use this to test your game rules.
  * It emulates what the backend does.
  */
-export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
-  gameDef: GameDef_<GS, GM>;
+export class MatchTester<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, BMT>,
+  BM extends BoardMoveDefs<GS, BMT> = BoardMoveDefs<GS, any>,
+  BMT = EmptyObject,
+> {
+  gameDef: GameDef_<GS, PM, BM, BMT>;
   gameData: any;
   matchData?: any;
   meta: Meta;
@@ -106,7 +121,7 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
   // Clock used for delayedMoves - in ms.
   time: number;
   // List of timers to be executed.
-  delayedMoves: DelayedMove<string, any>[];
+  delayedMoves: DelayedMove<BMT, any>[];
   // To help generate the next userIds.
   nextUserId: number;
   // Variables to check for infinite loops.
@@ -135,7 +150,7 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
     training = false,
     logBoardToTrainingLog = false,
     locale = "en",
-  }: MatchTesterOptions<GS, GM>) {
+  }: MatchTesterOptions<GS, PM, BM, BMT>) {
     if (random == null) {
       random = new Random();
     }
@@ -371,9 +386,9 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
     this._isPlaying = false;
   }
 
-  async makeMoveAndContinue<K extends MoveName<GS, GM>>(
+  async makeMoveAndContinue<K extends PlayerMoveName<GS, PM>>(
     userId: UserId,
-    move: GameMoveWithOptionalPayload<GS, GM, K>,
+    move: PlayerMoveWithOptionalPayload<GS, PM, K>,
     { canFail = false }: { canFail?: boolean } = {},
   ) {
     this.makeMove(userId, move, { canFail });
@@ -399,9 +414,12 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
       metaItsYourTurn(this.meta, payload);
     };
 
-    // fIXME any
-    const delayMove = (move: any, delay: number) => {
-      const dm = delayedMove(move, this.time + delay);
+    // FIXME any
+    const delayMove = <K extends BoardMoveName<BMT>>(
+      move: BoardMoveWithOptionalPayload<BMT, K>,
+      delay: number,
+    ) => {
+      const dm = delayedMove<BMT, K>(move, this.time + delay);
       // In the match tester, we only note the delayed move. We'll execute them only if
       // we `fastForward`.
       this.delayedMoves.push(dm);
@@ -415,8 +433,9 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
     return { delayMove, itsYourTurn, endMatch, reward, logStat };
   }
 
-  // FIXME
-  makeBoardMove(move: any) {
+  makeBoardMove<K extends BoardMoveName<BMT>>(
+    move: BoardMoveWithOptionalPayload<BMT, K>,
+  ) {
     const { name, payload } = move;
     const {
       gameDef,
@@ -469,12 +488,12 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
     }
   }
 
-  makeMove<K extends MoveName<GS, GM>>(
+  makeMove<K extends PlayerMoveName<GS, PM>>(
     userId: UserId,
-    move: GameMoveWithOptionalPayload<GS, GM, K>,
+    move: PlayerMoveWithOptionalPayload<GS, PM, K>,
     { canFail = false }: { canFail?: boolean } = {},
   ) {
-    const { name, payload } = move;
+    const { name, payload = {} } = move;
 
     const {
       board,
@@ -488,7 +507,7 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
       time,
     } = this;
 
-    if (!gameDef.moves[name]) {
+    if (!gameDef.playerMoves[name]) {
       throw new Error(`game does not implement ${name}`);
     }
 
@@ -497,9 +516,9 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
       throw new Error(`unknown userId ${userId}`);
     }
 
-    const { moves } = gameDef;
+    const { playerMoves } = gameDef;
 
-    const moveDef = moves[name];
+    const moveDef = playerMoves[name];
 
     if (!moveDef) {
       throw new Error(`unknown move ${name}`);
@@ -507,7 +526,7 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
 
     const playerboard = playerboards[userId];
 
-    const { canDo, executeNow, execute } = gameDef.moves[name];
+    const { canDo, executeNow, execute } = gameDef.playerMoves[name];
 
     if (
       canDo !== undefined &&
@@ -612,7 +631,7 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
 
         // let autoMoveRet: ReturnType<Agent<B, PB>['getMove']>;
         // FIXME
-        let autoMoveRet: AutoMoveRet<GS, GM> | AgentGetMoveRet<GS, GM>;
+        let autoMoveRet: AutoMoveRet<GS, PM> | AgentGetMoveRet<GS, PM>;
         const t0 = new Date().getTime();
         if (gameDef.autoMove !== undefined) {
           // TODO deprecate the `autoMove` function in favor of the AutoMover class?
@@ -713,7 +732,7 @@ export class MatchTester<GS extends GameState, GM extends GameMoves<GS>> {
     const delayedMoves = this.delayedMoves.filter((du) => du.ts <= this.time);
     // Sort by time, but keep the order in case of equality.
     delayedMoves
-      .map((u, i) => [u, i] as [DelayedMove<any /* FIXME */>, number])
+      .map((u, i) => [u, i] as [DelayedMove<BMT, any>, number])
       .sort(([u1, i1], [u2, i2]) => Math.sign(u1.ts - u2.ts) || i1 - i2);
 
     for (const delayedMove of delayedMoves) {
diff --git a/packages/ui-testing/src/index.tsx b/packages/ui-testing/src/index.tsx
index 424bb29..e089230 100644
--- a/packages/ui-testing/src/index.tsx
+++ b/packages/ui-testing/src/index.tsx
@@ -1,24 +1,24 @@
 import { i18n } from "@lingui/core";
 import { I18nProvider } from "@lingui/react";
 import { render as rtlRender, RenderResult } from "@testing-library/react";
-import { ReactNode } from "react";
+import { ElementType, ReactNode } from "react";
 import { createStore } from "zustand";
 
-import { GameState } from "@lefun/game";
+import { GameStateBase } from "@lefun/game";
 import { MatchState, setMakeMove, storeContext } from "@lefun/ui";
 
-export const render = (
-  Board: any,
-  state: MatchState<GameState>,
+export function render<GS extends GameStateBase>(
+  Board: ElementType,
+  state: MatchState<GS>,
   locale: string = "en",
-): RenderResult => {
+): RenderResult {
   const userId = state.userId;
   // Sanity check
   if (userId == null) {
     throw new Error("userId should not be null");
   }
 
-  const store = createStore<MatchState<GameState>>()(() => ({
+  const store = createStore<MatchState<GS>>()(() => ({
     ...state,
   }));
 
@@ -39,4 +39,4 @@ export const render = (
     );
   };
   return rtlRender(<Board userId={userId} />, { wrapper });
-};
+}
diff --git a/packages/ui/src/index.tsx b/packages/ui/src/index.tsx
index 36ba198..53da062 100644
--- a/packages/ui/src/index.tsx
+++ b/packages/ui/src/index.tsx
@@ -4,29 +4,15 @@ import { useShallow } from "zustand/react/shallow";
 
 import type { MatchState as _MatchState, UserId } from "@lefun/core";
 import type {
-  // GameDef,
-  // GameMove,
-  GameMoves,
-  GameMoveWithOptionalPayload,
-  GameState,
-  GameStateDefault,
-  MoveName,
-  // MovePayload,
-  // FIXME make sure we rename these
-  // GameStateDefault,
-  // MoveName,
-  // MovePayload,
-  // PlayerMove,
+  GameStateBase,
+  PlayerMoveDefs,
+  PlayerMoveName,
+  PlayerMoveWithOptionalPayload,
 } from "@lefun/game";
 
-type AnyGameType = GameStateDefault<any, any, any>;
-type UnknownGameType = GameStateDefault<unknown, unknown, unknown>;
-
-// type EmptyObject = Record<string, never>;
-
 // In the selectors, assume that the boards are defined. We will add a check in the
 // client code to make sure this is true.
-export type MatchState<GS extends GameState> = _MatchState<
+export type MatchState<GS extends GameStateBase> = _MatchState<
   GS["B"],
   GS["PB"]
 > & {
@@ -35,38 +21,31 @@ export type MatchState<GS extends GameState> = _MatchState<
   playerboard: GS["PB"];
 };
 
-export type Selector<GS extends GameState, T> = (state: MatchState<GS>) => T;
-
-// TODO Type this properly
-export type Store<GS extends GameState> = StoreApi<MatchState<GS>>;
-
-// FIXME
-export const storeContext = createContext<Store<UnknownGameType> | null>(null);
+export type Selector<GS extends GameStateBase, T> = (
+  state: MatchState<GS>,
+) => T;
 
-// type MakeMove<K extends string, P> = P extends EmptyObject
-//   ? <K, P>(moveName: K, payload: P) => void
-//   : <K>(moveName: K) => void;
+export type Store<GS extends GameStateBase> = StoreApi<MatchState<GS>>;
 
-// let _makeMove: (store: Store) => MakeMove;
-// type AnyGameState = GameStateDefault<any, any, any>
+export const storeContext = createContext<Store<GameStateBase> | null>(null);
 
 let _makeMove: <
-  GS extends GameState,
-  GM extends GameMoves<GS>,
-  K extends MoveName<GS, GM>,
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, GMT>,
+  GMT,
+  K extends PlayerMoveName<GS, PM>,
 >(
-  store: Store<AnyGameType>,
-) => (move: GameMoveWithOptionalPayload<GS, GM, K>) => void;
+  store: Store<GameStateBase>,
+) => (move: PlayerMoveWithOptionalPayload<GS, PM, K>) => void;
 
-// export function setMakeMove<GS extends GameState, GM extends GameMoves<GS>>(
 export function setMakeMove(
   makeMove: <
-    GS extends GameState,
-    GM extends GameMoves<GS>,
-    K extends MoveName<GS, GM>,
+    GS extends GameStateBase,
+    PM extends PlayerMoveDefs<GS, any>,
+    K extends PlayerMoveName<GS, PM>,
   >(
-    move: GameMoveWithOptionalPayload<GS, GM, K>,
-    store: Store<UnknownGameType>,
+    move: PlayerMoveWithOptionalPayload<GS, PM, K>,
+    store: Store<GameStateBase>,
   ) => void,
 ) {
   _makeMove = (store) => (move) => {
@@ -74,16 +53,11 @@ export function setMakeMove(
   };
 }
 
-// type EmptyObject = Record<string, never>;
-
-// type IsEmpty<T> = [T[keyof T]] extends [never] ? true : false;
-
-// ? Optional<GameMove<GS, GM, K>, "payload">
-
-export function useMakeMove<GS extends GameState, GM extends GameMoves<GS>>(): <
-  K extends MoveName<GS, GM>,
->(
-  move: GameMoveWithOptionalPayload<GS, GM, K>,
+export function useMakeMove<
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
+>(): <K extends PlayerMoveName<GS, PM>>(
+  move: PlayerMoveWithOptionalPayload<GS, PM, K>,
 ) => void {
   if (!_makeMove) {
     throw new Error(
@@ -108,17 +82,16 @@ export function useMakeMove<GS extends GameState, GM extends GameMoves<GS>>(): <
 // }
 
 export function makeUseMakeMove<
-  GS extends GameState,
-  GM extends GameMoves<GS>,
-  // K extends MoveName<GS, GM>,
+  GS extends GameStateBase,
+  PM extends PlayerMoveDefs<GS, any>,
 >() {
-  return useMakeMove<GS, GM>;
+  return useMakeMove<GS, PM>;
 }
 
 /*
  * Main way to get data from the match state.
  */
-export function useSelector<GS extends GameState, T>(
+export function useSelector<GS extends GameStateBase, T>(
   selector: Selector<GS, T>,
 ): T {
   const store = useContext(storeContext);
@@ -130,13 +103,13 @@ export function useSelector<GS extends GameState, T>(
 
 /* Util to "curry" the types of useSelector<...> */
 export const makeUseSelector =
-  <GS extends GameState>() =>
+  <GS extends GameStateBase>() =>
   <T,>(selector: Selector<GS, T>) =>
     useSelector<GS, T>(selector);
 
 /* Util to "curry" the types of useSelectorShallow<...> */
 export const makeUseSelectorShallow =
-  <GS extends GameState>() =>
+  <GS extends GameStateBase>() =>
   <T,>(selector: Selector<GS, T>) =>
     useSelectorShallow<GS, T>(selector);
 
@@ -144,7 +117,7 @@ export const makeUseSelectorShallow =
  * Same as `useSelector` but will use a shallow equal on the output to decide if a render
  * is required or not.
  */
-export function useSelectorShallow<GS extends GameState, T>(
+export function useSelectorShallow<GS extends GameStateBase, T>(
   selector: Selector<GS, T>,
 ): T {
   return useSelector(useShallow(selector));
@@ -153,7 +126,7 @@ export function useSelectorShallow<GS extends GameState, T>(
 /*
  * Util to check if the user is a player (if not they are a spectator).
  */
-export const useIsPlayer = <GS extends GameState>() => {
+export const useIsPlayer = <GS extends GameStateBase>() => {
   // Currently, the user is a player iif its playerboard is defined.
   const hasPlayerboard = useSelector(
     (state: _MatchState<GS["B"], GS["PB"]>) => {
@@ -201,7 +174,7 @@ const toClientTime =
  *  has happened. This can be useful if you want some action from the server to happen
  *  exactly when a countdown gets to 0.
  */
-export const useToClientTime = <GS extends GameState>() => {
+export const useToClientTime = <GS extends GameStateBase>() => {
   const delta = useSelector(
     (state: _MatchState<GS["B"], GS["PB"]>) => state.timeDelta || 0,
   );
@@ -247,7 +220,7 @@ export const playSound = (name: string) => {
 /*
  * Util to get a username given its userId
  */
-export const useUsername = <GS extends GameState>(
+export const useUsername = <GS extends GameStateBase>(
   userId?: UserId,
 ): string | undefined => {
   const username = useSelector((state: _MatchState<GS["B"], GS["PB"]>) => {
@@ -259,21 +232,16 @@ export const useUsername = <GS extends GameState>(
 /*
  * Return a userId: username mapping.
  */
-export const useUsernames = <GS extends GameState>(): Record<
-  UserId,
-  string
-> => {
+export const useUsernames = (): Record<UserId, string> => {
   // Note the shallow-compared selector.
-  const usernames = useSelectorShallow(
-    (state: _MatchState<GS["B"], GS["PB"]>) => {
-      const users = state.users.byId;
-      const usernames: { [userId: string]: string } = {};
-      for (const [userId, { username }] of Object.entries(users)) {
-        usernames[userId] = username;
-      }
-      return usernames;
-    },
-  );
+  const usernames = useSelectorShallow((state: _MatchState) => {
+    const users = state.users.byId;
+    const usernames: { [userId: string]: string } = {};
+    for (const [userId, { username }] of Object.entries(users)) {
+      usernames[userId] = username;
+    }
+    return usernames;
+  });
 
   return usernames;
 };