@openturn/replay

bun add @openturn/replay

interface SavedReplayEnvelope<TPlayers, TMatchData> {
  version: SavedReplayVersion;             // currently 1
  gameID: string;                          // your stable identifier
  playerID?: TPlayers[number];
  seed: string;
  initialNow: number;
  match: MatchInput<TPlayers, TMatchData>;
  actions: readonly GameActionRecord[];
  metadata?: SavedReplayMetadata;
}

createSavedReplayEnvelope({
  gameID,
  seed,
  initialNow,
  match,
  actions,
  playerID?,
  metadata?,
})

createSavedReplayFromSession({
  gameID,
  session,
  playerID?,
  metadata?,
})

interface ReplayTimeline<TGame> {
  frames: readonly ReplayFrame<TGame>[];
  actions: readonly GameActionRecord[];
  branches: readonly ReplayBranch[];
  seed: string;
  initialNow: number;
}

interface ReplayFrame<TGame> {
  snapshot: GameSnapshot<...>;
  step: GameStep<TGame> | null;     // null only on the initial frame
  action: GameActionRecord | null;
  revision: number;
  playerView: GamePlayerView<TGame> | null;
}

interface ReplayBranch {
  branchID: string;
  parentBranchID: string | null;
  createdAtActionID: string | null;
  createdAtRevision: number;
  /**
   * Last action that belongs to this branch's playback line. Used by cursors
   * to bound playback when scrubbing inside a non-trunk branch.
   * `null` for empty/initial-frame branches.
   */
  headActionID: string | null;
}

const timeline = materializeReplay(myGame, {
  match,
  seed,
  initialNow,
  actions,
});

interface ReplayMaterializeOptions<TGame> {
  actions: readonly GameActionRecord[];
  match: MatchInput<GamePlayers<TGame>>;
  initialNow?: number;
  playerID?: GamePlayers<TGame>[number];
  seed?: string;
}

interface ReplayCursor<TGame> {
  getState(): ReplayCursorState<TGame>;
  play(): ReplayCursorState<TGame>;
  pause(): ReplayCursorState<TGame>;
  undo(): ReplayCursorState<TGame>;
  redo(): ReplayCursorState<TGame>;
  seekAction(actionID: string | null): ReplayCursorState<TGame>;
  seekRevision(revision: number): ReplayCursorState<TGame>;
  seekTurn(turn: number): ReplayCursorState<TGame>;
  setBranch(branchID: string): ReplayCursorState<TGame>;
  setSpeed(speed: number): ReplayCursorState<TGame>;
}