init with react+axum+spacetimedb

src/services/rpg-runtime/rpgRuntimeStoryClient.ts

@@ -0,0 +1,281 @@
+import type {
+  RuntimeStoryActionRequest,
+  RuntimeStoryActionResponse,
+  RuntimeStoryOptionView,
+  RuntimeStoryStateRequest,
+} from '../../../packages/shared/src/contracts/rpgRuntimeStoryState';
+import type {
+  RuntimeStoryChoicePayload,
+  ServerRuntimeFunctionId,
+  Task5RuntimeFunctionId,
+} from '../../../packages/shared/src/contracts/rpgRuntimeStoryAction';
+import {
+  SERVER_RUNTIME_FUNCTION_IDS,
+  TASK5_RUNTIME_FUNCTION_IDS,
+} from '../../../packages/shared/src/contracts/rpgRuntimeStoryAction';
+import { rehydrateSavedSnapshot } from '../../persistence/runtimeSnapshot';
+import type { HydratedSavedGameSnapshot } from '../../persistence/runtimeSnapshotTypes';
+import type { GameState, StoryMoment, StoryOption } from '../../types';
+import { AnimationState } from '../../types';
+import { type ApiRetryOptions, requestJson } from '../apiClient';
+
+const RUNTIME_STORY_API_BASE = '/api/runtime/story';
+const DEFAULT_SESSION_ID = 'runtime-main';
+const RUNTIME_STORY_RETRY: ApiRetryOptions = {
+  maxRetries: 1,
+  baseDelayMs: 220,
+  maxDelayMs: 640,
+  retryUnsafeMethods: true,
+};
+
+const TASK5_RUNTIME_FUNCTION_ID_SET = new Set<string>(
+  TASK5_RUNTIME_FUNCTION_IDS,
+);
+const SERVER_RUNTIME_FUNCTION_ID_SET = new Set<string>([
+  ...SERVER_RUNTIME_FUNCTION_IDS,
+]);
+
+export type RpgRuntimeStoryClientOptions = {
+  signal?: AbortSignal;
+  retry?: ApiRetryOptions;
+};
+
+export type RuntimeStoryResponse = RuntimeStoryActionResponse<
+  GameState,
+  StoryMoment
+>;
+export type { RuntimeStoryChoicePayload };
+export type RuntimeStorySnapshotRequest = RuntimeStoryStateRequest<
+  GameState,
+  StoryMoment
+>['snapshot'];
+
+function requestRuntimeStoryJson<T>(
+  path: string,
+  init: RequestInit,
+  fallbackMessage: string,
+  options: RpgRuntimeStoryClientOptions = {},
+) {
+  return requestJson<T>(
+    `${RUNTIME_STORY_API_BASE}${path}`,
+    {
+      ...init,
+      signal: options.signal,
+    },
+    fallbackMessage,
+    { retry: options.retry ?? RUNTIME_STORY_RETRY },
+  );
+}
+
+function createRuntimeStoryOption(
+  option: RuntimeStoryOptionView,
+  _gameState?: Pick<GameState, 'currentEncounter'>,
+): StoryOption {
+  return {
+    functionId: option.functionId,
+    actionText: option.actionText,
+    text: option.actionText,
+    detailText: option.detailText,
+    visuals: {
+      playerAnimation: AnimationState.IDLE,
+      playerMoveMeters: 0,
+      playerOffsetY: 0,
+      playerFacing: 'right',
+      scrollWorld: false,
+      monsterChanges: [],
+    },
+    interaction: option.interaction as StoryOption['interaction'] | undefined,
+    runtimePayload: option.payload,
+    disabled: option.disabled,
+    disabledReason: option.reason,
+  };
+}
+
+export function getRuntimeSessionId(
+  gameState: Pick<GameState, 'runtimeSessionId'>,
+) {
+  return gameState.runtimeSessionId?.trim() || DEFAULT_SESSION_ID;
+}
+
+export function getRuntimeClientVersion(
+  gameState: Pick<GameState, 'runtimeActionVersion'>,
+) {
+  return typeof gameState.runtimeActionVersion === 'number'
+    ? gameState.runtimeActionVersion
+    : undefined;
+}
+
+export function isTask5RuntimeFunctionId(
+  functionId: string,
+): functionId is Task5RuntimeFunctionId {
+  return TASK5_RUNTIME_FUNCTION_ID_SET.has(functionId);
+}
+
+export function isServerRuntimeFunctionId(
+  functionId: string,
+): functionId is ServerRuntimeFunctionId {
+  return SERVER_RUNTIME_FUNCTION_ID_SET.has(functionId);
+}
+
+export function shouldUseServerRuntimeOptions(options: StoryOption[] | null) {
+  return Boolean(
+    options?.length &&
+      options.every((option) => isServerRuntimeFunctionId(option.functionId)),
+  );
+}
+
+export function buildStoryMomentFromRuntimeOptions(params: {
+  storyText: string;
+  options: RuntimeStoryOptionView[];
+  gameState?: Pick<GameState, 'currentEncounter'>;
+}): StoryMoment {
+  return {
+    text: params.storyText,
+    options: params.options.map((option) =>
+      createRuntimeStoryOption(option, params.gameState),
+    ),
+  } satisfies StoryMoment;
+}
+
+function shouldPreferSnapshotStory(story: StoryMoment | null) {
+  return Boolean(
+    story &&
+      (story.displayMode === 'dialogue' ||
+        story.deferredOptions?.length ||
+        story.dialogue?.length),
+  );
+}
+
+export function resolveRuntimeStoryMoment(params: {
+  response: RuntimeStoryResponse;
+  hydratedSnapshot: HydratedSavedGameSnapshot;
+  fallbackGameState?: Pick<GameState, 'currentEncounter'>;
+  fallbackStoryText?: string;
+}) {
+  if (shouldPreferSnapshotStory(params.hydratedSnapshot.currentStory)) {
+    return params.hydratedSnapshot.currentStory!;
+  }
+
+  const options =
+    params.response.viewModel.availableOptions.length > 0
+      ? params.response.viewModel.availableOptions
+      : params.response.presentation.options;
+
+  return buildStoryMomentFromRuntimeOptions({
+    storyText:
+      params.response.presentation.storyText ||
+      params.hydratedSnapshot.currentStory?.text ||
+      params.fallbackStoryText ||
+      '',
+    options,
+    gameState: params.hydratedSnapshot.gameState.currentEncounter
+      ? params.hydratedSnapshot.gameState
+      : params.fallbackGameState,
+  });
+}
+
+export async function getRuntimeStoryState(
+  params: {
+    sessionId: string;
+    clientVersion?: number;
+    snapshot?: RuntimeStorySnapshotRequest;
+  },
+  options: RpgRuntimeStoryClientOptions = {},
+) {
+  const normalizedSessionId = params.sessionId || DEFAULT_SESSION_ID;
+  const response = params.snapshot
+    ? await requestRuntimeStoryJson<RuntimeStoryResponse>(
+        '/state/resolve',
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            sessionId: normalizedSessionId,
+            clientVersion: params.clientVersion,
+            snapshot: params.snapshot,
+          } satisfies RuntimeStoryStateRequest<GameState, StoryMoment>),
+        },
+        '读取运行时故事状态失败',
+        options,
+      )
+    : await requestRuntimeStoryJson<RuntimeStoryResponse>(
+        `/state/${encodeURIComponent(normalizedSessionId)}`,
+        { method: 'GET' },
+        '读取运行时故事状态失败',
+        options,
+      );
+
+  return {
+    ...response,
+    snapshot: rehydrateSavedSnapshot(
+      response.snapshot as HydratedSavedGameSnapshot,
+    ),
+  } satisfies RuntimeStoryResponse;
+}
+
+export async function resolveRuntimeStoryAction(
+  params: {
+    sessionId?: string;
+    clientVersion?: number;
+    option: Pick<StoryOption, 'functionId' | 'actionText'>;
+    targetId?: string;
+    payload?: RuntimeStoryChoicePayload;
+    snapshot?: RuntimeStorySnapshotRequest;
+  },
+  options: RpgRuntimeStoryClientOptions = {},
+) {
+  const response = await requestRuntimeStoryJson<RuntimeStoryResponse>(
+    '/actions/resolve',
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        sessionId: params.sessionId || DEFAULT_SESSION_ID,
+        clientVersion: params.clientVersion,
+        action: {
+          type: 'story_choice',
+          functionId: params.option.functionId,
+          targetId: params.targetId,
+          payload: {
+            optionText: params.option.actionText,
+            ...(params.payload ?? {}),
+          },
+        },
+        snapshot: params.snapshot,
+      } satisfies RuntimeStoryActionRequest),
+    },
+    '执行运行时动作失败',
+    options,
+  );
+
+  return {
+    ...response,
+    snapshot: rehydrateSavedSnapshot(
+      response.snapshot as HydratedSavedGameSnapshot,
+    ),
+  } satisfies RuntimeStoryResponse;
+}
+
+export function getRuntimeActionSnapshot(response: RuntimeStoryResponse) {
+  return rehydrateSavedSnapshot(response.snapshot as HydratedSavedGameSnapshot);
+}
+
+export const getRpgRuntimeActionSnapshot = getRuntimeActionSnapshot;
+export const getRpgRuntimeClientVersion = getRuntimeClientVersion;
+export const getRpgRuntimeSessionId = getRuntimeSessionId;
+export const getRpgRuntimeStoryState = getRuntimeStoryState;
+export const isRpgRuntimeServerFunctionId = isServerRuntimeFunctionId;
+export const isRpgRuntimeTaskFunctionId = isTask5RuntimeFunctionId;
+export const resolveRpgRuntimeStoryAction = resolveRuntimeStoryAction;
+export const resolveRpgRuntimeStoryMoment = resolveRuntimeStoryMoment;
+export const shouldUseRpgRuntimeServerOptions = shouldUseServerRuntimeOptions;
+
+export const rpgRuntimeStoryClient = {
+  getActionSnapshot: getRpgRuntimeActionSnapshot,
+  getClientVersion: getRpgRuntimeClientVersion,
+  getSessionId: getRpgRuntimeSessionId,
+  getState: getRpgRuntimeStoryState,
+  resolveAction: resolveRpgRuntimeStoryAction,
+  resolveMoment: resolveRpgRuntimeStoryMoment,
+  shouldUseServerOptions: shouldUseRpgRuntimeServerOptions,
+};