3739 lines
134 KiB
Rust
3739 lines
134 KiB
Rust
use axum::{
|
||
Json,
|
||
extract::{Extension, Path, State},
|
||
http::StatusCode,
|
||
response::Response,
|
||
};
|
||
use module_runtime::RuntimeSnapshotRecord;
|
||
use platform_llm::{LlmMessage, LlmTextRequest};
|
||
use serde_json::{Map, Value, json};
|
||
use shared_contracts::runtime_story::{
|
||
RuntimeBattlePresentation, RuntimeStoryActionRequest, RuntimeStoryActionResponse,
|
||
RuntimeStoryAiRequest, RuntimeStoryAiResponse, RuntimeStoryCompanionViewModel,
|
||
RuntimeStoryEncounterViewModel, RuntimeStoryOptionInteraction, RuntimeStoryOptionView,
|
||
RuntimeStoryPatch, RuntimeStoryPlayerViewModel, RuntimeStoryPresentation,
|
||
RuntimeStorySnapshotPayload, RuntimeStoryStateResolveRequest, RuntimeStoryStatusViewModel,
|
||
RuntimeStoryViewModel,
|
||
};
|
||
use shared_kernel::{format_rfc3339, offset_datetime_to_unix_micros, parse_rfc3339};
|
||
use spacetime_client::SpacetimeClientError;
|
||
use time::OffsetDateTime;
|
||
|
||
use crate::{
|
||
api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
|
||
request_context::RequestContext, state::AppState,
|
||
};
|
||
|
||
const CONTINUE_ADVENTURE_FUNCTION_ID: &str = "story_continue_adventure";
|
||
const MAX_TASK5_COMPANIONS: usize = 2;
|
||
|
||
struct StoryResolution {
|
||
action_text: String,
|
||
result_text: String,
|
||
story_text: Option<String>,
|
||
presentation_options: Option<Vec<RuntimeStoryOptionView>>,
|
||
saved_current_story: Option<Value>,
|
||
patches: Vec<RuntimeStoryPatch>,
|
||
battle: Option<RuntimeBattlePresentation>,
|
||
toast: Option<String>,
|
||
}
|
||
|
||
struct CurrentEncounterNpcQuestContext {
|
||
npc_id: String,
|
||
npc_name: String,
|
||
}
|
||
|
||
struct PendingQuestOfferContext {
|
||
dialogue: Vec<Value>,
|
||
turn_count: i32,
|
||
custom_input_placeholder: String,
|
||
quest: Value,
|
||
quest_id: String,
|
||
intro_text: Option<String>,
|
||
}
|
||
|
||
pub async fn resolve_runtime_story_state(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
||
Json(payload): Json<RuntimeStoryStateResolveRequest>,
|
||
) -> Result<Json<Value>, Response> {
|
||
let session_id = normalize_required_string(payload.session_id.as_str()).ok_or_else(|| {
|
||
runtime_story_error_response(
|
||
&request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"field": "sessionId",
|
||
"message": "sessionId 不能为空",
|
||
})),
|
||
)
|
||
})?;
|
||
let snapshot = resolve_snapshot_for_request(
|
||
&state,
|
||
&request_context,
|
||
authenticated.claims().user_id().to_string(),
|
||
payload.snapshot,
|
||
)
|
||
.await?;
|
||
|
||
validate_client_version(
|
||
&request_context,
|
||
payload.client_version,
|
||
&snapshot.game_state,
|
||
"运行时版本已变化，请先同步最新快照后再读取状态",
|
||
)?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
build_runtime_story_state_response(&session_id, payload.client_version, snapshot),
|
||
))
|
||
}
|
||
|
||
pub async fn get_runtime_story_state(
|
||
State(state): State<AppState>,
|
||
Path(session_id): Path<String>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
||
) -> Result<Json<Value>, Response> {
|
||
let session_id = normalize_required_string(session_id.as_str()).ok_or_else(|| {
|
||
runtime_story_error_response(
|
||
&request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"field": "sessionId",
|
||
"message": "sessionId 不能为空",
|
||
})),
|
||
)
|
||
})?;
|
||
let snapshot = resolve_snapshot_for_request(
|
||
&state,
|
||
&request_context,
|
||
authenticated.claims().user_id().to_string(),
|
||
None,
|
||
)
|
||
.await?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
build_runtime_story_state_response(&session_id, None, snapshot),
|
||
))
|
||
}
|
||
|
||
pub async fn resolve_runtime_story_action(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
||
Json(payload): Json<RuntimeStoryActionRequest>,
|
||
) -> Result<Json<Value>, Response> {
|
||
let requested_session_id =
|
||
normalize_required_string(payload.session_id.as_str()).ok_or_else(|| {
|
||
runtime_story_error_response(
|
||
&request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"field": "sessionId",
|
||
"message": "sessionId 不能为空",
|
||
})),
|
||
)
|
||
})?;
|
||
let function_id =
|
||
normalize_required_string(payload.action.function_id.as_str()).ok_or_else(|| {
|
||
runtime_story_error_response(
|
||
&request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"field": "action.functionId",
|
||
"message": "functionId 不能为空",
|
||
})),
|
||
)
|
||
})?;
|
||
if payload.action.action_type.trim() != "story_choice" {
|
||
return Err(runtime_story_error_response(
|
||
&request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"field": "action.type",
|
||
"message": "runtime story 当前只支持 story_choice 动作",
|
||
})),
|
||
));
|
||
}
|
||
|
||
let mut snapshot = resolve_snapshot_for_request(
|
||
&state,
|
||
&request_context,
|
||
authenticated.claims().user_id().to_string(),
|
||
payload.snapshot.clone(),
|
||
)
|
||
.await?;
|
||
validate_client_version(
|
||
&request_context,
|
||
payload.client_version,
|
||
&snapshot.game_state,
|
||
"运行时版本已变化，请先同步最新快照后再提交动作",
|
||
)?;
|
||
|
||
let current_story_before = snapshot.current_story.clone();
|
||
let mut game_state = snapshot.game_state.clone();
|
||
let mut resolution = resolve_runtime_story_choice_action(
|
||
&mut game_state,
|
||
current_story_before.as_ref(),
|
||
&payload,
|
||
&function_id,
|
||
)
|
||
.map_err(|message| {
|
||
runtime_story_error_response(
|
||
&request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"message": message,
|
||
})),
|
||
)
|
||
})?;
|
||
|
||
let server_version = read_u32_field(&game_state, "runtimeActionVersion")
|
||
.unwrap_or(0)
|
||
.saturating_add(1);
|
||
write_u32_field(&mut game_state, "runtimeActionVersion", server_version);
|
||
write_string_field(
|
||
&mut game_state,
|
||
"runtimeSessionId",
|
||
requested_session_id.as_str(),
|
||
);
|
||
|
||
let mut options = resolution
|
||
.presentation_options
|
||
.take()
|
||
.unwrap_or_else(|| build_fallback_runtime_story_options(&game_state));
|
||
if options.is_empty() {
|
||
options = build_fallback_runtime_story_options(&game_state);
|
||
}
|
||
|
||
let story_text = resolution
|
||
.story_text
|
||
.clone()
|
||
.unwrap_or_else(|| resolution.result_text.clone());
|
||
let saved_current_story = resolution
|
||
.saved_current_story
|
||
.take()
|
||
.unwrap_or_else(|| build_legacy_current_story(story_text.as_str(), &options));
|
||
append_story_history(
|
||
&mut game_state,
|
||
resolution.action_text.as_str(),
|
||
resolution.result_text.as_str(),
|
||
);
|
||
|
||
let mut patches = vec![RuntimeStoryPatch::StoryHistoryAppend {
|
||
action_text: resolution.action_text.clone(),
|
||
result_text: resolution.result_text.clone(),
|
||
}];
|
||
patches.extend(resolution.patches);
|
||
|
||
snapshot.saved_at = Some(format_now_rfc3339());
|
||
snapshot.game_state = game_state;
|
||
snapshot.current_story = Some(saved_current_story);
|
||
let persisted = persist_runtime_story_snapshot(
|
||
&state,
|
||
&request_context,
|
||
authenticated.claims().user_id().to_string(),
|
||
snapshot,
|
||
)
|
||
.await?;
|
||
let persisted_snapshot = runtime_snapshot_payload_from_record(&persisted);
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
build_runtime_story_action_response(RuntimeStoryActionResponseParts {
|
||
requested_session_id,
|
||
server_version,
|
||
snapshot: persisted_snapshot,
|
||
action_text: resolution.action_text,
|
||
result_text: resolution.result_text,
|
||
story_text,
|
||
options,
|
||
patches,
|
||
toast: resolution.toast,
|
||
battle: resolution.battle,
|
||
}),
|
||
))
|
||
}
|
||
|
||
pub async fn generate_runtime_story_initial(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(_authenticated): Extension<AuthenticatedAccessToken>,
|
||
Json(payload): Json<RuntimeStoryAiRequest>,
|
||
) -> Result<Json<Value>, Response> {
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
build_runtime_story_ai_response(&state, payload, true).await,
|
||
))
|
||
}
|
||
|
||
pub async fn generate_runtime_story_continue(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(_authenticated): Extension<AuthenticatedAccessToken>,
|
||
Json(payload): Json<RuntimeStoryAiRequest>,
|
||
) -> Result<Json<Value>, Response> {
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
build_runtime_story_ai_response(&state, payload, false).await,
|
||
))
|
||
}
|
||
|
||
async fn resolve_snapshot_for_request(
|
||
state: &AppState,
|
||
request_context: &RequestContext,
|
||
user_id: String,
|
||
snapshot: Option<RuntimeStorySnapshotPayload>,
|
||
) -> Result<RuntimeStorySnapshotPayload, Response> {
|
||
if let Some(snapshot) = snapshot {
|
||
let record =
|
||
persist_runtime_story_snapshot(state, request_context, user_id, snapshot).await?;
|
||
return Ok(runtime_snapshot_payload_from_record(&record));
|
||
}
|
||
|
||
let record = state
|
||
.get_runtime_snapshot_record(user_id)
|
||
.await
|
||
.map_err(|error| {
|
||
runtime_story_error_response(request_context, map_runtime_story_client_error(error))
|
||
})?
|
||
.ok_or_else(|| {
|
||
runtime_story_error_response(
|
||
request_context,
|
||
AppError::from_status(StatusCode::CONFLICT).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"message": "运行时快照不存在，请先初始化并保存一次游戏",
|
||
})),
|
||
)
|
||
})?;
|
||
|
||
Ok(runtime_snapshot_payload_from_record(&record))
|
||
}
|
||
|
||
async fn persist_runtime_story_snapshot(
|
||
state: &AppState,
|
||
request_context: &RequestContext,
|
||
user_id: String,
|
||
snapshot: RuntimeStorySnapshotPayload,
|
||
) -> Result<RuntimeSnapshotRecord, Response> {
|
||
validate_snapshot_payload(&snapshot).map_err(|message| {
|
||
runtime_story_error_response(
|
||
request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"message": message,
|
||
})),
|
||
)
|
||
})?;
|
||
|
||
let now = OffsetDateTime::now_utc();
|
||
let saved_at = snapshot
|
||
.saved_at
|
||
.as_deref()
|
||
.and_then(|value| normalize_required_string(value))
|
||
.map(|value| parse_rfc3339(value.as_str()))
|
||
.transpose()
|
||
.map_err(|error| {
|
||
runtime_story_error_response(
|
||
request_context,
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"field": "snapshot.savedAt",
|
||
"message": format!("savedAt 非法: {error}"),
|
||
})),
|
||
)
|
||
})?
|
||
.unwrap_or(now);
|
||
|
||
state
|
||
.put_runtime_snapshot_record(
|
||
user_id,
|
||
offset_datetime_to_unix_micros(saved_at),
|
||
snapshot.bottom_tab,
|
||
snapshot.game_state,
|
||
snapshot.current_story,
|
||
offset_datetime_to_unix_micros(now),
|
||
)
|
||
.await
|
||
.map_err(|error| {
|
||
runtime_story_error_response(request_context, map_runtime_story_client_error(error))
|
||
})
|
||
}
|
||
|
||
fn validate_snapshot_payload(snapshot: &RuntimeStorySnapshotPayload) -> Result<(), String> {
|
||
if normalize_required_string(snapshot.bottom_tab.as_str()).is_none() {
|
||
return Err("snapshot.bottomTab 不能为空".to_string());
|
||
}
|
||
if !snapshot.game_state.is_object() {
|
||
return Err("snapshot.gameState 必须是 JSON object".to_string());
|
||
}
|
||
if snapshot
|
||
.current_story
|
||
.as_ref()
|
||
.is_some_and(|current_story| !current_story.is_object())
|
||
{
|
||
return Err("snapshot.currentStory 必须是 JSON object 或 null".to_string());
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn runtime_snapshot_payload_from_record(
|
||
record: &RuntimeSnapshotRecord,
|
||
) -> RuntimeStorySnapshotPayload {
|
||
RuntimeStorySnapshotPayload {
|
||
saved_at: Some(record.saved_at.clone()),
|
||
bottom_tab: record.bottom_tab.clone(),
|
||
game_state: record.game_state.clone(),
|
||
current_story: record.current_story.clone(),
|
||
}
|
||
}
|
||
|
||
fn validate_client_version(
|
||
request_context: &RequestContext,
|
||
client_version: Option<u32>,
|
||
game_state: &Value,
|
||
message: &str,
|
||
) -> Result<(), Response> {
|
||
let Some(client_version) = client_version else {
|
||
return Ok(());
|
||
};
|
||
let Some(server_version) = read_u32_field(game_state, "runtimeActionVersion") else {
|
||
return Ok(());
|
||
};
|
||
if client_version == server_version {
|
||
return Ok(());
|
||
}
|
||
|
||
Err(runtime_story_error_response(
|
||
request_context,
|
||
AppError::from_status(StatusCode::CONFLICT).with_details(json!({
|
||
"provider": "runtime-story",
|
||
"message": message,
|
||
"clientVersion": client_version,
|
||
"serverVersion": server_version,
|
||
})),
|
||
))
|
||
}
|
||
|
||
fn build_runtime_story_state_response(
|
||
requested_session_id: &str,
|
||
client_version: Option<u32>,
|
||
snapshot: RuntimeStorySnapshotPayload,
|
||
) -> RuntimeStoryActionResponse {
|
||
let session_id = read_runtime_session_id(&snapshot.game_state)
|
||
.unwrap_or_else(|| requested_session_id.to_string());
|
||
let options =
|
||
build_runtime_story_options(snapshot.current_story.as_ref(), &snapshot.game_state);
|
||
let story_text = read_story_text(snapshot.current_story.as_ref())
|
||
.unwrap_or_else(|| build_fallback_story_text(&snapshot.game_state));
|
||
let server_version = read_u32_field(&snapshot.game_state, "runtimeActionVersion")
|
||
.or(client_version)
|
||
.unwrap_or(0);
|
||
|
||
build_runtime_story_action_response(RuntimeStoryActionResponseParts {
|
||
requested_session_id: session_id,
|
||
server_version,
|
||
snapshot,
|
||
action_text: String::new(),
|
||
result_text: String::new(),
|
||
story_text,
|
||
options,
|
||
patches: Vec::new(),
|
||
toast: None,
|
||
battle: None,
|
||
})
|
||
}
|
||
|
||
struct RuntimeStoryActionResponseParts {
|
||
requested_session_id: String,
|
||
server_version: u32,
|
||
snapshot: RuntimeStorySnapshotPayload,
|
||
action_text: String,
|
||
result_text: String,
|
||
story_text: String,
|
||
options: Vec<RuntimeStoryOptionView>,
|
||
patches: Vec<RuntimeStoryPatch>,
|
||
toast: Option<String>,
|
||
battle: Option<RuntimeBattlePresentation>,
|
||
}
|
||
|
||
fn build_runtime_story_action_response(
|
||
parts: RuntimeStoryActionResponseParts,
|
||
) -> RuntimeStoryActionResponse {
|
||
let session_id = read_runtime_session_id(&parts.snapshot.game_state)
|
||
.unwrap_or_else(|| parts.requested_session_id);
|
||
|
||
RuntimeStoryActionResponse {
|
||
session_id,
|
||
server_version: parts.server_version,
|
||
view_model: build_runtime_story_view_model(&parts.snapshot.game_state, &parts.options),
|
||
presentation: RuntimeStoryPresentation {
|
||
action_text: parts.action_text,
|
||
result_text: parts.result_text,
|
||
story_text: parts.story_text,
|
||
options: parts.options,
|
||
toast: parts.toast,
|
||
battle: parts.battle,
|
||
},
|
||
patches: parts.patches,
|
||
snapshot: parts.snapshot,
|
||
}
|
||
}
|
||
|
||
fn build_runtime_story_view_model(
|
||
game_state: &Value,
|
||
options: &[RuntimeStoryOptionView],
|
||
) -> RuntimeStoryViewModel {
|
||
RuntimeStoryViewModel {
|
||
player: RuntimeStoryPlayerViewModel {
|
||
hp: read_i32_field(game_state, "playerHp").unwrap_or(0),
|
||
max_hp: read_i32_field(game_state, "playerMaxHp").unwrap_or(1),
|
||
mana: read_i32_field(game_state, "playerMana").unwrap_or(0),
|
||
max_mana: read_i32_field(game_state, "playerMaxMana").unwrap_or(1),
|
||
},
|
||
encounter: build_runtime_story_encounter(game_state),
|
||
companions: build_runtime_story_companions(game_state),
|
||
available_options: options.to_vec(),
|
||
status: RuntimeStoryStatusViewModel {
|
||
in_battle: read_bool_field(game_state, "inBattle").unwrap_or(false),
|
||
npc_interaction_active: read_bool_field(game_state, "npcInteractionActive")
|
||
.unwrap_or(false),
|
||
current_npc_battle_mode: read_optional_string_field(game_state, "currentNpcBattleMode"),
|
||
current_npc_battle_outcome: read_optional_string_field(
|
||
game_state,
|
||
"currentNpcBattleOutcome",
|
||
),
|
||
},
|
||
}
|
||
}
|
||
|
||
fn resolve_runtime_story_choice_action(
|
||
game_state: &mut Value,
|
||
current_story: Option<&Value>,
|
||
request: &RuntimeStoryActionRequest,
|
||
function_id: &str,
|
||
) -> Result<StoryResolution, String> {
|
||
match function_id {
|
||
CONTINUE_ADVENTURE_FUNCTION_ID => resolve_continue_adventure_action(current_story),
|
||
"story_opening_camp_dialogue" => resolve_npc_affinity_action(
|
||
game_state,
|
||
request,
|
||
"交换开场判断",
|
||
2,
|
||
"你把眼前局势先讲清楚，对方终于愿意把第一轮判断说出口。",
|
||
),
|
||
"camp_travel_home_scene" => {
|
||
clear_encounter_state(game_state);
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text("返回营地", request),
|
||
result_text: "你主动结束了当前遭遇，把节奏带回了更安全的营地。".to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![
|
||
build_status_patch(game_state),
|
||
RuntimeStoryPatch::EncounterChanged { encounter_id: None },
|
||
],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
"idle_call_out" => Ok(simple_story_resolution(
|
||
game_state,
|
||
resolve_action_text("主动出声试探", request),
|
||
"你的喊话打破了当前静场，周围潜着的动静也更难继续藏住。",
|
||
)),
|
||
"idle_explore_forward" => Ok(simple_story_resolution(
|
||
game_state,
|
||
resolve_action_text("继续向前探索", request),
|
||
"你没有停在原地，而是继续向前压，把下一段遭遇主动推到自己面前。",
|
||
)),
|
||
"idle_observe_signs" => Ok(simple_story_resolution(
|
||
game_state,
|
||
resolve_action_text("观察周围迹象", request),
|
||
"你先压住动作，把风向、脚印和气味这些细节重新读了一遍。",
|
||
)),
|
||
"idle_rest_focus" => {
|
||
restore_player_resource(game_state, 8, 6);
|
||
Ok(simple_story_resolution(
|
||
game_state,
|
||
resolve_action_text("原地调息", request),
|
||
"你把呼吸慢下来重新稳住节奏，生命和灵力都回上来一点。",
|
||
))
|
||
}
|
||
"idle_travel_next_scene" => {
|
||
clear_encounter_state(game_state);
|
||
increment_runtime_stat(game_state, "scenesTraveled", 1);
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text("前往相邻场景", request),
|
||
result_text: "你收束了这一段遭遇，顺着路线把故事推进到新的场景段落。".to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![
|
||
build_status_patch(game_state),
|
||
RuntimeStoryPatch::EncounterChanged { encounter_id: None },
|
||
],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
"npc_preview_talk" => resolve_npc_preview_action(game_state, request),
|
||
"npc_chat" => resolve_npc_chat_action(game_state, request),
|
||
"npc_help" => resolve_npc_help_action(game_state, request),
|
||
"npc_chat_quest_offer_view" => {
|
||
resolve_pending_quest_offer_view_action(game_state, current_story, request)
|
||
}
|
||
"npc_chat_quest_offer_replace" => {
|
||
resolve_pending_quest_offer_replace_action(game_state, current_story, request)
|
||
}
|
||
"npc_chat_quest_offer_abandon" => {
|
||
resolve_pending_quest_offer_abandon_action(game_state, current_story, request)
|
||
}
|
||
"npc_quest_accept" => {
|
||
resolve_pending_quest_accept_action(game_state, current_story, request)
|
||
}
|
||
"npc_quest_turn_in" => resolve_pending_quest_turn_in_action(game_state, request),
|
||
"npc_leave" => {
|
||
let npc_name = current_encounter_name(game_state);
|
||
clear_encounter_state(game_state);
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text("离开当前角色", request),
|
||
result_text: format!("你结束了与 {npc_name} 的这一轮接触，把注意力重新放回旅途。"),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![
|
||
build_status_patch(game_state),
|
||
RuntimeStoryPatch::EncounterChanged { encounter_id: None },
|
||
],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
"npc_fight" | "npc_spar" => {
|
||
resolve_npc_battle_entry_action(game_state, request, function_id)
|
||
}
|
||
"npc_recruit" => resolve_npc_recruit_action(game_state, request),
|
||
"battle_attack_basic"
|
||
| "battle_use_skill"
|
||
| "battle_all_in_crush"
|
||
| "battle_escape_breakout"
|
||
| "battle_feint_step"
|
||
| "battle_finisher_window"
|
||
| "battle_guard_break"
|
||
| "battle_probe_pressure"
|
||
| "battle_recover_breath" => resolve_battle_action(game_state, request, function_id),
|
||
"treasure_secure" | "treasure_inspect" | "treasure_leave" => {
|
||
resolve_treasure_action(game_state, request, function_id)
|
||
}
|
||
_ => Err(format!("暂不支持的 runtime action：{function_id}")),
|
||
}
|
||
}
|
||
|
||
fn resolve_continue_adventure_action(
|
||
current_story: Option<&Value>,
|
||
) -> Result<StoryResolution, String> {
|
||
let deferred_options = current_story
|
||
.map(|story| {
|
||
read_array_field(story, "deferredOptions")
|
||
.into_iter()
|
||
.filter_map(build_runtime_story_option_from_story_option)
|
||
.collect::<Vec<_>>()
|
||
})
|
||
.unwrap_or_default();
|
||
let options = (!deferred_options.is_empty()).then_some(deferred_options);
|
||
|
||
Ok(StoryResolution {
|
||
action_text: "继续推进冒险".to_string(),
|
||
result_text: "你没有把节奏停下来，而是顺着当前局势继续向前推进了这一段故事。".to_string(),
|
||
story_text: None,
|
||
presentation_options: options,
|
||
saved_current_story: None,
|
||
patches: Vec::new(),
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_npc_preview_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let npc_name = current_encounter_name(game_state);
|
||
write_bool_field(game_state, "npcInteractionActive", true);
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text("转向眼前角色", request),
|
||
result_text: format!("{npc_name} 注意到了你的靠近，正在等你先把话说出来。"),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![build_status_patch(game_state)],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_npc_affinity_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
default_action_text: &str,
|
||
affinity_delta: i32,
|
||
fallback_result_text: &str,
|
||
) -> Result<StoryResolution, String> {
|
||
write_bool_field(game_state, "npcInteractionActive", true);
|
||
let affinity_patch = adjust_current_npc_affinity(game_state, affinity_delta).map(
|
||
|(npc_id, previous_affinity, next_affinity)| RuntimeStoryPatch::NpcAffinityChanged {
|
||
npc_id,
|
||
previous_affinity,
|
||
next_affinity,
|
||
},
|
||
);
|
||
let mut patches = Vec::new();
|
||
if let Some(patch) = affinity_patch {
|
||
patches.push(patch);
|
||
}
|
||
patches.push(build_status_patch(game_state));
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(default_action_text, request),
|
||
result_text: fallback_result_text.to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches,
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_npc_chat_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let chatted_count = read_current_npc_state_i32_field(game_state, "chattedCount").unwrap_or(0);
|
||
let affinity_gain = (6 - chatted_count).max(2);
|
||
let result_text = format!(
|
||
"{} 愿意把话接下去，态度比刚才明显松动了一些。当前关系推进了 {} 点。",
|
||
current_encounter_name(game_state),
|
||
affinity_gain
|
||
);
|
||
let mut resolution = resolve_npc_affinity_action(
|
||
game_state,
|
||
request,
|
||
"继续交谈",
|
||
affinity_gain,
|
||
result_text.as_str(),
|
||
)?;
|
||
write_current_npc_state_i32_field(game_state, "chattedCount", chatted_count.saturating_add(1));
|
||
write_current_npc_state_bool_field(game_state, "firstMeaningfulContactResolved", true);
|
||
resolution.action_text = format!("继续和{}交谈", current_encounter_name(game_state));
|
||
Ok(resolution)
|
||
}
|
||
|
||
fn resolve_npc_help_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
if read_current_npc_state_bool_field(game_state, "helpUsed").unwrap_or(false) {
|
||
return Err("当前 NPC 的一次性援手已经用完了".to_string());
|
||
}
|
||
|
||
restore_player_resource(game_state, 10, 8);
|
||
write_current_npc_state_bool_field(game_state, "helpUsed", true);
|
||
resolve_npc_affinity_action(
|
||
game_state,
|
||
request,
|
||
&format!("向{}请求援手", current_encounter_name(game_state)),
|
||
4,
|
||
&format!(
|
||
"{} 给了你一次及时支援，你的状态暂时稳住了，关系也顺势拉近了一点。",
|
||
current_encounter_name(game_state)
|
||
),
|
||
)
|
||
}
|
||
|
||
fn resolve_pending_quest_offer_view_action(
|
||
game_state: &mut Value,
|
||
current_story: Option<&Value>,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let encounter = current_encounter_npc_quest_context(game_state)?;
|
||
let pending_offer = read_pending_quest_offer_context(current_story, encounter.npc_id.as_str())
|
||
.ok_or_else(|| "当前没有待处理的委托可查看。".to_string())?;
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(&format!("查看{}提出的委托", encounter.npc_name), request),
|
||
result_text: pending_offer.intro_text.clone().unwrap_or_else(|| {
|
||
build_quest_offer_dialogue_text(encounter.npc_name.as_str(), &pending_offer.quest)
|
||
}),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_pending_quest_offer_replace_action(
|
||
game_state: &mut Value,
|
||
current_story: Option<&Value>,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let encounter = current_encounter_npc_quest_context(game_state)?;
|
||
let pending_offer = read_pending_quest_offer_context(current_story, encounter.npc_id.as_str())
|
||
.ok_or_else(|| "当前没有待处理的委托可更换。".to_string())?;
|
||
let next_quest = build_next_pending_quest_offer(
|
||
game_state,
|
||
encounter.npc_id.as_str(),
|
||
encounter.npc_name.as_str(),
|
||
Some(pending_offer.quest_id.as_str()),
|
||
);
|
||
let quest_text = build_quest_offer_dialogue_text(encounter.npc_name.as_str(), &next_quest);
|
||
let dialogue = append_dialogue_turns(
|
||
pending_offer.dialogue.as_slice(),
|
||
vec![
|
||
json!({
|
||
"speaker": "player",
|
||
"text": "能不能换一份更适合眼下局势的委托？"
|
||
}),
|
||
json!({
|
||
"speaker": "npc",
|
||
"speakerName": encounter.npc_name,
|
||
"text": quest_text,
|
||
}),
|
||
],
|
||
);
|
||
let options = build_pending_quest_offer_options(encounter.npc_id.as_str());
|
||
let saved_current_story = build_pending_quest_offer_story(
|
||
dialogue,
|
||
encounter.npc_id.as_str(),
|
||
encounter.npc_name.as_str(),
|
||
pending_offer.turn_count,
|
||
pending_offer.custom_input_placeholder.as_str(),
|
||
Some(next_quest.clone()),
|
||
options.as_slice(),
|
||
);
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(&format!("请{}更换委托", encounter.npc_name), request),
|
||
result_text: quest_text.clone(),
|
||
story_text: Some(quest_text),
|
||
presentation_options: Some(options),
|
||
saved_current_story: Some(saved_current_story),
|
||
patches: vec![],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_pending_quest_offer_abandon_action(
|
||
game_state: &mut Value,
|
||
current_story: Option<&Value>,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let encounter = current_encounter_npc_quest_context(game_state)?;
|
||
let pending_offer = read_pending_quest_offer_context(current_story, encounter.npc_id.as_str())
|
||
.ok_or_else(|| "当前没有待处理的委托可放弃。".to_string())?;
|
||
let npc_reply = format!(
|
||
"{}点了点头，没有继续强求，只把这份委托暂时收了回去。",
|
||
encounter.npc_name
|
||
);
|
||
let dialogue = append_dialogue_turns(
|
||
pending_offer.dialogue.as_slice(),
|
||
vec![
|
||
json!({
|
||
"speaker": "player",
|
||
"text": "这件事我先不接，咱们还是先聊别的。"
|
||
}),
|
||
json!({
|
||
"speaker": "npc",
|
||
"speakerName": encounter.npc_name,
|
||
"text": npc_reply,
|
||
}),
|
||
],
|
||
);
|
||
let options = build_post_quest_offer_chat_options(encounter.npc_id.as_str());
|
||
let saved_current_story = build_pending_quest_offer_story(
|
||
dialogue,
|
||
encounter.npc_id.as_str(),
|
||
encounter.npc_name.as_str(),
|
||
pending_offer.turn_count,
|
||
pending_offer.custom_input_placeholder.as_str(),
|
||
None,
|
||
options.as_slice(),
|
||
);
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(&format!("暂不接受{}的委托", encounter.npc_name), request),
|
||
result_text: npc_reply.clone(),
|
||
story_text: Some(npc_reply),
|
||
presentation_options: Some(options),
|
||
saved_current_story: Some(saved_current_story),
|
||
patches: vec![],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_pending_quest_accept_action(
|
||
game_state: &mut Value,
|
||
current_story: Option<&Value>,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let encounter = current_encounter_npc_quest_context(game_state)?;
|
||
let pending_offer = read_pending_quest_offer_context(current_story, encounter.npc_id.as_str())
|
||
.ok_or_else(|| "当前没有待处理的委托可接下。".to_string())?;
|
||
if find_active_quest_for_issuer(game_state, encounter.npc_id.as_str()).is_some() {
|
||
return Err("当前角色已经有未结清的委托。".to_string());
|
||
}
|
||
|
||
let quest = pending_offer.quest.clone();
|
||
push_quest_record(game_state, &quest);
|
||
increment_runtime_stat(game_state, "questsAccepted", 1);
|
||
write_current_npc_state_bool_field(game_state, "firstMeaningfulContactResolved", true);
|
||
|
||
let reply_text = first_quest_reveal_text(&quest)
|
||
.map(|text| format!("那就拜托你了。{text}"))
|
||
.unwrap_or_else(|| {
|
||
format!(
|
||
"那就拜托你了。{}",
|
||
read_optional_string_field(&quest, "summary")
|
||
.unwrap_or_else(|| "这份委托的关键要点我已经交给你。".to_string())
|
||
)
|
||
});
|
||
let dialogue = append_dialogue_turns(
|
||
pending_offer.dialogue.as_slice(),
|
||
vec![
|
||
json!({
|
||
"speaker": "player",
|
||
"text": "这件事我愿意接下，你把关键要点交给我。"
|
||
}),
|
||
json!({
|
||
"speaker": "npc",
|
||
"speakerName": encounter.npc_name,
|
||
"text": reply_text,
|
||
}),
|
||
],
|
||
);
|
||
let options = build_post_quest_accept_chat_options(encounter.npc_id.as_str());
|
||
let saved_current_story = build_pending_quest_offer_story(
|
||
dialogue,
|
||
encounter.npc_id.as_str(),
|
||
encounter.npc_name.as_str(),
|
||
pending_offer.turn_count,
|
||
pending_offer.custom_input_placeholder.as_str(),
|
||
None,
|
||
options.as_slice(),
|
||
);
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(&format!("接下{}的委托", encounter.npc_name), request),
|
||
result_text: build_quest_accept_result_text(&quest),
|
||
story_text: Some(
|
||
saved_current_story["text"]
|
||
.as_str()
|
||
.unwrap_or_default()
|
||
.to_string(),
|
||
),
|
||
presentation_options: Some(options),
|
||
saved_current_story: Some(saved_current_story),
|
||
patches: vec![],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_pending_quest_turn_in_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let encounter = current_encounter_npc_quest_context(game_state)?;
|
||
let quest_id = request
|
||
.action
|
||
.payload
|
||
.as_ref()
|
||
.and_then(|payload| read_optional_string_field(payload, "questId"))
|
||
.or_else(|| request.action.target_id.clone())
|
||
.or_else(|| {
|
||
find_active_quest_for_issuer(game_state, encounter.npc_id.as_str())
|
||
.and_then(|quest| read_optional_string_field(quest, "id"))
|
||
})
|
||
.ok_or_else(|| "当前没有可交付的委托。".to_string())?;
|
||
let turned_in = turn_in_quest_record(game_state, encounter.npc_id.as_str(), quest_id.as_str())?;
|
||
let previous_affinity = read_current_npc_affinity(game_state);
|
||
let affinity_bonus = read_field(&turned_in, "reward")
|
||
.and_then(|reward| read_i32_field(reward, "affinityBonus"))
|
||
.unwrap_or(0);
|
||
let next_affinity = previous_affinity.saturating_add(affinity_bonus);
|
||
write_current_npc_state_i32_field(game_state, "affinity", next_affinity);
|
||
write_current_npc_state_bool_field(game_state, "firstMeaningfulContactResolved", true);
|
||
apply_quest_turn_in_rewards(game_state, &turned_in);
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(&format!("向{}交付委托", encounter.npc_name), request),
|
||
result_text: build_quest_turn_in_result_text(&turned_in),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![RuntimeStoryPatch::NpcAffinityChanged {
|
||
npc_id: encounter.npc_id,
|
||
previous_affinity,
|
||
next_affinity,
|
||
}],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_npc_battle_entry_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
function_id: &str,
|
||
) -> Result<StoryResolution, String> {
|
||
let npc_id = current_encounter_id(game_state).unwrap_or_else(|| "npc_current".to_string());
|
||
let npc_name = current_encounter_name(game_state);
|
||
let battle_mode = if function_id == "npc_spar" {
|
||
"spar"
|
||
} else {
|
||
"fight"
|
||
};
|
||
write_bool_field(game_state, "inBattle", true);
|
||
write_bool_field(game_state, "npcInteractionActive", false);
|
||
write_string_field(game_state, "currentBattleNpcId", npc_id.as_str());
|
||
write_string_field(game_state, "currentNpcBattleMode", battle_mode);
|
||
write_null_field(game_state, "currentNpcBattleOutcome");
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(
|
||
if battle_mode == "spar" {
|
||
"点到为止切磋"
|
||
} else {
|
||
"与对方战斗"
|
||
},
|
||
request,
|
||
),
|
||
result_text: format!(
|
||
"{npc_name} 已经进入{}节奏，下一步必须按战斗动作结算。",
|
||
battle_mode_text(battle_mode)
|
||
),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![build_status_patch(game_state)],
|
||
battle: Some(RuntimeBattlePresentation {
|
||
target_id: Some(npc_id),
|
||
target_name: Some(npc_name),
|
||
damage_dealt: None,
|
||
damage_taken: None,
|
||
outcome: Some("ongoing".to_string()),
|
||
}),
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_npc_recruit_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<StoryResolution, String> {
|
||
let npc_id = current_encounter_id(game_state).unwrap_or_else(|| "npc_current".to_string());
|
||
let npc_name = current_encounter_name(game_state);
|
||
let current_affinity = read_current_npc_affinity(game_state);
|
||
if read_current_npc_state_bool_field(game_state, "recruited").unwrap_or(false) {
|
||
return Err("当前 NPC 已经处于已招募状态".to_string());
|
||
}
|
||
if current_affinity < 60 {
|
||
return Err("当前关系还没达到招募阈值，暂时不能邀请入队".to_string());
|
||
}
|
||
|
||
let release_npc_id = request
|
||
.action
|
||
.payload
|
||
.as_ref()
|
||
.and_then(|payload| read_optional_string_field(payload, "releaseNpcId"));
|
||
let released_companion_name = recruit_companion_to_party(
|
||
game_state,
|
||
npc_id.as_str(),
|
||
npc_name.as_str(),
|
||
release_npc_id.as_deref(),
|
||
)?;
|
||
let affinity_patch =
|
||
set_current_npc_recruited(game_state, true).map(|(previous_affinity, next_affinity)| {
|
||
RuntimeStoryPatch::NpcAffinityChanged {
|
||
npc_id: npc_id.clone(),
|
||
previous_affinity,
|
||
next_affinity,
|
||
}
|
||
});
|
||
write_current_npc_state_bool_field(game_state, "firstMeaningfulContactResolved", true);
|
||
write_bool_field(game_state, "npcInteractionActive", false);
|
||
clear_encounter_only(game_state);
|
||
write_null_field(game_state, "currentNpcBattleMode");
|
||
write_null_field(game_state, "currentNpcBattleOutcome");
|
||
write_bool_field(game_state, "inBattle", false);
|
||
|
||
let mut patches = Vec::new();
|
||
if let Some(patch) = affinity_patch {
|
||
patches.push(patch);
|
||
}
|
||
patches.push(build_status_patch(game_state));
|
||
patches.push(RuntimeStoryPatch::EncounterChanged { encounter_id: None });
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(&format!("邀请{npc_name}加入队伍"), request),
|
||
result_text: match released_companion_name {
|
||
Some(released_name) => format!(
|
||
"{npc_name} 接受了你的邀请，你先让 {released_name} 暂时离队，把位置腾给了新的同行者。"
|
||
),
|
||
None => format!("{npc_name} 接受了你的邀请，正式进入了同行队伍。"),
|
||
},
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches,
|
||
battle: None,
|
||
toast: Some(format!("{npc_name} 已加入队伍")),
|
||
})
|
||
}
|
||
|
||
fn resolve_battle_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
function_id: &str,
|
||
) -> Result<StoryResolution, String> {
|
||
let target_id = current_encounter_id(game_state)
|
||
.or_else(|| first_hostile_npc_string_field(game_state, "id"))
|
||
.unwrap_or_else(|| "battle_target".to_string());
|
||
let target_name = current_encounter_name_from_battle(game_state);
|
||
let battle_mode = read_optional_string_field(game_state, "currentNpcBattleMode")
|
||
.unwrap_or_else(|| "fight".to_string());
|
||
|
||
if function_id == "battle_escape_breakout" {
|
||
clear_encounter_state(game_state);
|
||
return Ok(StoryResolution {
|
||
action_text: resolve_action_text("强行脱离战斗", request),
|
||
result_text: "你抓住空隙强行脱离战斗，把这一轮危险先甩在身后。".to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![
|
||
RuntimeStoryPatch::BattleResolved {
|
||
function_id: function_id.to_string(),
|
||
target_id: Some(target_id.clone()),
|
||
damage_dealt: Some(0),
|
||
damage_taken: Some(0),
|
||
outcome: "escaped".to_string(),
|
||
},
|
||
build_status_patch(game_state),
|
||
RuntimeStoryPatch::EncounterChanged { encounter_id: None },
|
||
],
|
||
battle: Some(RuntimeBattlePresentation {
|
||
target_id: Some(target_id),
|
||
target_name: Some(target_name),
|
||
damage_dealt: Some(0),
|
||
damage_taken: Some(0),
|
||
outcome: Some("escaped".to_string()),
|
||
}),
|
||
toast: Some("已脱离战斗".to_string()),
|
||
});
|
||
}
|
||
|
||
let (damage_dealt, damage_taken, heal, mana_restore, mana_cost, action_text, result_text) =
|
||
battle_action_numbers(function_id);
|
||
spend_player_mana(game_state, mana_cost);
|
||
restore_player_resource(game_state, heal, mana_restore);
|
||
apply_player_damage(game_state, damage_taken);
|
||
let target_hp = apply_target_damage(game_state, damage_dealt);
|
||
let outcome = if target_hp <= 0 {
|
||
if battle_mode == "spar" {
|
||
"spar_complete"
|
||
} else {
|
||
"victory"
|
||
}
|
||
} else {
|
||
"ongoing"
|
||
};
|
||
|
||
if outcome != "ongoing" {
|
||
write_bool_field(game_state, "inBattle", false);
|
||
write_bool_field(game_state, "npcInteractionActive", false);
|
||
write_null_field(game_state, "currentNpcBattleMode");
|
||
write_string_field(
|
||
game_state,
|
||
"currentNpcBattleOutcome",
|
||
if outcome == "spar_complete" {
|
||
"spar_complete"
|
||
} else {
|
||
"fight_victory"
|
||
},
|
||
);
|
||
if outcome == "victory" {
|
||
clear_encounter_only(game_state);
|
||
}
|
||
}
|
||
|
||
let mut patches = vec![
|
||
RuntimeStoryPatch::BattleResolved {
|
||
function_id: function_id.to_string(),
|
||
target_id: Some(target_id.clone()),
|
||
damage_dealt: Some(damage_dealt),
|
||
damage_taken: Some(damage_taken),
|
||
outcome: outcome.to_string(),
|
||
},
|
||
build_status_patch(game_state),
|
||
];
|
||
if outcome == "victory" {
|
||
patches.push(RuntimeStoryPatch::EncounterChanged { encounter_id: None });
|
||
}
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(action_text, request),
|
||
result_text: if outcome == "ongoing" {
|
||
result_text.to_string()
|
||
} else if outcome == "spar_complete" {
|
||
format!("{target_name} 收住了最后一击，这场切磋已经分出结果。")
|
||
} else {
|
||
format!("{target_name} 被你压制下去，眼前的战斗已经结束。")
|
||
},
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches,
|
||
battle: Some(RuntimeBattlePresentation {
|
||
target_id: Some(target_id),
|
||
target_name: Some(target_name),
|
||
damage_dealt: Some(damage_dealt),
|
||
damage_taken: Some(damage_taken),
|
||
outcome: Some(outcome.to_string()),
|
||
}),
|
||
toast: None,
|
||
})
|
||
}
|
||
|
||
fn resolve_treasure_action(
|
||
game_state: &mut Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
function_id: &str,
|
||
) -> Result<StoryResolution, String> {
|
||
match function_id {
|
||
"treasure_secure" => {
|
||
clear_encounter_state(game_state);
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text("直接收取", request),
|
||
result_text: "你确认周围暂时安全，把这份收获稳稳收入行囊。".to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![
|
||
build_status_patch(game_state),
|
||
RuntimeStoryPatch::EncounterChanged { encounter_id: None },
|
||
],
|
||
battle: None,
|
||
toast: Some("已收取宝箱".to_string()),
|
||
})
|
||
}
|
||
"treasure_inspect" => Ok(simple_story_resolution(
|
||
game_state,
|
||
resolve_action_text("仔细检查", request),
|
||
"你没有急着伸手，而是绕着目标重新检查机关、痕迹和可能的埋伏。",
|
||
)),
|
||
"treasure_leave" => {
|
||
clear_encounter_state(game_state);
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text("先记下位置", request),
|
||
result_text: "你没有立刻处理这份收获，而是记下位置后继续保持移动。".to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![
|
||
build_status_patch(game_state),
|
||
RuntimeStoryPatch::EncounterChanged { encounter_id: None },
|
||
],
|
||
battle: None,
|
||
toast: None,
|
||
})
|
||
}
|
||
_ => Err(format!("暂不支持的 treasure action：{function_id}")),
|
||
}
|
||
}
|
||
|
||
fn simple_story_resolution(
|
||
game_state: &Value,
|
||
action_text: String,
|
||
result_text: &str,
|
||
) -> StoryResolution {
|
||
StoryResolution {
|
||
action_text,
|
||
result_text: result_text.to_string(),
|
||
story_text: None,
|
||
presentation_options: None,
|
||
saved_current_story: None,
|
||
patches: vec![build_status_patch(game_state)],
|
||
battle: None,
|
||
toast: None,
|
||
}
|
||
}
|
||
|
||
async fn build_runtime_story_ai_response(
|
||
state: &AppState,
|
||
payload: RuntimeStoryAiRequest,
|
||
initial: bool,
|
||
) -> RuntimeStoryAiResponse {
|
||
let options = build_ai_response_options(&payload);
|
||
let fallback = build_ai_fallback_story_text(&payload, initial);
|
||
let story_text = generate_ai_story_text(state, &payload, initial)
|
||
.await
|
||
.filter(|text| !text.trim().is_empty())
|
||
.unwrap_or(fallback);
|
||
|
||
RuntimeStoryAiResponse {
|
||
story_text,
|
||
options,
|
||
encounter: None,
|
||
}
|
||
}
|
||
|
||
async fn generate_ai_story_text(
|
||
state: &AppState,
|
||
payload: &RuntimeStoryAiRequest,
|
||
initial: bool,
|
||
) -> Option<String> {
|
||
let llm_client = state.llm_client()?;
|
||
let system_prompt = if initial {
|
||
"你是游戏运行时剧情导演。请用中文输出一段可直接展示给玩家的开局剧情，不要输出 JSON。"
|
||
} else {
|
||
"你是游戏运行时剧情导演。请用中文根据玩家选择续写一段剧情，不要输出 JSON。"
|
||
};
|
||
let user_prompt = json!({
|
||
"worldType": payload.world_type,
|
||
"character": payload.character,
|
||
"monsters": payload.monsters,
|
||
"history": payload.history,
|
||
"choice": payload.choice,
|
||
"context": payload.context,
|
||
"availableOptions": payload.request_options.available_options,
|
||
})
|
||
.to_string();
|
||
let mut request = LlmTextRequest::new(vec![
|
||
LlmMessage::system(system_prompt),
|
||
LlmMessage::user(user_prompt),
|
||
]);
|
||
request.max_tokens = Some(700);
|
||
|
||
llm_client
|
||
.request_text(request)
|
||
.await
|
||
.ok()
|
||
.map(|response| response.content.trim().to_string())
|
||
.filter(|text| !text.is_empty())
|
||
}
|
||
|
||
fn build_ai_response_options(payload: &RuntimeStoryAiRequest) -> Vec<Value> {
|
||
let source = if payload.request_options.available_options.is_empty() {
|
||
&payload.request_options.option_catalog
|
||
} else {
|
||
&payload.request_options.available_options
|
||
};
|
||
let options = source
|
||
.iter()
|
||
.filter_map(normalize_ai_story_option)
|
||
.collect::<Vec<_>>();
|
||
if !options.is_empty() {
|
||
return options;
|
||
}
|
||
|
||
vec![
|
||
build_ai_story_option_value("idle_observe_signs", "观察周围迹象"),
|
||
build_ai_story_option_value("idle_explore_forward", "继续向前探索"),
|
||
build_ai_story_option_value("idle_rest_focus", "原地调息"),
|
||
]
|
||
}
|
||
|
||
fn normalize_ai_story_option(value: &Value) -> Option<Value> {
|
||
let function_id = read_required_string_field(value, "functionId")?;
|
||
let action_text = read_required_string_field(value, "actionText")
|
||
.or_else(|| read_required_string_field(value, "text"))
|
||
.unwrap_or_else(|| function_id.clone());
|
||
let mut option = value.as_object()?.clone();
|
||
option.insert("functionId".to_string(), Value::String(function_id));
|
||
option.insert("actionText".to_string(), Value::String(action_text.clone()));
|
||
option
|
||
.entry("text".to_string())
|
||
.or_insert_with(|| Value::String(action_text));
|
||
|
||
Some(Value::Object(option))
|
||
}
|
||
|
||
fn build_ai_story_option_value(function_id: &str, action_text: &str) -> Value {
|
||
json!({
|
||
"functionId": function_id,
|
||
"actionText": action_text,
|
||
"text": action_text,
|
||
"visuals": {
|
||
"playerAnimation": "idle",
|
||
"playerMoveMeters": 0,
|
||
"playerOffsetY": 0,
|
||
"playerFacing": "right",
|
||
"scrollWorld": false,
|
||
"monsterChanges": []
|
||
}
|
||
})
|
||
}
|
||
|
||
fn build_ai_fallback_story_text(payload: &RuntimeStoryAiRequest, initial: bool) -> String {
|
||
let character_name =
|
||
read_optional_string_field(&payload.character, "name").unwrap_or_else(|| "你".to_string());
|
||
let scene_name = read_optional_string_field(&payload.context, "sceneName")
|
||
.or_else(|| read_optional_string_field(&payload.context, "scene"))
|
||
.unwrap_or_else(|| "当前区域".to_string());
|
||
if initial {
|
||
return format!(
|
||
"{character_name} 在 {scene_name} 稳住脚步，周围的气息正在变化，第一轮选择已经摆到眼前。"
|
||
);
|
||
}
|
||
|
||
let choice = normalize_required_string(payload.choice.as_str())
|
||
.unwrap_or_else(|| "继续推进".to_string());
|
||
format!("{character_name} 选择了「{choice}」，{scene_name} 的局势随之向下一步展开。")
|
||
}
|
||
|
||
fn build_runtime_story_companions(game_state: &Value) -> Vec<RuntimeStoryCompanionViewModel> {
|
||
read_array_field(game_state, "companions")
|
||
.into_iter()
|
||
.filter_map(|entry| {
|
||
let npc_id = read_required_string_field(entry, "npcId")?;
|
||
Some(RuntimeStoryCompanionViewModel {
|
||
npc_id,
|
||
character_id: read_optional_string_field(entry, "characterId"),
|
||
joined_at_affinity: read_i32_field(entry, "joinedAtAffinity").unwrap_or(0),
|
||
})
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn build_runtime_story_encounter(game_state: &Value) -> Option<RuntimeStoryEncounterViewModel> {
|
||
let encounter = read_object_field(game_state, "currentEncounter")?;
|
||
let npc_name = read_required_string_field(encounter, "npcName")
|
||
.or_else(|| read_required_string_field(encounter, "name"))
|
||
.unwrap_or_else(|| "当前遭遇".to_string());
|
||
let encounter_id =
|
||
read_required_string_field(encounter, "id").unwrap_or_else(|| npc_name.clone());
|
||
let npc_state = resolve_current_encounter_npc_state(game_state, &encounter_id, &npc_name);
|
||
|
||
Some(RuntimeStoryEncounterViewModel {
|
||
id: encounter_id,
|
||
kind: read_required_string_field(encounter, "kind").unwrap_or_else(|| "npc".to_string()),
|
||
npc_name,
|
||
hostile: read_bool_field(encounter, "hostile").unwrap_or(false),
|
||
affinity: npc_state.and_then(|state| read_i32_field(state, "affinity")),
|
||
recruited: npc_state.and_then(|state| read_bool_field(state, "recruited")),
|
||
interaction_active: read_bool_field(game_state, "npcInteractionActive").unwrap_or(false),
|
||
battle_mode: read_optional_string_field(game_state, "currentNpcBattleMode"),
|
||
})
|
||
}
|
||
|
||
fn resolve_current_encounter_npc_state<'a>(
|
||
game_state: &'a Value,
|
||
encounter_id: &str,
|
||
npc_name: &str,
|
||
) -> Option<&'a Value> {
|
||
let npc_states = read_object_field(game_state, "npcStates")?;
|
||
|
||
npc_states
|
||
.get(encounter_id)
|
||
.or_else(|| npc_states.get(npc_name))
|
||
}
|
||
|
||
fn build_runtime_story_options(
|
||
current_story: Option<&Value>,
|
||
game_state: &Value,
|
||
) -> Vec<RuntimeStoryOptionView> {
|
||
if let Some(story) = current_story {
|
||
let prefers_deferred = read_required_string_field(story, "displayMode")
|
||
.is_some_and(|value| value == "dialogue")
|
||
&& !read_array_field(story, "deferredOptions").is_empty();
|
||
|
||
let source = if prefers_deferred {
|
||
read_array_field(story, "deferredOptions")
|
||
} else {
|
||
read_array_field(story, "options")
|
||
};
|
||
|
||
let compiled = source
|
||
.into_iter()
|
||
.filter_map(build_runtime_story_option_from_story_option)
|
||
.collect::<Vec<_>>();
|
||
|
||
if !compiled.is_empty() {
|
||
return compiled;
|
||
}
|
||
}
|
||
|
||
build_fallback_runtime_story_options(game_state)
|
||
}
|
||
|
||
fn build_runtime_story_option_from_story_option(value: &Value) -> Option<RuntimeStoryOptionView> {
|
||
let function_id = read_required_string_field(value, "functionId")?;
|
||
let action_text = read_required_string_field(value, "actionText")
|
||
.or_else(|| read_required_string_field(value, "text"))
|
||
.unwrap_or_else(|| function_id.clone());
|
||
|
||
Some(RuntimeStoryOptionView {
|
||
scope: infer_option_scope(function_id.as_str()).to_string(),
|
||
detail_text: read_optional_string_field(value, "detailText"),
|
||
interaction: build_runtime_story_option_interaction(read_field(value, "interaction")),
|
||
payload: read_field(value, "runtimePayload")
|
||
.or_else(|| read_field(value, "payload"))
|
||
.cloned(),
|
||
disabled: read_bool_field(value, "disabled"),
|
||
reason: read_optional_string_field(value, "disabledReason")
|
||
.or_else(|| read_optional_string_field(value, "reason")),
|
||
function_id,
|
||
action_text,
|
||
})
|
||
}
|
||
|
||
fn build_runtime_story_option_interaction(
|
||
value: Option<&Value>,
|
||
) -> Option<RuntimeStoryOptionInteraction> {
|
||
let interaction = value?;
|
||
match read_required_string_field(interaction, "kind")?.as_str() {
|
||
"npc" => Some(RuntimeStoryOptionInteraction::Npc {
|
||
npc_id: read_required_string_field(interaction, "npcId")?,
|
||
action: read_required_string_field(interaction, "action")?,
|
||
quest_id: read_optional_string_field(interaction, "questId"),
|
||
}),
|
||
"treasure" => Some(RuntimeStoryOptionInteraction::Treasure {
|
||
action: read_required_string_field(interaction, "action")?,
|
||
}),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
fn build_fallback_runtime_story_options(game_state: &Value) -> Vec<RuntimeStoryOptionView> {
|
||
if read_bool_field(game_state, "inBattle").unwrap_or(false) {
|
||
return vec![
|
||
build_static_runtime_story_option("battle_attack_basic", "普通攻击", "combat"),
|
||
build_static_runtime_story_option("battle_recover_breath", "恢复", "combat"),
|
||
build_static_runtime_story_option("battle_escape_breakout", "强行脱离战斗", "combat"),
|
||
];
|
||
}
|
||
|
||
let encounter = read_object_field(game_state, "currentEncounter");
|
||
if let Some(encounter) = encounter {
|
||
match read_required_string_field(encounter, "kind").as_deref() {
|
||
Some("npc") => {
|
||
let interaction_active =
|
||
read_bool_field(game_state, "npcInteractionActive").unwrap_or(false);
|
||
let npc_id = read_required_string_field(encounter, "id")
|
||
.unwrap_or_else(|| "npc_current".to_string());
|
||
if let Some(active_quest) =
|
||
find_active_quest_for_issuer(game_state, npc_id.as_str())
|
||
{
|
||
if read_optional_string_field(active_quest, "status")
|
||
.is_some_and(|status| status == "completed")
|
||
{
|
||
return vec![
|
||
build_npc_runtime_story_option_with_quest(
|
||
"npc_quest_turn_in",
|
||
&format!("向{}交付委托", current_encounter_name(game_state)),
|
||
&npc_id,
|
||
"quest_turn_in",
|
||
read_optional_string_field(active_quest, "id"),
|
||
),
|
||
build_npc_runtime_story_option(
|
||
"npc_leave",
|
||
"离开当前角色",
|
||
&npc_id,
|
||
"leave",
|
||
),
|
||
];
|
||
}
|
||
}
|
||
if interaction_active {
|
||
return vec![
|
||
build_npc_runtime_story_option("npc_chat", "继续交谈", &npc_id, "chat"),
|
||
build_npc_runtime_story_option("npc_help", "请求援手", &npc_id, "help"),
|
||
build_npc_runtime_story_option(
|
||
"npc_recruit",
|
||
"邀请同行",
|
||
&npc_id,
|
||
"recruit",
|
||
),
|
||
build_npc_runtime_story_option("npc_spar", "点到为止切磋", &npc_id, "spar"),
|
||
build_npc_runtime_story_option("npc_fight", "与对方战斗", &npc_id, "fight"),
|
||
build_npc_runtime_story_option(
|
||
"npc_leave",
|
||
"离开当前角色",
|
||
&npc_id,
|
||
"leave",
|
||
),
|
||
];
|
||
}
|
||
|
||
return vec![
|
||
build_npc_runtime_story_option(
|
||
"npc_preview_talk",
|
||
"转向眼前角色",
|
||
&npc_id,
|
||
"chat",
|
||
),
|
||
build_npc_runtime_story_option("npc_fight", "与对方战斗", &npc_id, "fight"),
|
||
build_npc_runtime_story_option("npc_leave", "离开当前角色", &npc_id, "leave"),
|
||
];
|
||
}
|
||
Some("treasure") => {
|
||
return vec![
|
||
build_treasure_runtime_story_option("treasure_secure", "直接收取", "secure"),
|
||
build_treasure_runtime_story_option("treasure_inspect", "仔细检查", "inspect"),
|
||
build_treasure_runtime_story_option("treasure_leave", "先记下位置", "leave"),
|
||
];
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
vec![
|
||
build_static_runtime_story_option("idle_observe_signs", "观察周围迹象", "story"),
|
||
build_static_runtime_story_option("idle_call_out", "主动出声试探", "story"),
|
||
build_static_runtime_story_option("idle_rest_focus", "原地调息", "story"),
|
||
build_static_runtime_story_option("idle_explore_forward", "继续向前探索", "story"),
|
||
build_static_runtime_story_option("idle_travel_next_scene", "前往相邻场景", "story"),
|
||
build_static_runtime_story_option(CONTINUE_ADVENTURE_FUNCTION_ID, "继续推进冒险", "story"),
|
||
]
|
||
}
|
||
|
||
fn build_static_runtime_story_option(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
scope: &str,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
function_id: function_id.to_string(),
|
||
action_text: action_text.to_string(),
|
||
detail_text: None,
|
||
scope: scope.to_string(),
|
||
interaction: None,
|
||
payload: None,
|
||
disabled: None,
|
||
reason: None,
|
||
}
|
||
}
|
||
|
||
fn build_npc_runtime_story_option(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
npc_id: &str,
|
||
action: &str,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
interaction: Some(RuntimeStoryOptionInteraction::Npc {
|
||
npc_id: npc_id.to_string(),
|
||
action: action.to_string(),
|
||
quest_id: None,
|
||
}),
|
||
..build_static_runtime_story_option(function_id, action_text, "npc")
|
||
}
|
||
}
|
||
|
||
fn build_npc_runtime_story_option_with_payload(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
npc_id: &str,
|
||
action: &str,
|
||
payload: Value,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
payload: Some(payload),
|
||
..build_npc_runtime_story_option(function_id, action_text, npc_id, action)
|
||
}
|
||
}
|
||
|
||
fn build_npc_runtime_story_option_with_quest(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
npc_id: &str,
|
||
action: &str,
|
||
quest_id: Option<String>,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
interaction: Some(RuntimeStoryOptionInteraction::Npc {
|
||
npc_id: npc_id.to_string(),
|
||
action: action.to_string(),
|
||
quest_id,
|
||
}),
|
||
..build_static_runtime_story_option(function_id, action_text, "npc")
|
||
}
|
||
}
|
||
|
||
fn build_treasure_runtime_story_option(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
action: &str,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
interaction: Some(RuntimeStoryOptionInteraction::Treasure {
|
||
action: action.to_string(),
|
||
}),
|
||
..build_static_runtime_story_option(function_id, action_text, "story")
|
||
}
|
||
}
|
||
|
||
fn current_encounter_npc_quest_context(
|
||
game_state: &Value,
|
||
) -> Result<CurrentEncounterNpcQuestContext, String> {
|
||
let encounter = read_object_field(game_state, "currentEncounter")
|
||
.ok_or_else(|| "当前不在可结算的 NPC 委托态。".to_string())?;
|
||
let kind = read_required_string_field(encounter, "kind")
|
||
.ok_or_else(|| "当前不在可结算的 NPC 委托态。".to_string())?;
|
||
if kind != "npc" {
|
||
return Err("当前不在可结算的 NPC 委托态。".to_string());
|
||
}
|
||
|
||
let npc_name = read_optional_string_field(encounter, "npcName")
|
||
.or_else(|| read_optional_string_field(encounter, "name"))
|
||
.unwrap_or_else(|| "当前角色".to_string());
|
||
let npc_id = read_optional_string_field(encounter, "id").unwrap_or_else(|| npc_name.clone());
|
||
|
||
if resolve_current_encounter_npc_state(game_state, npc_id.as_str(), npc_name.as_str()).is_none()
|
||
{
|
||
return Err("当前 NPC 状态不存在，无法处理委托。".to_string());
|
||
}
|
||
|
||
Ok(CurrentEncounterNpcQuestContext { npc_id, npc_name })
|
||
}
|
||
|
||
fn read_pending_quest_offer_context(
|
||
current_story: Option<&Value>,
|
||
npc_key: &str,
|
||
) -> Option<PendingQuestOfferContext> {
|
||
let current_story = current_story?;
|
||
let npc_chat_state = read_object_field(current_story, "npcChatState")?;
|
||
let pending_offer = read_object_field(npc_chat_state, "pendingQuestOffer")?;
|
||
let quest = read_object_field(pending_offer, "quest")?.clone();
|
||
let quest_id = read_optional_string_field(&quest, "id")?;
|
||
let pending_npc_id = read_optional_string_field(npc_chat_state, "npcId");
|
||
let issuer_npc_id = read_optional_string_field(&quest, "issuerNpcId");
|
||
if pending_npc_id
|
||
.as_deref()
|
||
.is_some_and(|value| value != npc_key)
|
||
{
|
||
return None;
|
||
}
|
||
if issuer_npc_id
|
||
.as_deref()
|
||
.is_some_and(|value| value != npc_key)
|
||
{
|
||
return None;
|
||
}
|
||
|
||
Some(PendingQuestOfferContext {
|
||
dialogue: read_array_field(current_story, "dialogue")
|
||
.into_iter()
|
||
.cloned()
|
||
.collect(),
|
||
turn_count: read_i32_field(npc_chat_state, "turnCount").unwrap_or(0),
|
||
custom_input_placeholder: read_optional_string_field(
|
||
npc_chat_state,
|
||
"customInputPlaceholder",
|
||
)
|
||
.unwrap_or_else(|| "输入你想对 TA 说的话".to_string()),
|
||
quest,
|
||
quest_id,
|
||
intro_text: read_optional_string_field(pending_offer, "introText"),
|
||
})
|
||
}
|
||
|
||
fn build_quest_offer_dialogue_text(npc_name: &str, quest: &Value) -> String {
|
||
let summary_text = read_optional_string_field(quest, "summary")
|
||
.or_else(|| read_optional_string_field(quest, "description"))
|
||
.unwrap_or_default();
|
||
if summary_text.is_empty() {
|
||
return format!(
|
||
"{npc_name}沉吟了片刻，像是终于把真正想托付的事说了出来。如果你愿意，我想把眼前这件事正式交给你。"
|
||
);
|
||
}
|
||
format!(
|
||
"{npc_name}沉吟了片刻，像是终于把真正想托付的事说了出来。如果你愿意，我想把这件事正式交给你：{summary_text}"
|
||
)
|
||
}
|
||
|
||
fn append_dialogue_turns(existing: &[Value], additions: Vec<Value>) -> Vec<Value> {
|
||
let mut dialogue = existing.to_vec();
|
||
dialogue.extend(additions);
|
||
dialogue
|
||
}
|
||
|
||
fn build_pending_quest_offer_options(npc_id: &str) -> Vec<RuntimeStoryOptionView> {
|
||
vec![
|
||
build_npc_runtime_story_option_with_payload(
|
||
"npc_chat_quest_offer_view",
|
||
"查看任务",
|
||
npc_id,
|
||
"quest_offer_view",
|
||
json!({
|
||
"npcChatQuestOfferAction": "view"
|
||
}),
|
||
),
|
||
build_npc_runtime_story_option_with_payload(
|
||
"npc_chat_quest_offer_replace",
|
||
"更换任务",
|
||
npc_id,
|
||
"quest_offer_replace",
|
||
json!({
|
||
"npcChatQuestOfferAction": "replace"
|
||
}),
|
||
),
|
||
build_npc_runtime_story_option_with_payload(
|
||
"npc_chat_quest_offer_abandon",
|
||
"放弃任务",
|
||
npc_id,
|
||
"quest_offer_abandon",
|
||
json!({
|
||
"npcChatQuestOfferAction": "abandon"
|
||
}),
|
||
),
|
||
]
|
||
}
|
||
|
||
fn build_post_quest_offer_chat_options(npc_id: &str) -> Vec<RuntimeStoryOptionView> {
|
||
vec![
|
||
build_npc_runtime_story_option(
|
||
"npc_chat",
|
||
"那先继续聊聊你刚才没说完的部分",
|
||
npc_id,
|
||
"chat",
|
||
),
|
||
build_npc_runtime_story_option(
|
||
"npc_chat",
|
||
"除了委托，你对眼前局势还有什么判断",
|
||
npc_id,
|
||
"chat",
|
||
),
|
||
build_npc_runtime_story_option(
|
||
"npc_chat",
|
||
"先把这附近真正危险的地方说清楚",
|
||
npc_id,
|
||
"chat",
|
||
),
|
||
]
|
||
}
|
||
|
||
fn build_post_quest_accept_chat_options(npc_id: &str) -> Vec<RuntimeStoryOptionView> {
|
||
vec![
|
||
build_npc_runtime_story_option("npc_chat", "这件事里你最担心哪一步", npc_id, "chat"),
|
||
build_npc_runtime_story_option("npc_chat", "我回来时你最想先知道什么", npc_id, "chat"),
|
||
build_npc_runtime_story_option(
|
||
"npc_chat",
|
||
"除了这份委托，你还想提醒我什么",
|
||
npc_id,
|
||
"chat",
|
||
),
|
||
]
|
||
}
|
||
|
||
fn build_pending_quest_offer_story(
|
||
dialogue: Vec<Value>,
|
||
npc_id: &str,
|
||
npc_name: &str,
|
||
turn_count: i32,
|
||
custom_input_placeholder: &str,
|
||
pending_quest: Option<Value>,
|
||
options: &[RuntimeStoryOptionView],
|
||
) -> Value {
|
||
json!({
|
||
"text": dialogue
|
||
.iter()
|
||
.filter_map(|entry| read_optional_string_field(entry, "text"))
|
||
.collect::<Vec<_>>()
|
||
.join("\n"),
|
||
"options": options.iter().map(build_story_option_from_runtime_option).collect::<Vec<_>>(),
|
||
"displayMode": "dialogue",
|
||
"dialogue": dialogue,
|
||
"streaming": false,
|
||
"npcChatState": {
|
||
"npcId": npc_id,
|
||
"npcName": npc_name,
|
||
"turnCount": turn_count,
|
||
"customInputPlaceholder": custom_input_placeholder,
|
||
"pendingQuestOffer": pending_quest.map(|quest| json!({ "quest": quest })),
|
||
}
|
||
})
|
||
}
|
||
|
||
fn build_next_pending_quest_offer(
|
||
game_state: &Value,
|
||
npc_id: &str,
|
||
npc_name: &str,
|
||
previous_quest_id: Option<&str>,
|
||
) -> Value {
|
||
let next_id = if previous_quest_id.is_some_and(|id| id == "quest-bridge-offer") {
|
||
"quest-bridge-replaced"
|
||
} else {
|
||
"quest-generated-replaced"
|
||
};
|
||
let title = if next_id == "quest-bridge-replaced" {
|
||
"断桥夜巡"
|
||
} else {
|
||
"新的临时委托"
|
||
};
|
||
let scene_id = read_object_field(game_state, "currentScenePreset")
|
||
.and_then(|scene| read_optional_string_field(scene, "id"));
|
||
json!({
|
||
"id": next_id,
|
||
"issuerNpcId": npc_id,
|
||
"issuerNpcName": npc_name,
|
||
"sceneId": scene_id,
|
||
"title": title,
|
||
"description": format!("{title}的详细说明。"),
|
||
"summary": format!("{title}的简要目标。"),
|
||
"objective": {
|
||
"kind": "inspect_treasure",
|
||
"requiredCount": 1
|
||
},
|
||
"progress": 0,
|
||
"status": "active",
|
||
"reward": {
|
||
"affinityBonus": 6,
|
||
"currency": 30,
|
||
"items": []
|
||
},
|
||
"rewardText": "完成后可以领取报酬。",
|
||
"steps": [{
|
||
"id": format!("{next_id}-step-1"),
|
||
"title": "查清线索",
|
||
"kind": "inspect_treasure",
|
||
"requiredCount": 1,
|
||
"progress": 0,
|
||
"revealText": "先去断桥口附近看看留下了什么痕迹。",
|
||
"completeText": "线索已经查清。"
|
||
}],
|
||
"activeStepId": format!("{next_id}-step-1")
|
||
})
|
||
}
|
||
|
||
fn find_active_quest_for_issuer<'a>(
|
||
game_state: &'a Value,
|
||
issuer_npc_id: &str,
|
||
) -> Option<&'a Value> {
|
||
read_array_field(game_state, "quests")
|
||
.into_iter()
|
||
.find(|quest| {
|
||
read_optional_string_field(quest, "issuerNpcId").as_deref() == Some(issuer_npc_id)
|
||
&& read_optional_string_field(quest, "status")
|
||
.is_some_and(|status| status != "turned_in")
|
||
})
|
||
}
|
||
|
||
fn push_quest_record(game_state: &mut Value, quest: &Value) {
|
||
let root = ensure_json_object(game_state);
|
||
let quests = root
|
||
.entry("quests".to_string())
|
||
.or_insert_with(|| Value::Array(Vec::new()));
|
||
if !quests.is_array() {
|
||
*quests = Value::Array(Vec::new());
|
||
}
|
||
quests
|
||
.as_array_mut()
|
||
.expect("quests should be array")
|
||
.push(quest.clone());
|
||
}
|
||
|
||
fn first_quest_reveal_text(quest: &Value) -> Option<String> {
|
||
read_array_field(quest, "steps")
|
||
.first()
|
||
.and_then(|step| read_optional_string_field(step, "revealText"))
|
||
}
|
||
|
||
fn build_quest_accept_result_text(quest: &Value) -> String {
|
||
let issuer_name =
|
||
read_optional_string_field(quest, "issuerNpcName").unwrap_or_else(|| "对方".to_string());
|
||
let title = read_optional_string_field(quest, "title").unwrap_or_else(|| "委托".to_string());
|
||
format!("你正式接下了 {issuer_name} 的委托「{title}」，接下来可以开始推进任务目标。")
|
||
}
|
||
|
||
fn turn_in_quest_record(
|
||
game_state: &mut Value,
|
||
issuer_npc_id: &str,
|
||
quest_id: &str,
|
||
) -> Result<Value, String> {
|
||
let root = ensure_json_object(game_state);
|
||
let quests = root
|
||
.entry("quests".to_string())
|
||
.or_insert_with(|| Value::Array(Vec::new()));
|
||
if !quests.is_array() {
|
||
*quests = Value::Array(Vec::new());
|
||
}
|
||
let quests = quests.as_array_mut().expect("quests should be array");
|
||
let Some(index) = quests.iter().position(|quest| {
|
||
read_optional_string_field(quest, "id").as_deref() == Some(quest_id)
|
||
&& read_optional_string_field(quest, "issuerNpcId").as_deref() == Some(issuer_npc_id)
|
||
}) else {
|
||
return Err("当前没有可交付的委托。".to_string());
|
||
};
|
||
|
||
let mut turned_in = quests[index].clone();
|
||
if read_optional_string_field(&turned_in, "status").as_deref() != Some("completed") {
|
||
return Err("这份委托还没有达到可交付状态。".to_string());
|
||
}
|
||
if let Some(object) = turned_in.as_object_mut() {
|
||
object.insert("status".to_string(), Value::String("turned_in".to_string()));
|
||
object.insert("completionNotified".to_string(), Value::Bool(true));
|
||
if let Some(steps) = object.get_mut("steps").and_then(Value::as_array_mut) {
|
||
for step in steps.iter_mut() {
|
||
let required_count = read_i32_field(step, "requiredCount").unwrap_or(0);
|
||
if let Some(step_object) = step.as_object_mut() {
|
||
step_object.insert("progress".to_string(), json!(required_count.max(0)));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
quests[index] = turned_in.clone();
|
||
Ok(turned_in)
|
||
}
|
||
|
||
fn build_quest_turn_in_result_text(quest: &Value) -> String {
|
||
let title = read_optional_string_field(quest, "title").unwrap_or_else(|| "委托".to_string());
|
||
let reward_text = read_optional_string_field(quest, "rewardText")
|
||
.unwrap_or_else(|| "报酬已经结清。".to_string());
|
||
format!("你已经完成并交付了「{title}」。{reward_text}")
|
||
}
|
||
|
||
fn apply_quest_turn_in_rewards(game_state: &mut Value, quest: &Value) {
|
||
let Some(reward) = read_field(quest, "reward") else {
|
||
return;
|
||
};
|
||
|
||
let currency = read_i32_field(reward, "currency").unwrap_or(0).max(0);
|
||
if currency > 0 {
|
||
add_player_currency(game_state, currency);
|
||
}
|
||
|
||
let reward_items = read_array_field(reward, "items")
|
||
.into_iter()
|
||
.cloned()
|
||
.collect::<Vec<_>>();
|
||
if !reward_items.is_empty() {
|
||
add_player_inventory_items(game_state, reward_items);
|
||
}
|
||
|
||
let experience = read_i32_field(reward, "experience").unwrap_or(0).max(0);
|
||
if experience > 0 {
|
||
grant_player_progression_experience(game_state, experience, "quest");
|
||
}
|
||
}
|
||
|
||
fn infer_option_scope(function_id: &str) -> &'static str {
|
||
if function_id.starts_with("battle_") || function_id == "inventory_use" {
|
||
"combat"
|
||
} else if function_id.starts_with("npc_") {
|
||
"npc"
|
||
} else {
|
||
"story"
|
||
}
|
||
}
|
||
|
||
fn build_legacy_current_story(story_text: &str, options: &[RuntimeStoryOptionView]) -> Value {
|
||
json!({
|
||
"text": story_text,
|
||
"options": options.iter().map(build_story_option_from_runtime_option).collect::<Vec<_>>(),
|
||
"streaming": false
|
||
})
|
||
}
|
||
|
||
fn build_story_option_from_runtime_option(option: &RuntimeStoryOptionView) -> Value {
|
||
json!({
|
||
"functionId": option.function_id,
|
||
"actionText": option.action_text,
|
||
"text": option.action_text,
|
||
"detailText": option.detail_text,
|
||
"visuals": {
|
||
"playerAnimation": "idle",
|
||
"playerMoveMeters": 0,
|
||
"playerOffsetY": 0,
|
||
"playerFacing": "right",
|
||
"scrollWorld": false,
|
||
"monsterChanges": []
|
||
},
|
||
"interaction": option.interaction,
|
||
"runtimePayload": option.payload,
|
||
"disabled": option.disabled,
|
||
"disabledReason": option.reason,
|
||
})
|
||
}
|
||
|
||
fn read_story_text(current_story: Option<&Value>) -> Option<String> {
|
||
current_story.and_then(|story| read_optional_string_field(story, "text"))
|
||
}
|
||
|
||
fn build_fallback_story_text(game_state: &Value) -> String {
|
||
if read_bool_field(game_state, "inBattle").unwrap_or(false) {
|
||
let encounter_name = read_object_field(game_state, "currentEncounter")
|
||
.and_then(|encounter| read_optional_string_field(encounter, "npcName"))
|
||
.unwrap_or_else(|| "眼前的敌人".to_string());
|
||
return format!("战斗还没有结束，{encounter_name} 仍在逼你立刻做出下一步判断。");
|
||
}
|
||
|
||
if let Some(encounter) = read_object_field(game_state, "currentEncounter")
|
||
&& let Some(npc_name) = read_optional_string_field(encounter, "npcName")
|
||
{
|
||
return format!("{npc_name} 正在等你表态，当前局势已经可以继续推进。");
|
||
}
|
||
|
||
"当前故事状态已经同步到兼容状态桥，可以继续推进这一轮运行时动作。".to_string()
|
||
}
|
||
|
||
fn resolve_action_text(default_text: &str, request: &RuntimeStoryActionRequest) -> String {
|
||
request
|
||
.action
|
||
.payload
|
||
.as_ref()
|
||
.and_then(|payload| read_optional_string_field(payload, "optionText"))
|
||
.unwrap_or_else(|| default_text.to_string())
|
||
}
|
||
|
||
fn build_status_patch(game_state: &Value) -> RuntimeStoryPatch {
|
||
RuntimeStoryPatch::StatusChanged {
|
||
in_battle: read_bool_field(game_state, "inBattle").unwrap_or(false),
|
||
npc_interaction_active: read_bool_field(game_state, "npcInteractionActive")
|
||
.unwrap_or(false),
|
||
current_npc_battle_mode: read_optional_string_field(game_state, "currentNpcBattleMode"),
|
||
current_npc_battle_outcome: read_optional_string_field(
|
||
game_state,
|
||
"currentNpcBattleOutcome",
|
||
),
|
||
}
|
||
}
|
||
|
||
fn restore_player_resource(game_state: &mut Value, hp_restore: i32, mana_restore: i32) {
|
||
let max_hp = read_i32_field(game_state, "playerMaxHp")
|
||
.unwrap_or(1)
|
||
.max(1);
|
||
let max_mana = read_i32_field(game_state, "playerMaxMana")
|
||
.unwrap_or(0)
|
||
.max(0);
|
||
let hp = read_i32_field(game_state, "playerHp").unwrap_or(max_hp);
|
||
let mana = read_i32_field(game_state, "playerMana").unwrap_or(max_mana);
|
||
write_i32_field(game_state, "playerHp", (hp + hp_restore).clamp(0, max_hp));
|
||
write_i32_field(
|
||
game_state,
|
||
"playerMana",
|
||
(mana + mana_restore).clamp(0, max_mana),
|
||
);
|
||
}
|
||
|
||
fn spend_player_mana(game_state: &mut Value, mana_cost: i32) {
|
||
if mana_cost <= 0 {
|
||
return;
|
||
}
|
||
let mana = read_i32_field(game_state, "playerMana").unwrap_or(0);
|
||
write_i32_field(game_state, "playerMana", (mana - mana_cost).max(0));
|
||
}
|
||
|
||
fn apply_player_damage(game_state: &mut Value, damage: i32) {
|
||
if damage <= 0 {
|
||
return;
|
||
}
|
||
let hp = read_i32_field(game_state, "playerHp").unwrap_or(1);
|
||
write_i32_field(game_state, "playerHp", (hp - damage).max(1));
|
||
}
|
||
|
||
fn apply_target_damage(game_state: &mut Value, damage: i32) -> i32 {
|
||
let target_hp = read_object_field(game_state, "currentEncounter")
|
||
.and_then(|encounter| {
|
||
read_i32_field(encounter, "hp")
|
||
.or_else(|| read_i32_field(encounter, "currentHp"))
|
||
.or_else(|| read_i32_field(encounter, "targetHp"))
|
||
})
|
||
.or_else(|| {
|
||
read_array_field(game_state, "sceneHostileNpcs")
|
||
.first()
|
||
.and_then(|target| read_i32_field(target, "hp"))
|
||
})
|
||
.unwrap_or(24);
|
||
let next_hp = target_hp - damage.max(0);
|
||
write_current_encounter_i32_field(game_state, "hp", next_hp);
|
||
write_first_hostile_npc_i32_field(game_state, "hp", next_hp);
|
||
|
||
next_hp
|
||
}
|
||
|
||
fn battle_action_numbers(
|
||
function_id: &str,
|
||
) -> (i32, i32, i32, i32, i32, &'static str, &'static str) {
|
||
match function_id {
|
||
"battle_recover_breath" => (
|
||
0,
|
||
0,
|
||
8,
|
||
6,
|
||
0,
|
||
"恢复",
|
||
"你先稳住呼吸，把状态从危险边缘拉回一点。",
|
||
),
|
||
"battle_use_skill" => (
|
||
14,
|
||
4,
|
||
0,
|
||
0,
|
||
4,
|
||
"施放技能",
|
||
"你调动灵力打出一记更重的攻势，同时也承受了对方的反扑。",
|
||
),
|
||
"battle_all_in_crush" => (
|
||
22,
|
||
8,
|
||
0,
|
||
0,
|
||
6,
|
||
"全力压制",
|
||
"你把这一轮节奏全部压上去，试图用最强硬的方式打穿对方防线。",
|
||
),
|
||
"battle_feint_step" => (
|
||
6,
|
||
2,
|
||
0,
|
||
0,
|
||
0,
|
||
"佯攻换位",
|
||
"你用一次短促佯攻换开角度，虽然伤害有限，但避开了更重的反击。",
|
||
),
|
||
"battle_finisher_window" => (
|
||
18,
|
||
3,
|
||
0,
|
||
0,
|
||
3,
|
||
"抓住终结窗口",
|
||
"你抓住破绽打出决定性的一击，战斗天平明显向你倾斜。",
|
||
),
|
||
"battle_guard_break" => (
|
||
12,
|
||
5,
|
||
0,
|
||
0,
|
||
2,
|
||
"破开防守",
|
||
"你顶住压力破开对方防守，为后续行动争到更直接的窗口。",
|
||
),
|
||
"battle_probe_pressure" => (
|
||
5,
|
||
1,
|
||
0,
|
||
0,
|
||
0,
|
||
"试探压迫",
|
||
"你没有贸然压上，而是用轻攻测试对方反应。",
|
||
),
|
||
_ => (
|
||
10,
|
||
4,
|
||
0,
|
||
0,
|
||
0,
|
||
"普通攻击",
|
||
"你抓住当前窗口打出一记直接攻击，对方也立刻做出反击。",
|
||
),
|
||
}
|
||
}
|
||
|
||
fn battle_mode_text(value: &str) -> &'static str {
|
||
if value == "spar" { "切磋" } else { "战斗" }
|
||
}
|
||
|
||
fn current_encounter_name(game_state: &Value) -> String {
|
||
read_object_field(game_state, "currentEncounter")
|
||
.and_then(|encounter| {
|
||
read_optional_string_field(encounter, "npcName")
|
||
.or_else(|| read_optional_string_field(encounter, "name"))
|
||
})
|
||
.unwrap_or_else(|| "对方".to_string())
|
||
}
|
||
|
||
fn current_encounter_name_from_battle(game_state: &Value) -> String {
|
||
read_object_field(game_state, "currentEncounter")
|
||
.and_then(|encounter| {
|
||
read_optional_string_field(encounter, "npcName")
|
||
.or_else(|| read_optional_string_field(encounter, "name"))
|
||
})
|
||
.or_else(|| first_hostile_npc_string_field(game_state, "name"))
|
||
.unwrap_or_else(|| "眼前的敌人".to_string())
|
||
}
|
||
|
||
fn current_encounter_id(game_state: &Value) -> Option<String> {
|
||
read_object_field(game_state, "currentEncounter")
|
||
.and_then(|encounter| read_optional_string_field(encounter, "id"))
|
||
}
|
||
|
||
fn adjust_current_npc_affinity(game_state: &mut Value, delta: i32) -> Option<(String, i32, i32)> {
|
||
let npc_id = current_encounter_id(game_state)?;
|
||
let npc_name = current_encounter_name(game_state);
|
||
let state = ensure_npc_state_object(game_state, npc_id.as_str(), npc_name.as_str());
|
||
let previous_affinity = state
|
||
.get("affinity")
|
||
.and_then(Value::as_i64)
|
||
.and_then(|value| i32::try_from(value).ok())
|
||
.unwrap_or(0);
|
||
let next_affinity = (previous_affinity + delta).clamp(-100, 100);
|
||
state.insert("affinity".to_string(), json!(next_affinity));
|
||
state
|
||
.entry("recruited".to_string())
|
||
.or_insert(Value::Bool(false));
|
||
|
||
Some((npc_id, previous_affinity, next_affinity))
|
||
}
|
||
|
||
fn read_current_npc_state_i32_field(game_state: &Value, key: &str) -> Option<i32> {
|
||
let npc_id = current_encounter_id(game_state)?;
|
||
let npc_name = current_encounter_name(game_state);
|
||
resolve_current_encounter_npc_state(game_state, npc_id.as_str(), npc_name.as_str())
|
||
.and_then(|state| read_i32_field(state, key))
|
||
}
|
||
|
||
fn read_current_npc_state_bool_field(game_state: &Value, key: &str) -> Option<bool> {
|
||
let npc_id = current_encounter_id(game_state)?;
|
||
let npc_name = current_encounter_name(game_state);
|
||
resolve_current_encounter_npc_state(game_state, npc_id.as_str(), npc_name.as_str())
|
||
.and_then(|state| read_bool_field(state, key))
|
||
}
|
||
|
||
fn write_current_npc_state_i32_field(game_state: &mut Value, key: &str, value: i32) {
|
||
let Some(npc_id) = current_encounter_id(game_state) else {
|
||
return;
|
||
};
|
||
let npc_name = current_encounter_name(game_state);
|
||
let state = ensure_npc_state_object(game_state, npc_id.as_str(), npc_name.as_str());
|
||
state.insert(key.to_string(), json!(value));
|
||
}
|
||
|
||
fn write_current_npc_state_bool_field(game_state: &mut Value, key: &str, value: bool) {
|
||
let Some(npc_id) = current_encounter_id(game_state) else {
|
||
return;
|
||
};
|
||
let npc_name = current_encounter_name(game_state);
|
||
let state = ensure_npc_state_object(game_state, npc_id.as_str(), npc_name.as_str());
|
||
state.insert(key.to_string(), Value::Bool(value));
|
||
}
|
||
|
||
fn set_current_npc_recruited(game_state: &mut Value, recruited: bool) -> Option<(i32, i32)> {
|
||
let npc_id = current_encounter_id(game_state)?;
|
||
let npc_name = current_encounter_name(game_state);
|
||
let state = ensure_npc_state_object(game_state, npc_id.as_str(), npc_name.as_str());
|
||
let previous_affinity = state
|
||
.get("affinity")
|
||
.and_then(Value::as_i64)
|
||
.and_then(|value| i32::try_from(value).ok())
|
||
.unwrap_or(0);
|
||
let next_affinity = previous_affinity.max(60);
|
||
state.insert("affinity".to_string(), json!(next_affinity));
|
||
state.insert("recruited".to_string(), Value::Bool(recruited));
|
||
|
||
Some((previous_affinity, next_affinity))
|
||
}
|
||
|
||
fn read_current_npc_affinity(game_state: &Value) -> i32 {
|
||
let Some(npc_id) = current_encounter_id(game_state) else {
|
||
return 0;
|
||
};
|
||
let npc_name = current_encounter_name(game_state);
|
||
resolve_current_encounter_npc_state(game_state, npc_id.as_str(), npc_name.as_str())
|
||
.and_then(|state| read_i32_field(state, "affinity"))
|
||
.unwrap_or(0)
|
||
}
|
||
|
||
fn ensure_npc_state_object<'a>(
|
||
game_state: &'a mut Value,
|
||
npc_id: &str,
|
||
npc_name: &str,
|
||
) -> &'a mut Map<String, Value> {
|
||
let root = ensure_json_object(game_state);
|
||
let npc_states = root
|
||
.entry("npcStates".to_string())
|
||
.or_insert_with(|| Value::Object(Map::new()));
|
||
if !npc_states.is_object() {
|
||
*npc_states = Value::Object(Map::new());
|
||
}
|
||
let states = npc_states
|
||
.as_object_mut()
|
||
.expect("npcStates should be object");
|
||
let existing_key = if states.contains_key(npc_id) {
|
||
npc_id.to_string()
|
||
} else if states.contains_key(npc_name) {
|
||
npc_name.to_string()
|
||
} else {
|
||
npc_id.to_string()
|
||
};
|
||
let state = states
|
||
.entry(existing_key)
|
||
.or_insert_with(|| Value::Object(Map::new()));
|
||
if !state.is_object() {
|
||
*state = Value::Object(Map::new());
|
||
}
|
||
state.as_object_mut().expect("npc state should be object")
|
||
}
|
||
|
||
fn add_companion_if_absent(
|
||
game_state: &mut Value,
|
||
npc_id: &str,
|
||
character_id: Option<String>,
|
||
joined_at_affinity: i32,
|
||
) {
|
||
let root = ensure_json_object(game_state);
|
||
let companions = root
|
||
.entry("companions".to_string())
|
||
.or_insert_with(|| Value::Array(Vec::new()));
|
||
if !companions.is_array() {
|
||
*companions = Value::Array(Vec::new());
|
||
}
|
||
let items = companions
|
||
.as_array_mut()
|
||
.expect("companions should be array");
|
||
if items
|
||
.iter()
|
||
.any(|item| read_optional_string_field(item, "npcId").is_some_and(|value| value == npc_id))
|
||
{
|
||
return;
|
||
}
|
||
items.push(json!({
|
||
"npcId": npc_id,
|
||
"characterId": character_id,
|
||
"joinedAtAffinity": joined_at_affinity,
|
||
}));
|
||
}
|
||
|
||
fn remove_companion_by_npc_id(game_state: &mut Value, npc_id: &str) -> Option<Value> {
|
||
let root = ensure_json_object(game_state);
|
||
let companions = root
|
||
.entry("companions".to_string())
|
||
.or_insert_with(|| Value::Array(Vec::new()));
|
||
if !companions.is_array() {
|
||
*companions = Value::Array(Vec::new());
|
||
}
|
||
let items = companions
|
||
.as_array_mut()
|
||
.expect("companions should be array");
|
||
let index = items.iter().position(|item| {
|
||
read_optional_string_field(item, "npcId").is_some_and(|value| value == npc_id)
|
||
})?;
|
||
Some(items.remove(index))
|
||
}
|
||
|
||
fn recruit_companion_to_party(
|
||
game_state: &mut Value,
|
||
npc_id: &str,
|
||
_npc_name: &str,
|
||
release_npc_id: Option<&str>,
|
||
) -> Result<Option<String>, String> {
|
||
let companion_count = read_array_field(game_state, "companions").len();
|
||
if companion_count < MAX_TASK5_COMPANIONS {
|
||
add_companion_if_absent(
|
||
game_state,
|
||
npc_id,
|
||
None,
|
||
read_current_npc_affinity(game_state),
|
||
);
|
||
return Ok(None);
|
||
}
|
||
|
||
let Some(release_npc_id) = release_npc_id.and_then(normalize_required_string) else {
|
||
return Err("队伍已满时必须明确指定一名离队同伴".to_string());
|
||
};
|
||
|
||
let released_companion = remove_companion_by_npc_id(game_state, release_npc_id.as_str())
|
||
.ok_or_else(|| "指定的离队同伴不存在，无法完成换队招募".to_string())?;
|
||
let released_name = read_optional_string_field(&released_companion, "displayName")
|
||
.or_else(|| read_optional_string_field(&released_companion, "name"))
|
||
.or_else(|| read_optional_string_field(&released_companion, "npcName"))
|
||
.unwrap_or_else(|| release_npc_id.clone());
|
||
add_companion_if_absent(
|
||
game_state,
|
||
npc_id,
|
||
None,
|
||
read_current_npc_affinity(game_state),
|
||
);
|
||
Ok(Some(released_name))
|
||
}
|
||
|
||
fn clear_encounter_state(game_state: &mut Value) {
|
||
clear_encounter_only(game_state);
|
||
write_bool_field(game_state, "inBattle", false);
|
||
write_bool_field(game_state, "npcInteractionActive", false);
|
||
write_null_field(game_state, "currentNpcBattleMode");
|
||
}
|
||
|
||
fn clear_encounter_only(game_state: &mut Value) {
|
||
write_null_field(game_state, "currentEncounter");
|
||
let root = ensure_json_object(game_state);
|
||
root.insert("sceneHostileNpcs".to_string(), Value::Array(Vec::new()));
|
||
}
|
||
|
||
fn append_story_history(game_state: &mut Value, action_text: &str, result_text: &str) {
|
||
let root = ensure_json_object(game_state);
|
||
let story_history = root
|
||
.entry("storyHistory".to_string())
|
||
.or_insert_with(|| Value::Array(Vec::new()));
|
||
if !story_history.is_array() {
|
||
*story_history = Value::Array(Vec::new());
|
||
}
|
||
let entries = story_history
|
||
.as_array_mut()
|
||
.expect("storyHistory should be array");
|
||
entries.push(json!({
|
||
"text": action_text,
|
||
"historyRole": "action",
|
||
}));
|
||
entries.push(json!({
|
||
"text": result_text,
|
||
"historyRole": "result",
|
||
}));
|
||
}
|
||
|
||
fn increment_runtime_stat(game_state: &mut Value, key: &str, delta: i32) {
|
||
let root = ensure_json_object(game_state);
|
||
let stats = root
|
||
.entry("runtimeStats".to_string())
|
||
.or_insert_with(|| Value::Object(Map::new()));
|
||
if !stats.is_object() {
|
||
*stats = Value::Object(Map::new());
|
||
}
|
||
let stats = stats
|
||
.as_object_mut()
|
||
.expect("runtimeStats should be object");
|
||
let previous = stats
|
||
.get(key)
|
||
.and_then(Value::as_i64)
|
||
.and_then(|value| i32::try_from(value).ok())
|
||
.unwrap_or(0);
|
||
stats.insert(key.to_string(), json!((previous + delta).max(0)));
|
||
}
|
||
|
||
fn add_player_currency(game_state: &mut Value, delta: i32) {
|
||
let previous = read_i32_field(game_state, "playerCurrency").unwrap_or(0);
|
||
write_i32_field(
|
||
game_state,
|
||
"playerCurrency",
|
||
previous.saturating_add(delta.max(0)),
|
||
);
|
||
}
|
||
|
||
fn add_player_inventory_items(game_state: &mut Value, additions: Vec<Value>) {
|
||
if additions.is_empty() {
|
||
return;
|
||
}
|
||
|
||
let root = ensure_json_object(game_state);
|
||
let inventory = root
|
||
.entry("playerInventory".to_string())
|
||
.or_insert_with(|| Value::Array(Vec::new()));
|
||
if !inventory.is_array() {
|
||
*inventory = Value::Array(Vec::new());
|
||
}
|
||
let items = inventory
|
||
.as_array_mut()
|
||
.expect("playerInventory should be array");
|
||
items.extend(additions);
|
||
}
|
||
|
||
fn grant_player_progression_experience(game_state: &mut Value, amount: i32, source: &str) {
|
||
if amount <= 0 {
|
||
return;
|
||
}
|
||
|
||
let root = ensure_json_object(game_state);
|
||
let progression = root
|
||
.entry("playerProgression".to_string())
|
||
.or_insert_with(|| Value::Object(Map::new()));
|
||
if !progression.is_object() {
|
||
*progression = Value::Object(Map::new());
|
||
}
|
||
let progression = progression
|
||
.as_object_mut()
|
||
.expect("playerProgression should be object");
|
||
let previous_total_xp = progression
|
||
.get("totalXp")
|
||
.and_then(Value::as_i64)
|
||
.and_then(|value| i32::try_from(value).ok())
|
||
.unwrap_or(0)
|
||
.max(0);
|
||
let next_total_xp = previous_total_xp.saturating_add(amount);
|
||
let level = resolve_progression_level(next_total_xp);
|
||
let current_level_xp = next_total_xp.saturating_sub(cumulative_xp_required(level));
|
||
let xp_to_next_level = if level >= MAX_PLAYER_LEVEL {
|
||
0
|
||
} else {
|
||
xp_to_next_level_for(level)
|
||
};
|
||
|
||
progression.insert("level".to_string(), json!(level));
|
||
progression.insert("currentLevelXp".to_string(), json!(current_level_xp.max(0)));
|
||
progression.insert("totalXp".to_string(), json!(next_total_xp));
|
||
progression.insert("xpToNextLevel".to_string(), json!(xp_to_next_level.max(0)));
|
||
progression.insert("pendingLevelUps".to_string(), json!(0));
|
||
progression.insert(
|
||
"lastGrantedSource".to_string(),
|
||
Value::String(source.to_string()),
|
||
);
|
||
}
|
||
|
||
const MAX_PLAYER_LEVEL: i32 = 20;
|
||
|
||
fn xp_to_next_level_for(level: i32) -> i32 {
|
||
if level >= MAX_PLAYER_LEVEL {
|
||
0
|
||
} else {
|
||
let scale = (level - 1).max(0);
|
||
60 + 20 * scale + 8 * scale * scale
|
||
}
|
||
}
|
||
|
||
fn cumulative_xp_required(level: i32) -> i32 {
|
||
let mut total = 0;
|
||
let capped_level = level.clamp(1, MAX_PLAYER_LEVEL);
|
||
for current_level in 1..capped_level {
|
||
total += xp_to_next_level_for(current_level);
|
||
}
|
||
total
|
||
}
|
||
|
||
fn resolve_progression_level(total_xp: i32) -> i32 {
|
||
let normalized_total_xp = total_xp.max(0);
|
||
let mut resolved_level = 1;
|
||
for level in 2..=MAX_PLAYER_LEVEL {
|
||
if normalized_total_xp < cumulative_xp_required(level) {
|
||
break;
|
||
}
|
||
resolved_level = level;
|
||
}
|
||
resolved_level
|
||
}
|
||
|
||
fn write_current_encounter_i32_field(game_state: &mut Value, key: &str, value: i32) {
|
||
let root = ensure_json_object(game_state);
|
||
let Some(encounter) = root.get_mut("currentEncounter") else {
|
||
return;
|
||
};
|
||
if let Some(encounter) = encounter.as_object_mut() {
|
||
encounter.insert(key.to_string(), json!(value));
|
||
}
|
||
}
|
||
|
||
fn write_first_hostile_npc_i32_field(game_state: &mut Value, key: &str, value: i32) {
|
||
let root = ensure_json_object(game_state);
|
||
let Some(hostiles) = root.get_mut("sceneHostileNpcs") else {
|
||
return;
|
||
};
|
||
let Some(first) = hostiles.as_array_mut().and_then(|items| items.first_mut()) else {
|
||
return;
|
||
};
|
||
if let Some(first) = first.as_object_mut() {
|
||
first.insert(key.to_string(), json!(value));
|
||
}
|
||
}
|
||
|
||
fn first_hostile_npc_string_field(game_state: &Value, key: &str) -> Option<String> {
|
||
read_array_field(game_state, "sceneHostileNpcs")
|
||
.first()
|
||
.and_then(|target| read_optional_string_field(target, key))
|
||
}
|
||
|
||
fn read_runtime_session_id(game_state: &Value) -> Option<String> {
|
||
read_optional_string_field(game_state, "runtimeSessionId")
|
||
}
|
||
|
||
fn read_field<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
|
||
value.as_object()?.get(key)
|
||
}
|
||
|
||
fn read_object_field<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
|
||
let field = read_field(value, key)?;
|
||
field.is_object().then_some(field)
|
||
}
|
||
|
||
fn read_array_field<'a>(value: &'a Value, key: &str) -> Vec<&'a Value> {
|
||
read_field(value, key)
|
||
.and_then(Value::as_array)
|
||
.map(|items| items.iter().collect())
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn read_required_string_field(value: &Value, key: &str) -> Option<String> {
|
||
normalize_required_string(read_field(value, key)?.as_str()?)
|
||
}
|
||
|
||
fn read_optional_string_field(value: &Value, key: &str) -> Option<String> {
|
||
normalize_optional_string(read_field(value, key).and_then(Value::as_str))
|
||
}
|
||
|
||
fn read_bool_field(value: &Value, key: &str) -> Option<bool> {
|
||
read_field(value, key).and_then(Value::as_bool)
|
||
}
|
||
|
||
fn read_i32_field(value: &Value, key: &str) -> Option<i32> {
|
||
read_field(value, key)
|
||
.and_then(Value::as_i64)
|
||
.and_then(|number| i32::try_from(number).ok())
|
||
}
|
||
|
||
fn read_u32_field(value: &Value, key: &str) -> Option<u32> {
|
||
read_field(value, key)
|
||
.and_then(Value::as_u64)
|
||
.and_then(|number| u32::try_from(number).ok())
|
||
}
|
||
|
||
fn write_i32_field(value: &mut Value, key: &str, field_value: i32) {
|
||
ensure_json_object(value).insert(key.to_string(), json!(field_value));
|
||
}
|
||
|
||
fn write_u32_field(value: &mut Value, key: &str, field_value: u32) {
|
||
ensure_json_object(value).insert(key.to_string(), json!(field_value));
|
||
}
|
||
|
||
fn write_bool_field(value: &mut Value, key: &str, field_value: bool) {
|
||
ensure_json_object(value).insert(key.to_string(), Value::Bool(field_value));
|
||
}
|
||
|
||
fn write_string_field(value: &mut Value, key: &str, field_value: &str) {
|
||
ensure_json_object(value).insert(key.to_string(), Value::String(field_value.to_string()));
|
||
}
|
||
|
||
fn write_null_field(value: &mut Value, key: &str) {
|
||
ensure_json_object(value).insert(key.to_string(), Value::Null);
|
||
}
|
||
|
||
fn ensure_json_object(value: &mut Value) -> &mut Map<String, Value> {
|
||
if !value.is_object() {
|
||
*value = Value::Object(Map::new());
|
||
}
|
||
value.as_object_mut().expect("value should be object")
|
||
}
|
||
|
||
fn normalize_required_string(value: &str) -> Option<String> {
|
||
let trimmed = value.trim();
|
||
(!trimmed.is_empty()).then(|| trimmed.to_string())
|
||
}
|
||
|
||
fn normalize_optional_string(value: Option<&str>) -> Option<String> {
|
||
value.and_then(normalize_required_string)
|
||
}
|
||
|
||
fn format_now_rfc3339() -> String {
|
||
format_rfc3339(OffsetDateTime::now_utc()).unwrap_or_else(|_| "1970-01-01T00:00:00Z".to_string())
|
||
}
|
||
|
||
fn map_runtime_story_client_error(error: SpacetimeClientError) -> AppError {
|
||
let (status, provider) = match error {
|
||
SpacetimeClientError::Runtime(_) => (StatusCode::BAD_REQUEST, "runtime-story"),
|
||
_ => (StatusCode::BAD_GATEWAY, "spacetimedb"),
|
||
};
|
||
|
||
AppError::from_status(status).with_details(json!({
|
||
"provider": provider,
|
||
"message": error.to_string(),
|
||
}))
|
||
}
|
||
|
||
fn runtime_story_error_response(request_context: &RequestContext, error: AppError) -> Response {
|
||
error.into_response_with_context(Some(request_context))
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use axum::{
|
||
body::Body,
|
||
http::{Request, StatusCode},
|
||
};
|
||
use http_body_util::BodyExt;
|
||
use platform_auth::{
|
||
AccessTokenClaims, AccessTokenClaimsInput, AuthProvider, BindingStatus, sign_access_token,
|
||
};
|
||
use serde_json::{Value, json};
|
||
use time::OffsetDateTime;
|
||
use tower::ServiceExt;
|
||
|
||
use super::*;
|
||
use crate::{app::build_router, config::AppConfig, state::AppState};
|
||
|
||
#[tokio::test]
|
||
async fn runtime_story_state_resolve_requires_authentication() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/runtime/story/state/resolve")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"sessionId": "runtime-main",
|
||
"snapshot": {
|
||
"bottomTab": "adventure",
|
||
"gameState": {
|
||
"runtimeSessionId": "runtime-main"
|
||
},
|
||
"currentStory": null
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn runtime_story_state_get_requires_authentication() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/runtime/story/state/runtime-main")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn runtime_story_action_resolve_requires_authentication() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/runtime/story/actions/resolve")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"sessionId": "runtime-main",
|
||
"action": {
|
||
"type": "story_choice",
|
||
"functionId": "idle_rest_focus"
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn runtime_story_routes_resolve_through_rust_route_boundary() {
|
||
let state = seed_authenticated_state().await;
|
||
let token = issue_access_token(&state);
|
||
let app = build_router(state);
|
||
let snapshot_payload = json!({
|
||
"bottomTab": "adventure",
|
||
"gameState": build_runtime_story_boundary_game_state_fixture(),
|
||
"currentStory": {
|
||
"text": "巡路人看着你，像在等一句开口。",
|
||
"options": []
|
||
}
|
||
});
|
||
|
||
let put_response = app
|
||
.clone()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("PUT")
|
||
.uri("/api/runtime/save/snapshot")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(snapshot_payload.to_string()))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
assert_eq!(put_response.status(), StatusCode::OK);
|
||
|
||
let state_response = app
|
||
.clone()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/runtime/story/state/runtime-main")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
assert_eq!(state_response.status(), StatusCode::OK);
|
||
let state_payload: Value = serde_json::from_slice(
|
||
&state_response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes(),
|
||
)
|
||
.expect("response should be json");
|
||
assert!(
|
||
state_payload["data"]["viewModel"]["availableOptions"]
|
||
.as_array()
|
||
.is_some_and(|options| options
|
||
.iter()
|
||
.any(|option| { option["functionId"] == json!("npc_chat") }))
|
||
);
|
||
|
||
let action_response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/runtime/story/actions/resolve")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(
|
||
json!({
|
||
"sessionId": "runtime-main",
|
||
"clientVersion": 0,
|
||
"action": {
|
||
"type": "story_choice",
|
||
"functionId": "npc_chat"
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
assert_eq!(action_response.status(), StatusCode::OK);
|
||
let action_payload: Value = serde_json::from_slice(
|
||
&action_response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes(),
|
||
)
|
||
.expect("response should be json");
|
||
assert_eq!(action_payload["data"]["serverVersion"], json!(1));
|
||
assert_eq!(
|
||
action_payload["data"]["viewModel"]["encounter"]["affinity"],
|
||
json!(52)
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn runtime_story_action_resolve_rejects_client_version_conflict() {
|
||
let state = seed_authenticated_state().await;
|
||
let token = issue_access_token(&state);
|
||
let app = build_router(state);
|
||
|
||
let put_response = app
|
||
.clone()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("PUT")
|
||
.uri("/api/runtime/save/snapshot")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(
|
||
json!({
|
||
"bottomTab": "adventure",
|
||
"gameState": {
|
||
"runtimeSessionId": "runtime-main",
|
||
"runtimeActionVersion": 5,
|
||
"playerHp": 20,
|
||
"playerMaxHp": 30,
|
||
"playerMana": 4,
|
||
"playerMaxMana": 12,
|
||
"storyHistory": []
|
||
},
|
||
"currentStory": {
|
||
"text": "旧局势仍然悬着。",
|
||
"options": []
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
assert_eq!(put_response.status(), StatusCode::OK);
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/runtime/story/actions/resolve")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(
|
||
json!({
|
||
"sessionId": "runtime-main",
|
||
"clientVersion": 4,
|
||
"action": {
|
||
"type": "story_choice",
|
||
"functionId": "idle_rest_focus"
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::CONFLICT);
|
||
let payload: Value = serde_json::from_slice(
|
||
&response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes(),
|
||
)
|
||
.expect("response should be json");
|
||
assert_eq!(payload["error"]["details"]["clientVersion"], json!(4));
|
||
assert_eq!(payload["error"]["details"]["serverVersion"], json!(5));
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn runtime_story_initial_returns_fallback_without_llm() {
|
||
let state = seed_authenticated_state().await;
|
||
let token = issue_access_token(&state);
|
||
let app = build_router(state);
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/runtime/story/initial")
|
||
.header("authorization", format!("Bearer {token}"))
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "v1")
|
||
.body(Body::from(
|
||
json!({
|
||
"worldType": "martial",
|
||
"character": { "name": "林迟" },
|
||
"monsters": [],
|
||
"context": { "sceneName": "旧驿道" },
|
||
"requestOptions": {
|
||
"availableOptions": [{
|
||
"functionId": "idle_observe_signs",
|
||
"actionText": "观察周围迹象"
|
||
}]
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(payload["ok"], Value::Bool(true));
|
||
assert_eq!(
|
||
payload["data"]["options"][0]["functionId"],
|
||
json!("idle_observe_signs")
|
||
);
|
||
assert!(
|
||
payload["data"]["storyText"]
|
||
.as_str()
|
||
.is_some_and(|text| text.contains("林迟"))
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_state_compiler_prefers_dialogue_deferred_options() {
|
||
let response = build_runtime_story_state_response(
|
||
"runtime-main",
|
||
Some(7),
|
||
RuntimeStorySnapshotPayload {
|
||
saved_at: None,
|
||
bottom_tab: "adventure".to_string(),
|
||
game_state: json!({
|
||
"runtimeSessionId": "runtime-main",
|
||
"runtimeActionVersion": 7,
|
||
"playerHp": 32,
|
||
"playerMaxHp": 40,
|
||
"playerMana": 18,
|
||
"playerMaxMana": 20,
|
||
"inBattle": false,
|
||
"npcInteractionActive": true,
|
||
"currentEncounter": {
|
||
"id": "npc_camp_firekeeper",
|
||
"kind": "npc",
|
||
"npcName": "守火人",
|
||
"hostile": false
|
||
},
|
||
"npcStates": {
|
||
"npc_camp_firekeeper": {
|
||
"affinity": 12,
|
||
"recruited": false
|
||
}
|
||
},
|
||
"companions": [{
|
||
"npcId": "npc_companion_001",
|
||
"characterId": "char_companion_001",
|
||
"joinedAtAffinity": 64
|
||
}]
|
||
}),
|
||
current_story: Some(json!({
|
||
"text": "守火人抬眼看了你一瞬，示意你把想问的话继续说完。",
|
||
"displayMode": "dialogue",
|
||
"options": [{
|
||
"functionId": "story_continue_adventure",
|
||
"actionText": "继续冒险"
|
||
}],
|
||
"deferredOptions": [{
|
||
"functionId": "npc_chat",
|
||
"actionText": "继续交谈",
|
||
"detailText": "围绕当前话题继续推进关系判断。",
|
||
"interaction": {
|
||
"kind": "npc",
|
||
"npcId": "npc_camp_firekeeper",
|
||
"action": "chat"
|
||
},
|
||
"runtimePayload": {
|
||
"note": "server-runtime-test"
|
||
}
|
||
}]
|
||
})),
|
||
},
|
||
);
|
||
|
||
assert_eq!(response.session_id, "runtime-main");
|
||
assert_eq!(response.server_version, 7);
|
||
assert_eq!(
|
||
response
|
||
.view_model
|
||
.encounter
|
||
.as_ref()
|
||
.expect("encounter should exist")
|
||
.npc_name,
|
||
"守火人"
|
||
);
|
||
assert_eq!(
|
||
response.view_model.available_options[0].function_id,
|
||
"npc_chat"
|
||
);
|
||
assert!(matches!(
|
||
response.presentation.options[0].interaction,
|
||
Some(RuntimeStoryOptionInteraction::Npc { .. })
|
||
));
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_action_resolution_updates_version_and_history() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(3),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "idle_rest_focus".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({ "optionText": "原地调息" })),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
let mut game_state = json!({
|
||
"runtimeSessionId": "runtime-main",
|
||
"runtimeActionVersion": 3,
|
||
"playerHp": 10,
|
||
"playerMaxHp": 30,
|
||
"playerMana": 2,
|
||
"playerMaxMana": 12,
|
||
"storyHistory": []
|
||
});
|
||
|
||
let resolution =
|
||
resolve_runtime_story_choice_action(&mut game_state, None, &request, "idle_rest_focus")
|
||
.expect("action should resolve");
|
||
let next_version = read_u32_field(&game_state, "runtimeActionVersion")
|
||
.unwrap_or(3)
|
||
.saturating_add(1);
|
||
write_u32_field(&mut game_state, "runtimeActionVersion", next_version);
|
||
append_story_history(
|
||
&mut game_state,
|
||
resolution.action_text.as_str(),
|
||
resolution.result_text.as_str(),
|
||
);
|
||
|
||
assert_eq!(read_i32_field(&game_state, "playerHp"), Some(18));
|
||
assert_eq!(read_i32_field(&game_state, "playerMana"), Some(8));
|
||
assert_eq!(read_u32_field(&game_state, "runtimeActionVersion"), Some(4));
|
||
assert_eq!(
|
||
read_array_field(&game_state, "storyHistory")
|
||
.first()
|
||
.and_then(|entry| read_optional_string_field(entry, "historyRole")),
|
||
Some("action".to_string())
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_npc_help_is_one_shot_and_restores_resources() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(0),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "npc_help".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({ "optionText": "请求援手" })),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
let mut game_state = build_runtime_story_boundary_game_state_fixture();
|
||
write_i32_field(&mut game_state, "playerHp", 20);
|
||
write_i32_field(&mut game_state, "playerMana", 4);
|
||
|
||
let first =
|
||
resolve_runtime_story_choice_action(&mut game_state, None, &request, "npc_help")
|
||
.expect("first help should resolve");
|
||
|
||
assert!(first.result_text.contains("及时支援"));
|
||
assert_eq!(read_i32_field(&game_state, "playerHp"), Some(30));
|
||
assert_eq!(read_i32_field(&game_state, "playerMana"), Some(12));
|
||
assert_eq!(
|
||
read_current_npc_state_bool_field(&game_state, "helpUsed"),
|
||
Some(true)
|
||
);
|
||
|
||
let second =
|
||
resolve_runtime_story_choice_action(&mut game_state, None, &request, "npc_help");
|
||
match second {
|
||
Ok(_) => panic!("second help should be rejected"),
|
||
Err(error) => assert_eq!(error, "当前 NPC 的一次性援手已经用完了"),
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_npc_recruit_requires_threshold_and_release_target_when_party_full() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(0),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "npc_recruit".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({ "optionText": "邀请同行" })),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
|
||
let mut low_affinity_state = build_runtime_story_boundary_game_state_fixture();
|
||
let error = resolve_runtime_story_choice_action(
|
||
&mut low_affinity_state,
|
||
None,
|
||
&request,
|
||
"npc_recruit",
|
||
);
|
||
match error {
|
||
Ok(_) => panic!("low affinity recruit should be rejected"),
|
||
Err(message) => assert_eq!(message, "当前关系还没达到招募阈值，暂时不能邀请入队"),
|
||
}
|
||
|
||
let mut full_party_state = build_runtime_story_boundary_game_state_fixture();
|
||
write_current_npc_state_i32_field(&mut full_party_state, "affinity", 60);
|
||
let root = ensure_json_object(&mut full_party_state);
|
||
root.insert(
|
||
"companions".to_string(),
|
||
json!([
|
||
{
|
||
"npcId": "npc-ally-1",
|
||
"characterId": "char-ally-1",
|
||
"joinedAtAffinity": 64,
|
||
"npcName": "旧同伴甲"
|
||
},
|
||
{
|
||
"npcId": "npc-ally-2",
|
||
"characterId": "char-ally-2",
|
||
"joinedAtAffinity": 61,
|
||
"npcName": "旧同伴乙"
|
||
}
|
||
]),
|
||
);
|
||
|
||
let full_party_error = resolve_runtime_story_choice_action(
|
||
&mut full_party_state,
|
||
None,
|
||
&request,
|
||
"npc_recruit",
|
||
);
|
||
match full_party_error {
|
||
Ok(_) => panic!("full party recruit should require release target"),
|
||
Err(message) => assert_eq!(message, "队伍已满时必须明确指定一名离队同伴"),
|
||
}
|
||
|
||
let request_with_release = RuntimeStoryActionRequest {
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
payload: Some(json!({
|
||
"optionText": "邀请同行",
|
||
"releaseNpcId": "npc-ally-1"
|
||
})),
|
||
..request.action.clone()
|
||
},
|
||
..request
|
||
};
|
||
let resolution = resolve_runtime_story_choice_action(
|
||
&mut full_party_state,
|
||
None,
|
||
&request_with_release,
|
||
"npc_recruit",
|
||
)
|
||
.expect("recruit with release target should resolve");
|
||
|
||
assert!(resolution.result_text.contains("旧同伴甲"));
|
||
assert_eq!(read_array_field(&full_party_state, "companions").len(), 2);
|
||
assert!(
|
||
read_array_field(&full_party_state, "companions")
|
||
.iter()
|
||
.any(|entry| {
|
||
read_optional_string_field(entry, "npcId").as_deref() == Some("npc_merchant_01")
|
||
})
|
||
);
|
||
assert_eq!(
|
||
read_field(&full_party_state, "currentEncounter"),
|
||
Some(&Value::Null)
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_quest_offer_replace_updates_pending_offer_and_payload() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(0),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "npc_chat_quest_offer_replace".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({
|
||
"optionText": "更换任务"
|
||
})),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
let mut game_state = build_runtime_story_boundary_game_state_fixture();
|
||
let current_story = build_runtime_story_pending_quest_offer_fixture(
|
||
build_runtime_story_boundary_quest_fixture("quest-bridge-offer", "断桥口的密信"),
|
||
);
|
||
|
||
let resolution = resolve_runtime_story_choice_action(
|
||
&mut game_state,
|
||
Some(¤t_story),
|
||
&request,
|
||
"npc_chat_quest_offer_replace",
|
||
)
|
||
.expect("quest replace should resolve");
|
||
|
||
let saved_current_story = resolution
|
||
.saved_current_story
|
||
.expect("quest replace should save current story");
|
||
let pending_quest = read_field(&saved_current_story, "npcChatState")
|
||
.and_then(|state| read_field(state, "pendingQuestOffer"))
|
||
.and_then(|offer| read_field(offer, "quest"))
|
||
.expect("pending quest should exist after replace");
|
||
assert_eq!(
|
||
read_optional_string_field(pending_quest, "id"),
|
||
Some("quest-bridge-replaced".to_string())
|
||
);
|
||
|
||
let options = resolution
|
||
.presentation_options
|
||
.expect("quest replace should expose options");
|
||
assert_eq!(options.len(), 3);
|
||
assert_eq!(
|
||
options[1].payload.as_ref().and_then(|payload| {
|
||
read_optional_string_field(payload, "npcChatQuestOfferAction")
|
||
}),
|
||
Some("replace".to_string())
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_quest_offer_abandon_clears_pending_offer_and_restores_chat_options() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(0),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "npc_chat_quest_offer_abandon".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({
|
||
"optionText": "放弃任务"
|
||
})),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
let mut game_state = build_runtime_story_boundary_game_state_fixture();
|
||
let current_story = build_runtime_story_pending_quest_offer_fixture(
|
||
build_runtime_story_boundary_quest_fixture("quest-bridge-offer", "断桥口的密信"),
|
||
);
|
||
|
||
let resolution = resolve_runtime_story_choice_action(
|
||
&mut game_state,
|
||
Some(¤t_story),
|
||
&request,
|
||
"npc_chat_quest_offer_abandon",
|
||
)
|
||
.expect("quest abandon should resolve");
|
||
|
||
let saved_current_story = resolution
|
||
.saved_current_story
|
||
.expect("quest abandon should save current story");
|
||
assert_eq!(
|
||
read_field(&saved_current_story, "npcChatState")
|
||
.and_then(|state| read_field(state, "pendingQuestOffer")),
|
||
Some(&Value::Null)
|
||
);
|
||
let options = resolution
|
||
.presentation_options
|
||
.expect("quest abandon should expose follow-up chat options");
|
||
assert_eq!(options.len(), 3);
|
||
assert!(
|
||
options
|
||
.iter()
|
||
.all(|option| option.function_id == "npc_chat")
|
||
);
|
||
assert_eq!(options[0].action_text, "那先继续聊聊你刚才没说完的部分");
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_quest_accept_writes_quest_runtime_stats_and_followup_story() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(0),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "npc_quest_accept".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({
|
||
"optionText": "接受任务"
|
||
})),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
let mut game_state = build_runtime_story_boundary_game_state_fixture();
|
||
let pending_quest =
|
||
build_runtime_story_boundary_quest_fixture("quest-bridge-offer", "断桥口的密信");
|
||
let current_story = build_runtime_story_pending_quest_offer_fixture(pending_quest.clone());
|
||
|
||
let resolution = resolve_runtime_story_choice_action(
|
||
&mut game_state,
|
||
Some(¤t_story),
|
||
&request,
|
||
"npc_quest_accept",
|
||
)
|
||
.expect("quest accept should resolve");
|
||
|
||
let quests = read_array_field(&game_state, "quests");
|
||
assert_eq!(quests.len(), 1);
|
||
assert_eq!(
|
||
read_optional_string_field(quests[0], "id"),
|
||
read_optional_string_field(&pending_quest, "id")
|
||
);
|
||
assert_eq!(
|
||
read_field(&game_state, "runtimeStats")
|
||
.and_then(|stats| read_i32_field(stats, "questsAccepted")),
|
||
Some(1)
|
||
);
|
||
let saved_current_story = resolution
|
||
.saved_current_story
|
||
.expect("quest accept should save current story");
|
||
assert_eq!(
|
||
read_field(&saved_current_story, "npcChatState")
|
||
.and_then(|state| read_field(state, "pendingQuestOffer")),
|
||
Some(&Value::Null)
|
||
);
|
||
assert_eq!(
|
||
resolution
|
||
.presentation_options
|
||
.expect("quest accept should expose follow-up options")
|
||
.len(),
|
||
3
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn runtime_story_quest_turn_in_marks_quest_rewards_and_affinity() {
|
||
let request = RuntimeStoryActionRequest {
|
||
session_id: "runtime-main".to_string(),
|
||
client_version: Some(0),
|
||
action: shared_contracts::runtime_story::RuntimeStoryChoiceAction {
|
||
action_type: "story_choice".to_string(),
|
||
function_id: "npc_quest_turn_in".to_string(),
|
||
target_id: None,
|
||
payload: Some(json!({
|
||
"optionText": "交付任务",
|
||
"questId": "quest-bridge-complete"
|
||
})),
|
||
},
|
||
snapshot: None,
|
||
};
|
||
let mut game_state = build_runtime_story_boundary_game_state_fixture();
|
||
let mut completed_quest =
|
||
build_runtime_story_boundary_quest_fixture("quest-bridge-complete", "断桥夜巡");
|
||
if let Some(quest) = completed_quest.as_object_mut() {
|
||
quest.insert("status".to_string(), Value::String("completed".to_string()));
|
||
quest.insert(
|
||
"reward".to_string(),
|
||
json!({
|
||
"affinityBonus": 6,
|
||
"currency": 30,
|
||
"experience": 24,
|
||
"items": [{
|
||
"id": "reward-med-1",
|
||
"category": "补给",
|
||
"name": "回气散",
|
||
"quantity": 1,
|
||
"tags": []
|
||
}]
|
||
}),
|
||
);
|
||
}
|
||
push_quest_record(&mut game_state, &completed_quest);
|
||
|
||
let resolution = resolve_runtime_story_choice_action(
|
||
&mut game_state,
|
||
None,
|
||
&request,
|
||
"npc_quest_turn_in",
|
||
)
|
||
.expect("quest turn in should resolve");
|
||
|
||
let quests = read_array_field(&game_state, "quests");
|
||
assert_eq!(quests.len(), 1);
|
||
assert_eq!(
|
||
read_optional_string_field(quests[0], "status"),
|
||
Some("turned_in".to_string())
|
||
);
|
||
assert_eq!(read_i32_field(&game_state, "playerCurrency"), Some(120));
|
||
assert_eq!(read_array_field(&game_state, "playerInventory").len(), 1);
|
||
assert_eq!(
|
||
read_field(&game_state, "playerProgression")
|
||
.and_then(|progression| read_i32_field(progression, "totalXp")),
|
||
Some(24)
|
||
);
|
||
assert_eq!(
|
||
read_current_npc_state_i32_field(&game_state, "affinity"),
|
||
Some(52)
|
||
);
|
||
assert!(resolution.patches.iter().any(|patch| matches!(
|
||
patch,
|
||
RuntimeStoryPatch::NpcAffinityChanged {
|
||
previous_affinity: 46,
|
||
next_affinity: 52,
|
||
..
|
||
}
|
||
)));
|
||
}
|
||
|
||
async fn seed_authenticated_state() -> AppState {
|
||
let state = AppState::new(AppConfig::default()).expect("state should build");
|
||
state
|
||
.password_entry_service()
|
||
.execute(module_auth::PasswordEntryInput {
|
||
username: "runtime_story_state_user".to_string(),
|
||
password: "secret123".to_string(),
|
||
})
|
||
.await
|
||
.expect("seed login should succeed");
|
||
state
|
||
}
|
||
|
||
fn issue_access_token(state: &AppState) -> String {
|
||
let claims = AccessTokenClaims::from_input(
|
||
AccessTokenClaimsInput {
|
||
user_id: "user_00000001".to_string(),
|
||
session_id: "sess_runtime_story_state".to_string(),
|
||
provider: AuthProvider::Password,
|
||
roles: vec!["user".to_string()],
|
||
token_version: 1,
|
||
phone_verified: true,
|
||
binding_status: BindingStatus::Active,
|
||
display_name: Some("运行时剧情状态用户".to_string()),
|
||
},
|
||
state.auth_jwt_config(),
|
||
OffsetDateTime::now_utc(),
|
||
)
|
||
.expect("claims should build");
|
||
|
||
sign_access_token(&claims, state.auth_jwt_config()).expect("token should sign")
|
||
}
|
||
|
||
fn build_runtime_story_boundary_game_state_fixture() -> Value {
|
||
serde_json::from_str(
|
||
r#"{
|
||
"worldType": "WUXIA",
|
||
"runtimeSessionId": "runtime-main",
|
||
"runtimeActionVersion": 0,
|
||
"playerCharacter": {
|
||
"id": "hero-story",
|
||
"title": "试剑客",
|
||
"description": "站在桥口的人。",
|
||
"personality": "谨慎",
|
||
"attributes": {
|
||
"strength": 8,
|
||
"spirit": 6
|
||
},
|
||
"skills": []
|
||
},
|
||
"runtimeStats": {
|
||
"playTimeMs": 0,
|
||
"lastPlayTickAt": null,
|
||
"hostileNpcsDefeated": 0,
|
||
"questsAccepted": 0,
|
||
"itemsUsed": 0,
|
||
"scenesTraveled": 0
|
||
},
|
||
"currentScene": "test-scene",
|
||
"storyHistory": [],
|
||
"characterChats": {},
|
||
"animationState": "idle",
|
||
"currentEncounter": {
|
||
"kind": "npc",
|
||
"id": "npc_merchant_01",
|
||
"npcName": "沈七",
|
||
"npcDescription": "腰间挂着药囊的行商",
|
||
"context": "受伤行商",
|
||
"hostile": false
|
||
},
|
||
"npcInteractionActive": true,
|
||
"currentScenePreset": null,
|
||
"sceneHostileNpcs": [],
|
||
"playerX": 0,
|
||
"playerOffsetY": 0,
|
||
"playerFacing": "right",
|
||
"playerActionMode": "idle",
|
||
"scrollWorld": false,
|
||
"inBattle": false,
|
||
"playerHp": 31,
|
||
"playerMaxHp": 40,
|
||
"playerMana": 9,
|
||
"playerMaxMana": 16,
|
||
"playerSkillCooldowns": {},
|
||
"activeBuildBuffs": [],
|
||
"activeCombatEffects": [],
|
||
"playerCurrency": 90,
|
||
"playerInventory": [],
|
||
"playerEquipment": {
|
||
"weapon": null,
|
||
"armor": null,
|
||
"relic": null
|
||
},
|
||
"npcStates": {
|
||
"npc_merchant_01": {
|
||
"affinity": 46,
|
||
"chattedCount": 0,
|
||
"helpUsed": false,
|
||
"giftsGiven": 0,
|
||
"inventory": [],
|
||
"recruited": false
|
||
}
|
||
},
|
||
"quests": [],
|
||
"roster": [],
|
||
"companions": [],
|
||
"currentNpcBattleMode": null,
|
||
"currentNpcBattleOutcome": null,
|
||
"sparReturnEncounter": null,
|
||
"sparPlayerHpBefore": null,
|
||
"sparPlayerMaxHpBefore": null,
|
||
"sparStoryHistoryBefore": null,
|
||
"playerProgression": {
|
||
"level": 1,
|
||
"currentLevelXp": 0,
|
||
"totalXp": 0,
|
||
"xpToNextLevel": 60,
|
||
"pendingLevelUps": 0,
|
||
"lastGrantedSource": null
|
||
}
|
||
}"#,
|
||
)
|
||
.expect("runtime story boundary game state fixture should parse")
|
||
}
|
||
|
||
fn build_runtime_story_boundary_quest_fixture(quest_id: &str, title: &str) -> Value {
|
||
json!({
|
||
"id": quest_id,
|
||
"issuerNpcId": "npc_merchant_01",
|
||
"issuerNpcName": "沈七",
|
||
"sceneId": "scene-bridge",
|
||
"title": title,
|
||
"description": format!("{title}的详细说明。"),
|
||
"summary": format!("{title}的简要目标。"),
|
||
"objective": {
|
||
"kind": "inspect_treasure",
|
||
"requiredCount": 1
|
||
},
|
||
"progress": 0,
|
||
"status": "active",
|
||
"reward": {
|
||
"affinityBonus": 6,
|
||
"currency": 30,
|
||
"items": []
|
||
},
|
||
"rewardText": "完成后可以领取报酬。",
|
||
"steps": [{
|
||
"id": format!("{quest_id}-step-1"),
|
||
"title": "查清线索",
|
||
"kind": "inspect_treasure",
|
||
"requiredCount": 1,
|
||
"progress": 0,
|
||
"revealText": "先去断桥口附近看看留下了什么痕迹。",
|
||
"completeText": "线索已经查清。"
|
||
}],
|
||
"activeStepId": format!("{quest_id}-step-1")
|
||
})
|
||
}
|
||
|
||
fn build_runtime_story_pending_quest_offer_fixture(quest: Value) -> Value {
|
||
json!({
|
||
"text": "沈七终于把真正的委托说了出来。",
|
||
"options": [],
|
||
"displayMode": "dialogue",
|
||
"dialogue": [{
|
||
"speaker": "npc",
|
||
"speakerName": "沈七",
|
||
"text": "这件事我只想托给你。"
|
||
}],
|
||
"npcChatState": {
|
||
"npcId": "npc_merchant_01",
|
||
"npcName": "沈七",
|
||
"turnCount": 2,
|
||
"customInputPlaceholder": "输入你想对 TA 说的话",
|
||
"pendingQuestOffer": {
|
||
"quest": quest
|
||
}
|
||
}
|
||
})
|
||
}
|
||
}
|