GenarrativeAI/Genarrative
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Integrate unfinished server-rs refactor worklists

Browse Source
This commit is contained in:
kdletters
2026-04-30 13:39:06 +08:00
parent 62934b0809
commit 7ab0933f6d
676 changed files with 24487 additions and 21531 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/services/rpg-runtime/index.ts
View File

@@ -8,10 +8,15 @@ export {
streamRpgNpcRecruitDialogue,
} from './rpgRuntimeChatClient';
export {
beginRpgStorySession,
getRpgRuntimeActionSnapshot,
getRpgRuntimeClientVersion,
getRpgRuntimeSessionId,
getRpgRuntimeStorySessionId,
getRpgRuntimeStoryState,
continueRpgStorySession,
getRpgStoryRuntimeProjection,
getRpgStorySessionState,
isRpgRuntimeServerFunctionId,
isRpgRuntimeTaskFunctionId,
loadRpgRuntimeInventoryView,
@@ -21,7 +26,10 @@ export {
type RpgRuntimeStoryClientOptions,
type RuntimeStoryChoicePayload,
type RuntimeStoryInventoryView,
type RuntimeStoryProjectionResult,
type RuntimeStoryResponse,
type StorySessionMutationResult,
type StorySessionStateResult,
shouldUseRpgRuntimeServerOptions,
} from './rpgRuntimeStoryClient';
export {

5
src/services/rpg-runtime/rpgRuntimeRequest.ts
View File

@@ -35,9 +35,12 @@ export function requestRpgRuntimeJson<T>(
const retry =
options.retry ??
(method === 'GET' ? RUNTIME_READ_RETRY : RUNTIME_WRITE_RETRY);
const normalizedPath = path.startsWith('/profile/')
? `/api${path}`
: `${RUNTIME_API_BASE}${path}`;
return requestJson<T>(
`${RUNTIME_API_BASE}${path}`,
normalizedPath,
{
...init,
signal: options.signal,

443
src/services/rpg-runtime/rpgRuntimeStoryClient.test.ts
View File

@@ -15,14 +15,19 @@ vi.mock('../apiClient', async () => {
import { AnimationState } from '../../types';
import {
beginRpgStorySession,
beginRpgRuntimeStorySession,
buildStoryMomentFromRuntimeOptions,
continueRpgStorySession,
getRpgStorySessionState,
getRpgRuntimeClientVersion,
getRpgRuntimeSessionId,
getRpgRuntimeStorySessionId,
getRpgRuntimeStoryState,
isRpgRuntimeServerFunctionId,
isRpgRuntimeTaskFunctionId,
loadRpgRuntimeInventoryView,
resolveRpgRuntimeStoryProjectionMoment,
resolveRpgRuntimeStoryAction,
resolveRpgRuntimeStoryMoment,
shouldUseRpgRuntimeServerOptions,
@@ -33,6 +38,134 @@ describe('rpgRuntimeStoryClient', () => {
requestJsonMock.mockReset();
});
it('creates story sessions through the new story session endpoint', async () => {
requestJsonMock.mockResolvedValue({
storySession: {
storySessionId: 'storysess-main',
runtimeSessionId: 'runtime-main',
actorUserId: 'user-1',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: '营地开场',
latestNarrativeText: '篝火正在燃烧。',
latestChoiceFunctionId: null,
status: 'active',
version: 1,
createdAt: '2026-04-29T00:00:00.000Z',
updatedAt: '2026-04-29T00:00:00.000Z',
},
storyEvent: {
eventId: 'storyevt-main',
storySessionId: 'storysess-main',
eventKind: 'session_started',
narrativeText: '篝火正在燃烧。',
choiceFunctionId: null,
createdAt: '2026-04-29T00:00:00.000Z',
},
});
const result = await beginRpgStorySession({
runtimeSessionId: 'runtime-main',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: '营地开场',
});
expect(result.storySession.storySessionId).toBe('storysess-main');
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/story/sessions',
expect.objectContaining({
method: 'POST',
body: JSON.stringify({
runtimeSessionId: 'runtime-main',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: '营地开场',
}),
}),
'创建故事会话失败',
expect.any(Object),
);
});
it('continues story sessions through the new story session endpoint', async () => {
requestJsonMock.mockResolvedValue({
storySession: {
storySessionId: 'storysess-main',
runtimeSessionId: 'runtime-main',
actorUserId: 'user-1',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: null,
latestNarrativeText: '你继续向前。',
latestChoiceFunctionId: 'story_continue',
status: 'active',
version: 2,
createdAt: '2026-04-29T00:00:00.000Z',
updatedAt: '2026-04-29T00:00:01.000Z',
},
storyEvent: {
eventId: 'storyevt-next',
storySessionId: 'storysess-main',
eventKind: 'story_continued',
narrativeText: '你继续向前。',
choiceFunctionId: 'story_continue',
createdAt: '2026-04-29T00:00:01.000Z',
},
});
await continueRpgStorySession({
storySessionId: ' storysess-main ',
narrativeText: '你继续向前。',
choiceFunctionId: 'story_continue',
});
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/story/sessions/continue',
expect.objectContaining({
method: 'POST',
body: JSON.stringify({
storySessionId: 'storysess-main',
narrativeText: '你继续向前。',
choiceFunctionId: 'story_continue',
}),
}),
'继续故事会话失败',
expect.any(Object),
);
});
it('reads story session state through the new state endpoint', async () => {
requestJsonMock.mockResolvedValue({
storySession: {
storySessionId: 'storysess-main',
runtimeSessionId: 'runtime-main',
actorUserId: 'user-1',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: null,
latestNarrativeText: '服务端故事',
latestChoiceFunctionId: null,
status: 'active',
version: 3,
createdAt: '2026-04-29T00:00:00.000Z',
updatedAt: '2026-04-29T00:00:02.000Z',
},
storyEvents: [],
});
await getRpgStorySessionState({ storySessionId: ' storysess-main ' });
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/story/sessions/storysess-main/state',
expect.objectContaining({
method: 'GET',
}),
'读取故事会话状态失败',
expect.any(Object),
);
});
it('starts runtime sessions through the backend bootstrap endpoint', async () => {
requestJsonMock.mockResolvedValue({
sessionId: 'runtime-server-1',
@@ -185,145 +318,180 @@ describe('rpgRuntimeStoryClient', () => {
);
});
it('reads runtime story state by server session id', async () => {
it('reads runtime story state by story session id', async () => {
requestJsonMock.mockResolvedValue({
sessionId: 'runtime-main',
storySession: {
storySessionId: 'storysess-main',
runtimeSessionId: 'runtime-main',
actorUserId: 'user-1',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: null,
latestNarrativeText: '服务端故事',
latestChoiceFunctionId: null,
status: 'active',
version: 4,
createdAt: '2026-04-08T00:00:00.000Z',
updatedAt: '2026-04-08T00:00:00.000Z',
},
storyEvents: [],
serverVersion: 4,
viewModel: {
player: {
hp: 100,
maxHp: 100,
mana: 20,
maxMana: 20,
},
encounter: null,
companions: [],
availableOptions: [],
status: {
inBattle: false,
npcInteractionActive: false,
currentNpcBattleMode: null,
currentNpcBattleOutcome: null,
},
actor: {
hp: 100,
maxHp: 100,
mana: 20,
maxMana: 20,
currency: 0,
currencyText: '0 铜钱',
},
presentation: {
actionText: '',
resultText: '',
storyText: '服务端故事',
options: [],
inventory: {
backpackItems: [],
equipmentSlots: [],
forgeRecipes: [],
},
patches: [],
snapshot: {
version: 2,
savedAt: '2026-04-08T00:00:00.000Z',
bottomTab: 'adventure',
gameState: {},
currentStory: null,
options: [],
status: {
inBattle: false,
npcInteractionActive: false,
currentNpcBattleMode: null,
currentNpcBattleOutcome: null,
},
currentNarrativeText: '服务端故事',
actionResultText: null,
toast: null,
});
await getRpgRuntimeStoryState({
sessionId: 'runtime-main',
storySessionId: 'storysess-main',
clientVersion: 7,
});
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/runtime/story/state/runtime-main',
'/api/story/sessions/storysess-main/runtime-projection',
expect.objectContaining({
method: 'GET',
}),
'读取运行时故事状态失败',
'读取运行时故事投影失败',
expect.any(Object),
);
});
it('loads backend inventory view from runtime story state', async () => {
requestJsonMock.mockResolvedValue({
sessionId: 'runtime-inventory',
serverVersion: 5,
viewModel: {
player: {
hp: 100,
maxHp: 100,
mana: 20,
maxMana: 20,
},
encounter: null,
companions: [],
inventory: {
playerCurrency: 90,
currencyText: '90 铜钱',
inBattle: false,
backpackItems: [],
equipmentSlots: [],
forgeRecipes: [
{
id: 'synthesis-refined-ingot',
name: '压炼锭材',
kind: 'synthesis',
description: '把零散残片和基础材料压成稳定可用的金属锭材。',
resultLabel: '精炼锭材',
currencyCost: 18,
currencyText: '18 铜钱',
requirements: [
{
id: 'material:any',
label: '任意材料',
quantity: 3,
owned: 3,
},
],
canCraft: true,
action: {
functionId: 'forge_craft',
actionText: '制作精炼锭材',
payload: { recipeId: 'synthesis-refined-ingot' },
enabled: true,
},
},
],
},
availableOptions: [],
status: {
inBattle: false,
npcInteractionActive: false,
currentNpcBattleMode: null,
currentNpcBattleOutcome: null,
},
},
presentation: {
actionText: '',
resultText: '',
storyText: '',
options: [],
},
patches: [],
snapshot: {
version: 2,
savedAt: '2026-04-08T00:00:00.000Z',
bottomTab: 'adventure',
it('rejects missing story session id instead of falling back to runtime id', async () => {
expect(() =>
getRpgRuntimeStorySessionId({
storySessionId: '',
}),
).toThrow('运行时故事会话不存在，无法读取服务端投影');
await expect(
loadRpgRuntimeInventoryView({
gameState: {
runtimeSessionId: 'runtime-inventory',
storySessionId: null,
runtimeActionVersion: 5,
},
currentStory: null,
} as never,
}),
).rejects.toThrow('运行时故事会话不存在，无法读取服务端投影');
await expect(
continueRpgStorySession({
storySessionId: '',
narrativeText: '继续',
}),
).rejects.toThrow('故事会话不存在，无法继续故事');
await expect(
getRpgStorySessionState({
storySessionId: '',
}),
).rejects.toThrow('故事会话不存在，无法读取故事会话状态');
expect(requestJsonMock).not.toHaveBeenCalled();
});
it('loads backend inventory view from story runtime projection', async () => {
requestJsonMock.mockResolvedValue({
storySession: {
storySessionId: 'storysess-inventory',
runtimeSessionId: 'runtime-inventory',
actorUserId: 'user-1',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: null,
latestNarrativeText: '背包状态',
latestChoiceFunctionId: null,
status: 'active',
version: 5,
createdAt: '2026-04-08T00:00:00.000Z',
updatedAt: '2026-04-08T00:00:00.000Z',
},
storyEvents: [],
serverVersion: 5,
actor: {
hp: 100,
maxHp: 100,
mana: 20,
maxMana: 20,
currency: 90,
currencyText: '90 铜钱',
},
inventory: {
backpackItems: [],
equipmentSlots: [],
forgeRecipes: [
{
id: 'synthesis-refined-ingot',
name: '压炼锭材',
kind: 'synthesis',
description: '把零散残片和基础材料压成稳定可用的金属锭材。',
resultLabel: '精炼锭材',
currencyCost: 18,
currencyText: '18 铜钱',
requirements: [
{
id: 'material:any',
label: '任意材料',
quantity: 3,
owned: 3,
},
],
canCraft: true,
action: {
functionId: 'forge_craft',
actionText: '制作精炼锭材',
payload: { recipeId: 'synthesis-refined-ingot' },
enabled: true,
},
},
],
},
options: [],
status: {
inBattle: false,
npcInteractionActive: false,
currentNpcBattleMode: null,
currentNpcBattleOutcome: null,
},
currentNarrativeText: '',
actionResultText: null,
toast: null,
});
const view = await loadRpgRuntimeInventoryView({
gameState: {
runtimeSessionId: 'runtime-inventory',
storySessionId: 'storysess-inventory',
runtimeActionVersion: 5,
} as never,
});
expect(view.forgeRecipes[0]?.action.functionId).toBe('forge_craft');
expect(view.playerCurrency).toBe(90);
expect(requestJsonMock).toHaveBeenCalledWith(
'/api/runtime/story/state/runtime-inventory',
'/api/story/sessions/storysess-inventory/runtime-projection',
expect.objectContaining({
method: 'GET',
}),
'读取运行时故事状态失败',
'读取运行时故事投影失败',
expect.any(Object),
);
});
@@ -415,9 +583,78 @@ describe('rpgRuntimeStoryClient', () => {
expect(getRpgRuntimeSessionId({ runtimeSessionId: '' })).toBe(
'runtime-main',
);
expect(getRpgRuntimeStorySessionId({ storySessionId: ' storysess-1 ' })).toBe(
'storysess-1',
);
expect(getRpgRuntimeClientVersion({ runtimeActionVersion: 3 })).toBe(3);
});
it('builds story moments from story runtime projection options', () => {
const story = resolveRpgRuntimeStoryProjectionMoment({
projection: {
storySession: {
storySessionId: 'storysess-main',
runtimeSessionId: 'runtime-main',
actorUserId: 'user-1',
worldProfileId: 'profile-1',
initialPrompt: '进入营地',
openingSummary: null,
latestNarrativeText: '兜底故事',
latestChoiceFunctionId: null,
status: 'active',
version: 5,
createdAt: '2026-04-08T00:00:00.000Z',
updatedAt: '2026-04-08T00:00:00.000Z',
},
storyEvents: [],
serverVersion: 5,
actor: {
hp: 100,
maxHp: 100,
mana: 20,
maxMana: 20,
currency: 0,
currencyText: '0 铜钱',
},
inventory: {
backpackItems: [],
equipmentSlots: [],
forgeRecipes: [],
},
options: [
{
functionId: 'npc_chat',
actionText: '继续交谈',
detailText: '推进当前话题',
scope: 'npc',
payload: { npcId: 'npc-merchant' },
enabled: false,
reason: '对方暂时不想说话',
},
],
status: {
inBattle: false,
npcInteractionActive: true,
currentNpcBattleMode: null,
currentNpcBattleOutcome: null,
},
currentNarrativeText: '服务端投影故事',
actionResultText: null,
toast: null,
},
});
expect(story.text).toBe('服务端投影故事');
expect(story.options[0]).toEqual(
expect.objectContaining({
functionId: 'npc_chat',
actionText: '继续交谈',
disabled: true,
disabledReason: '对方暂时不想说话',
}),
);
});
it('preserves runtime option interaction metadata from the server response', () => {
const story = buildStoryMomentFromRuntimeOptions({
storyText: '服务端返回的新故事',

231
src/services/rpg-runtime/rpgRuntimeStoryClient.ts
View File

@@ -14,6 +14,14 @@ import type {
RuntimeStoryBootstrapResponse,
RuntimeStoryOptionView,
} from '../../../packages/shared/src/contracts/rpgRuntimeStoryState';
import type {
BeginStorySessionRequest,
ContinueStoryRequest,
StorySessionMutationResponse,
StorySessionStateResponse,
StoryRuntimeOptionProjection,
StoryRuntimeProjectionResponse,
} from '../../../packages/shared/src/contracts/story';
import { rehydrateSavedSnapshot } from '../../persistence/runtimeSnapshot';
import type { HydratedSavedGameSnapshot } from '../../persistence/runtimeSnapshotTypes';
import type { GameState, StoryMoment, StoryOption } from '../../types';
@@ -21,6 +29,7 @@ import { AnimationState } from '../../types';
import { type ApiRetryOptions, requestJson } from '../apiClient';
const RUNTIME_STORY_API_BASE = '/api/runtime/story';
const STORY_SESSIONS_API_BASE = '/api/story/sessions';
const DEFAULT_SESSION_ID = 'runtime-main';
const RUNTIME_STORY_RETRY: ApiRetryOptions = {
maxRetries: 1,
@@ -49,6 +58,9 @@ export type RuntimeStoryBootstrapResult = RuntimeStoryBootstrapResponse<
GameState,
StoryMoment
>;
export type StorySessionMutationResult = StorySessionMutationResponse;
export type StorySessionStateResult = StorySessionStateResponse;
export type RuntimeStoryProjectionResult = StoryRuntimeProjectionResponse;
export type RuntimeStoryInventoryView =
RuntimeStoryResponse['viewModel']['inventory'];
export type { RuntimeStoryChoicePayload };
@@ -72,6 +84,23 @@ function requestRuntimeStoryJson<T>(
);
}
function requestStorySessionJson<T>(
path: string,
init: RequestInit,
fallbackMessage: string,
options: RpgRuntimeStoryClientOptions = {},
) {
return requestJson<T>(
`${STORY_SESSIONS_API_BASE}${path}`,
{
...init,
signal: options.signal,
},
fallbackMessage,
{ retry: options.retry ?? RUNTIME_STORY_RETRY },
);
}
function createRuntimeStoryOption(
option: RuntimeStoryOptionView,
_gameState?: Pick<GameState, 'currentEncounter'>,
@@ -98,12 +127,84 @@ function createRuntimeStoryOption(
};
}
function normalizeProjectionOptionScope(
scope: string,
): RuntimeStoryOptionView['scope'] {
return scope === 'combat' || scope === 'npc' ? scope : 'story';
}
function mapRuntimeProjectionOption(
option: StoryRuntimeOptionProjection,
): RuntimeStoryOptionView {
return {
functionId: option.functionId,
actionText: option.actionText,
detailText: option.detailText ?? undefined,
scope: normalizeProjectionOptionScope(option.scope),
payload: option.payload ?? undefined,
disabled: option.enabled ? undefined : true,
reason: option.enabled ? undefined : (option.reason ?? undefined),
};
}
function mapRuntimeProjectionInventory(
projection: StoryRuntimeProjectionResponse,
): RuntimeStoryInventoryView {
return {
playerCurrency: projection.actor.currency,
currencyText: projection.actor.currencyText,
inBattle: projection.status.inBattle,
backpackItems:
projection.inventory
.backpackItems as RuntimeStoryInventoryView['backpackItems'],
equipmentSlots:
projection.inventory
.equipmentSlots as RuntimeStoryInventoryView['equipmentSlots'],
forgeRecipes:
projection.inventory
.forgeRecipes as RuntimeStoryInventoryView['forgeRecipes'],
};
}
function getRuntimeProjectionStoryText(
projection: Pick<
StoryRuntimeProjectionResponse,
'currentNarrativeText' | 'storySession'
>,
) {
return (
projection.currentNarrativeText?.trim() ||
projection.storySession.latestNarrativeText.trim()
);
}
export function getRuntimeSessionId(
gameState: Pick<GameState, 'runtimeSessionId'>,
) {
return gameState.runtimeSessionId?.trim() || DEFAULT_SESSION_ID;
}
export function getRuntimeStorySessionId(
gameState: Pick<GameState, 'storySessionId'>,
) {
return normalizeStorySessionId(
gameState.storySessionId,
'运行时故事会话不存在，无法读取服务端投影',
);
}
function normalizeStorySessionId(
storySessionId: string | null | undefined,
message: string,
) {
const normalizedStorySessionId = storySessionId?.trim();
if (!normalizedStorySessionId) {
throw new Error(message);
}
return normalizedStorySessionId;
}
export function getRuntimeClientVersion(
gameState: Pick<GameState, 'runtimeActionVersion'>,
) {
@@ -146,6 +247,17 @@ export function buildStoryMomentFromRuntimeOptions(params: {
} satisfies StoryMoment;
}
export function buildStoryMomentFromRuntimeProjection(params: {
projection: StoryRuntimeProjectionResponse;
gameState?: Pick<GameState, 'currentEncounter'>;
}): StoryMoment {
return buildStoryMomentFromRuntimeOptions({
storyText: getRuntimeProjectionStoryText(params.projection),
options: params.projection.options.map(mapRuntimeProjectionOption),
gameState: params.gameState,
});
}
function shouldPreferSnapshotStory(story: StoryMoment | null) {
return Boolean(
story &&
@@ -185,48 +297,114 @@ export function resolveRuntimeStoryMoment(params: {
});
}
export async function getRuntimeStoryState(
export async function beginStorySession(
params: BeginStorySessionRequest,
options: RpgRuntimeStoryClientOptions = {},
) {
return requestStorySessionJson<StorySessionMutationResult>(
'',
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(params),
},
'创建故事会话失败',
options,
);
}
export async function continueStorySession(
params: ContinueStoryRequest,
options: RpgRuntimeStoryClientOptions = {},
) {
const storySessionId = normalizeStorySessionId(
params.storySessionId,
'故事会话不存在，无法继续故事',
);
return requestStorySessionJson<StorySessionMutationResult>(
'/continue',
{
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
...params,
storySessionId,
}),
},
'继续故事会话失败',
options,
);
}
export async function getStorySessionState(
params: { storySessionId: string },
options: RpgRuntimeStoryClientOptions = {},
) {
const storySessionId = normalizeStorySessionId(
params.storySessionId,
'故事会话不存在，无法读取故事会话状态',
);
return requestStorySessionJson<StorySessionStateResult>(
`/${encodeURIComponent(storySessionId)}/state`,
{ method: 'GET' },
'读取故事会话状态失败',
options,
);
}
export async function getStoryRuntimeProjection(
params: {
sessionId: string;
storySessionId: string;
clientVersion?: number;
},
options: RpgRuntimeStoryClientOptions = {},
) {
const normalizedSessionId = params.sessionId || DEFAULT_SESSION_ID;
// 中文注释：runtime story 状态读取只按服务端持久化 sessionId 拉取，
// 不再允许前端上传本地 GameState 快照参与解析。
const response = await requestRuntimeStoryJson<RuntimeStoryResponse>(
`/state/${encodeURIComponent(normalizedSessionId)}`,
{ method: 'GET' },
'读取运行时故事状态失败',
options,
const storySessionId = normalizeStorySessionId(
params.storySessionId,
'运行时故事会话不存在，无法读取服务端投影',
);
return {
...response,
snapshot: rehydrateSavedSnapshot(
response.snapshot as HydratedSavedGameSnapshot,
),
} satisfies RuntimeStoryResponse;
// 中文注释：当前 BFF route 以 storySessionId 为唯一读取键；
// clientVersion 保留在调用签名里，等待后端增量投影契约稳定后再接查询参数。
return requestStorySessionJson<RuntimeStoryProjectionResult>(
`/${encodeURIComponent(storySessionId)}/runtime-projection`,
{ method: 'GET' },
'读取运行时故事投影失败',
options,
);
}
export async function getRuntimeStoryState(
params: {
storySessionId: string;
clientVersion?: number;
},
options: RpgRuntimeStoryClientOptions = {},
) {
// 中文注释：读取侧正式切到 story session scoped 投影；
// 这里不允许用 runtimeSessionId 兜底，避免两个会话主键被悄悄混用。
return getStoryRuntimeProjection(params, options);
}
export async function loadRuntimeInventoryView(
params: {
gameState: Pick<GameState, 'runtimeSessionId' | 'runtimeActionVersion'>;
gameState: Pick<GameState, 'storySessionId' | 'runtimeActionVersion'>;
},
options: RpgRuntimeStoryClientOptions = {},
) {
// 中文注释：背包 / 装备 / 锻造 view 只读取后端已持久化的 runtime session；
// 中文注释：背包 / 装备 / 锻造 view 只读取 story runtime 投影；
// 前端不再用本地背包、货币或装备状态重算配方可用性。
const response = await getRuntimeStoryState(
{
sessionId: getRuntimeSessionId(params.gameState),
storySessionId: getRuntimeStorySessionId(params.gameState),
clientVersion: getRuntimeClientVersion(params.gameState),
},
options,
);
return response.viewModel.inventory;
return mapRuntimeProjectionInventory(response);
}
export async function beginRuntimeStorySession(
@@ -303,25 +481,38 @@ export function getRuntimeActionSnapshot(response: RuntimeStoryResponse) {
}
export const beginRpgRuntimeStorySession = beginRuntimeStorySession;
export const beginRpgStorySession = beginStorySession;
export const continueRpgStorySession = continueStorySession;
export const getRpgStoryRuntimeProjection = getStoryRuntimeProjection;
export const getRpgStorySessionState = getStorySessionState;
export const getRpgRuntimeActionSnapshot = getRuntimeActionSnapshot;
export const getRpgRuntimeClientVersion = getRuntimeClientVersion;
export const getRpgRuntimeSessionId = getRuntimeSessionId;
export const getRpgRuntimeStorySessionId = getRuntimeStorySessionId;
export const getRpgRuntimeStoryState = getRuntimeStoryState;
export const isRpgRuntimeServerFunctionId = isServerRuntimeFunctionId;
export const isRpgRuntimeTaskFunctionId = isTask5RuntimeFunctionId;
export const loadRpgRuntimeInventoryView = loadRuntimeInventoryView;
export const resolveRpgRuntimeStoryAction = resolveRuntimeStoryAction;
export const resolveRpgRuntimeStoryProjectionMoment =
buildStoryMomentFromRuntimeProjection;
export const resolveRpgRuntimeStoryMoment = resolveRuntimeStoryMoment;
export const shouldUseRpgRuntimeServerOptions = shouldUseServerRuntimeOptions;
export const rpgRuntimeStoryClient = {
beginSession: beginRpgRuntimeStorySession,
beginStorySession: beginRpgStorySession,
continueStorySession: continueRpgStorySession,
getActionSnapshot: getRpgRuntimeActionSnapshot,
getClientVersion: getRpgRuntimeClientVersion,
getInventoryView: loadRpgRuntimeInventoryView,
getSessionId: getRpgRuntimeSessionId,
getStoryRuntimeProjection: getRpgStoryRuntimeProjection,
getStorySessionId: getRpgRuntimeStorySessionId,
getStorySessionState: getRpgStorySessionState,
getState: getRpgRuntimeStoryState,
resolveAction: resolveRpgRuntimeStoryAction,
resolveProjectionMoment: resolveRpgRuntimeStoryProjectionMoment,
resolveMoment: resolveRpgRuntimeStoryMoment,
shouldUseServerOptions: shouldUseRpgRuntimeServerOptions,
};