884 lines
30 KiB
Rust
884 lines
30 KiB
Rust
use std::{error::Error, fmt};
|
||
|
||
use serde::{Deserialize, Serialize};
|
||
use shared_kernel::normalize_required_string;
|
||
#[cfg(feature = "spacetime-types")]
|
||
use spacetimedb::SpacetimeType;
|
||
|
||
pub const BIG_FISH_SESSION_ID_PREFIX: &str = "big-fish-session-";
|
||
pub const BIG_FISH_MESSAGE_ID_PREFIX: &str = "big-fish-message-";
|
||
pub const BIG_FISH_OPERATION_ID_PREFIX: &str = "big-fish-operation-";
|
||
pub const BIG_FISH_ASSET_SLOT_ID_PREFIX: &str = "big-fish-asset-";
|
||
pub const BIG_FISH_DEFAULT_LEVEL_COUNT: u32 = 8;
|
||
pub const BIG_FISH_MIN_LEVEL_COUNT: u32 = 6;
|
||
pub const BIG_FISH_MAX_LEVEL_COUNT: u32 = 12;
|
||
pub const BIG_FISH_MERGE_COUNT_PER_UPGRADE: u32 = 3;
|
||
pub const BIG_FISH_OFFSCREEN_CULL_SECONDS: f32 = 3.0;
|
||
pub const BIG_FISH_TARGET_WILD_COUNT: usize = 12;
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum BigFishCreationStage {
|
||
CollectingAnchors,
|
||
DraftReady,
|
||
AssetRefining,
|
||
ReadyToPublish,
|
||
Published,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum BigFishAnchorStatus {
|
||
Confirmed,
|
||
Inferred,
|
||
Missing,
|
||
Locked,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum BigFishAgentMessageRole {
|
||
User,
|
||
Assistant,
|
||
System,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum BigFishAgentMessageKind {
|
||
Chat,
|
||
Summary,
|
||
ActionResult,
|
||
Warning,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum BigFishAssetKind {
|
||
LevelMainImage,
|
||
LevelMotion,
|
||
StageBackground,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub enum BigFishAssetStatus {
|
||
Missing,
|
||
Ready,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishAnchorItem {
|
||
pub key: String,
|
||
pub label: String,
|
||
pub value: String,
|
||
pub status: BigFishAnchorStatus,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishAnchorPack {
|
||
pub gameplay_promise: BigFishAnchorItem,
|
||
pub ecology_visual_theme: BigFishAnchorItem,
|
||
pub growth_ladder: BigFishAnchorItem,
|
||
pub risk_tempo: BigFishAnchorItem,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct BigFishLevelBlueprint {
|
||
pub level: u32,
|
||
pub name: String,
|
||
pub one_line_fantasy: String,
|
||
pub silhouette_direction: String,
|
||
pub size_ratio: f32,
|
||
pub visual_prompt_seed: String,
|
||
pub motion_prompt_seed: String,
|
||
pub merge_source_level: Option<u32>,
|
||
pub prey_window: Vec<u32>,
|
||
pub threat_window: Vec<u32>,
|
||
pub is_final_level: bool,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishBackgroundBlueprint {
|
||
pub theme: String,
|
||
pub color_mood: String,
|
||
pub foreground_hints: String,
|
||
pub midground_composition: String,
|
||
pub background_depth: String,
|
||
pub safe_play_area_hint: String,
|
||
pub spawn_edge_hint: String,
|
||
pub background_prompt_seed: String,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct BigFishRuntimeParams {
|
||
pub level_count: u32,
|
||
pub merge_count_per_upgrade: u32,
|
||
pub spawn_target_count: u32,
|
||
pub leader_move_speed: f32,
|
||
pub follower_catch_up_speed: f32,
|
||
pub offscreen_cull_seconds: f32,
|
||
pub prey_spawn_delta_levels: Vec<u32>,
|
||
pub threat_spawn_delta_levels: Vec<u32>,
|
||
pub win_level: u32,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct BigFishGameDraft {
|
||
pub title: String,
|
||
pub subtitle: String,
|
||
pub core_fun: String,
|
||
pub ecology_theme: String,
|
||
pub levels: Vec<BigFishLevelBlueprint>,
|
||
pub background: BigFishBackgroundBlueprint,
|
||
pub runtime_params: BigFishRuntimeParams,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishAgentMessageSnapshot {
|
||
pub message_id: String,
|
||
pub session_id: String,
|
||
pub role: BigFishAgentMessageRole,
|
||
pub kind: BigFishAgentMessageKind,
|
||
pub text: String,
|
||
pub created_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishAssetSlotSnapshot {
|
||
pub slot_id: String,
|
||
pub session_id: String,
|
||
pub asset_kind: BigFishAssetKind,
|
||
pub level: Option<u32>,
|
||
pub motion_key: Option<String>,
|
||
pub status: BigFishAssetStatus,
|
||
pub asset_url: Option<String>,
|
||
pub prompt_snapshot: String,
|
||
pub updated_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishAssetCoverage {
|
||
pub level_main_image_ready_count: u32,
|
||
pub level_motion_ready_count: u32,
|
||
pub background_ready: bool,
|
||
pub required_level_count: u32,
|
||
pub publish_ready: bool,
|
||
pub blockers: Vec<String>,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct BigFishSessionSnapshot {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub seed_text: String,
|
||
pub current_turn: u32,
|
||
pub progress_percent: u32,
|
||
pub stage: BigFishCreationStage,
|
||
pub anchor_pack: BigFishAnchorPack,
|
||
pub draft: Option<BigFishGameDraft>,
|
||
pub asset_slots: Vec<BigFishAssetSlotSnapshot>,
|
||
pub asset_coverage: BigFishAssetCoverage,
|
||
pub messages: Vec<BigFishAgentMessageSnapshot>,
|
||
pub last_assistant_reply: Option<String>,
|
||
pub publish_ready: bool,
|
||
pub created_at_micros: i64,
|
||
pub updated_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||
pub struct BigFishSessionProcedureResult {
|
||
pub ok: bool,
|
||
pub session: Option<BigFishSessionSnapshot>,
|
||
pub error_message: Option<String>,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishWorkSummarySnapshot {
|
||
pub work_id: String,
|
||
pub source_session_id: String,
|
||
pub owner_user_id: String,
|
||
pub title: String,
|
||
pub subtitle: String,
|
||
pub summary: String,
|
||
pub cover_image_src: Option<String>,
|
||
pub status: String,
|
||
pub updated_at_micros: i64,
|
||
pub publish_ready: bool,
|
||
pub level_count: u32,
|
||
pub level_main_image_ready_count: u32,
|
||
pub level_motion_ready_count: u32,
|
||
pub background_ready: bool,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishWorksListInput {
|
||
pub owner_user_id: String,
|
||
pub published_only: bool,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishWorkDeleteInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishWorksProcedureResult {
|
||
pub ok: bool,
|
||
pub items_json: Option<String>,
|
||
pub error_message: Option<String>,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishSessionCreateInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub seed_text: String,
|
||
pub welcome_message_id: String,
|
||
pub welcome_message_text: String,
|
||
pub created_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishSessionGetInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishMessageSubmitInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub user_message_id: String,
|
||
pub user_message_text: String,
|
||
pub assistant_message_id: String,
|
||
pub submitted_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishMessageFinalizeInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub assistant_message_id: Option<String>,
|
||
pub assistant_reply_text: Option<String>,
|
||
pub stage: BigFishCreationStage,
|
||
pub progress_percent: u32,
|
||
pub anchor_pack_json: String,
|
||
pub error_message: Option<String>,
|
||
pub updated_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishDraftCompileInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub compiled_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishAssetGenerateInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub asset_kind: BigFishAssetKind,
|
||
pub level: Option<u32>,
|
||
pub motion_key: Option<String>,
|
||
pub asset_url: Option<String>,
|
||
pub generated_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishPublishInput {
|
||
pub session_id: String,
|
||
pub owner_user_id: String,
|
||
pub published_at_micros: i64,
|
||
}
|
||
|
||
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||
pub struct BigFishPlayReportInput {
|
||
pub session_id: String,
|
||
pub user_id: String,
|
||
pub elapsed_ms: u64,
|
||
pub reported_at_micros: i64,
|
||
}
|
||
|
||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||
pub enum BigFishFieldError {
|
||
MissingSessionId,
|
||
MissingOwnerUserId,
|
||
MissingMessageId,
|
||
MissingMessageText,
|
||
MissingDraft,
|
||
InvalidLevel,
|
||
InvalidAssetKind,
|
||
}
|
||
|
||
impl BigFishCreationStage {
|
||
pub fn as_str(self) -> &'static str {
|
||
match self {
|
||
Self::CollectingAnchors => "collecting_anchors",
|
||
Self::DraftReady => "draft_ready",
|
||
Self::AssetRefining => "asset_refining",
|
||
Self::ReadyToPublish => "ready_to_publish",
|
||
Self::Published => "published",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl BigFishAnchorStatus {
|
||
pub fn as_str(self) -> &'static str {
|
||
match self {
|
||
Self::Confirmed => "confirmed",
|
||
Self::Inferred => "inferred",
|
||
Self::Missing => "missing",
|
||
Self::Locked => "locked",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl BigFishAgentMessageRole {
|
||
pub fn as_str(self) -> &'static str {
|
||
match self {
|
||
Self::User => "user",
|
||
Self::Assistant => "assistant",
|
||
Self::System => "system",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl BigFishAgentMessageKind {
|
||
pub fn as_str(self) -> &'static str {
|
||
match self {
|
||
Self::Chat => "chat",
|
||
Self::Summary => "summary",
|
||
Self::ActionResult => "action_result",
|
||
Self::Warning => "warning",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl BigFishAssetKind {
|
||
pub fn as_str(self) -> &'static str {
|
||
match self {
|
||
Self::LevelMainImage => "level_main_image",
|
||
Self::LevelMotion => "level_motion",
|
||
Self::StageBackground => "stage_background",
|
||
}
|
||
}
|
||
}
|
||
|
||
impl BigFishAssetStatus {
|
||
pub fn as_str(self) -> &'static str {
|
||
match self {
|
||
Self::Missing => "missing",
|
||
Self::Ready => "ready",
|
||
}
|
||
}
|
||
}
|
||
|
||
pub fn empty_anchor_pack() -> BigFishAnchorPack {
|
||
BigFishAnchorPack {
|
||
gameplay_promise: BigFishAnchorItem {
|
||
key: "gameplayPromise".to_string(),
|
||
label: "玩法承诺".to_string(),
|
||
value: String::new(),
|
||
status: BigFishAnchorStatus::Missing,
|
||
},
|
||
ecology_visual_theme: BigFishAnchorItem {
|
||
key: "ecologyVisualTheme".to_string(),
|
||
label: "生态与视觉母题".to_string(),
|
||
value: String::new(),
|
||
status: BigFishAnchorStatus::Missing,
|
||
},
|
||
growth_ladder: BigFishAnchorItem {
|
||
key: "growthLadder".to_string(),
|
||
label: "成长阶梯".to_string(),
|
||
value: String::new(),
|
||
status: BigFishAnchorStatus::Missing,
|
||
},
|
||
risk_tempo: BigFishAnchorItem {
|
||
key: "riskTempo".to_string(),
|
||
label: "风险节奏".to_string(),
|
||
value: "平衡".to_string(),
|
||
status: BigFishAnchorStatus::Inferred,
|
||
},
|
||
}
|
||
}
|
||
|
||
pub fn infer_anchor_pack(seed_text: &str, latest_message: Option<&str>) -> BigFishAnchorPack {
|
||
let source = normalize_required_string(latest_message.unwrap_or(seed_text))
|
||
.or_else(|| normalize_required_string(seed_text))
|
||
.unwrap_or_else(|| "深海弱小逆袭，逐级吞噬成长".to_string());
|
||
let mut pack = empty_anchor_pack();
|
||
pack.gameplay_promise.value = if source.contains("可爱") {
|
||
"可爱生态成长".to_string()
|
||
} else if source.contains("机械") {
|
||
"机械微生物吞并进化".to_string()
|
||
} else {
|
||
"弱小逆袭和群体吞并".to_string()
|
||
};
|
||
pack.gameplay_promise.status = BigFishAnchorStatus::Inferred;
|
||
pack.ecology_visual_theme.value = if source.contains("机械") {
|
||
"机械微生物水域".to_string()
|
||
} else if source.contains("梦") {
|
||
"梦境纸鱼生态".to_string()
|
||
} else {
|
||
"深海生物生态".to_string()
|
||
};
|
||
pack.ecology_visual_theme.status = BigFishAnchorStatus::Inferred;
|
||
pack.growth_ladder.value = "8 级连续进化，从幼小个体成长为终局巨兽".to_string();
|
||
pack.growth_ladder.status = BigFishAnchorStatus::Inferred;
|
||
pack.risk_tempo.value = if source.contains("爽") {
|
||
"偏爽快".to_string()
|
||
} else if source.contains("压迫") {
|
||
"偏压迫".to_string()
|
||
} else {
|
||
"平衡".to_string()
|
||
};
|
||
pack
|
||
}
|
||
|
||
pub fn compile_default_draft(anchor_pack: &BigFishAnchorPack) -> BigFishGameDraft {
|
||
let level_count = BIG_FISH_DEFAULT_LEVEL_COUNT;
|
||
let theme = fallback_anchor_value(&anchor_pack.ecology_visual_theme, "深海生物生态");
|
||
let core_fun = fallback_anchor_value(&anchor_pack.gameplay_promise, "弱小逆袭和群体吞并");
|
||
let risk_tempo = fallback_anchor_value(&anchor_pack.risk_tempo, "平衡");
|
||
|
||
let levels = (1..=level_count)
|
||
.map(|level| build_level_blueprint(level, level_count, &theme))
|
||
.collect();
|
||
|
||
BigFishGameDraft {
|
||
title: format!("{theme} 大鱼吃小鱼"),
|
||
subtitle: format!("{core_fun} · {risk_tempo}节奏"),
|
||
core_fun,
|
||
ecology_theme: theme.clone(),
|
||
levels,
|
||
background: BigFishBackgroundBlueprint {
|
||
theme: theme.clone(),
|
||
color_mood: "深蓝、青绿、带少量暖色生物光".to_string(),
|
||
foreground_hints: "只保留少量漂浮颗粒和边缘水草，不遮挡中央操作区".to_string(),
|
||
midground_composition: "中央留出大面积清晰活动区域，边缘只做出生缓冲层".to_string(),
|
||
background_depth: "简洁纵深水域与极少量远处剪影".to_string(),
|
||
safe_play_area_hint: "9:16 竖屏中央 80% 为主要活动区".to_string(),
|
||
spawn_edge_hint: "四周边缘以少量暗礁或水草提示野生实体出生区".to_string(),
|
||
background_prompt_seed: format!(
|
||
"{theme}，竖屏 9:16，全屏大场地游戏背景，元素少，中央开阔，无文字，无 UI 框"
|
||
),
|
||
},
|
||
runtime_params: BigFishRuntimeParams {
|
||
level_count,
|
||
merge_count_per_upgrade: BIG_FISH_MERGE_COUNT_PER_UPGRADE,
|
||
spawn_target_count: BIG_FISH_TARGET_WILD_COUNT as u32,
|
||
leader_move_speed: 160.0,
|
||
follower_catch_up_speed: 120.0,
|
||
offscreen_cull_seconds: BIG_FISH_OFFSCREEN_CULL_SECONDS,
|
||
prey_spawn_delta_levels: vec![1, 2],
|
||
threat_spawn_delta_levels: vec![1, 2],
|
||
win_level: level_count,
|
||
},
|
||
}
|
||
}
|
||
|
||
pub fn build_asset_coverage(
|
||
draft: Option<&BigFishGameDraft>,
|
||
asset_slots: &[BigFishAssetSlotSnapshot],
|
||
) -> BigFishAssetCoverage {
|
||
let required_level_count = draft
|
||
.map(|value| value.runtime_params.level_count)
|
||
.unwrap_or(BIG_FISH_DEFAULT_LEVEL_COUNT);
|
||
let main_ready = asset_slots
|
||
.iter()
|
||
.filter(|slot| {
|
||
slot.asset_kind == BigFishAssetKind::LevelMainImage
|
||
&& slot.status == BigFishAssetStatus::Ready
|
||
})
|
||
.count() as u32;
|
||
let motion_ready = asset_slots
|
||
.iter()
|
||
.filter(|slot| {
|
||
slot.asset_kind == BigFishAssetKind::LevelMotion
|
||
&& slot.status == BigFishAssetStatus::Ready
|
||
})
|
||
.count() as u32;
|
||
let background_ready = asset_slots.iter().any(|slot| {
|
||
slot.asset_kind == BigFishAssetKind::StageBackground
|
||
&& slot.status == BigFishAssetStatus::Ready
|
||
});
|
||
|
||
let required_motion_count = required_level_count * 2;
|
||
let mut blockers = Vec::new();
|
||
if draft.is_none() {
|
||
blockers.push("玩法草稿尚未编译".to_string());
|
||
}
|
||
if main_ready < required_level_count {
|
||
blockers.push(format!(
|
||
"还缺少 {} 个等级主图",
|
||
required_level_count.saturating_sub(main_ready)
|
||
));
|
||
}
|
||
if motion_ready < required_motion_count {
|
||
blockers.push(format!(
|
||
"还缺少 {} 个基础动作",
|
||
required_motion_count.saturating_sub(motion_ready)
|
||
));
|
||
}
|
||
if !background_ready {
|
||
blockers.push("还缺少活动区域背景图".to_string());
|
||
}
|
||
|
||
BigFishAssetCoverage {
|
||
level_main_image_ready_count: main_ready,
|
||
level_motion_ready_count: motion_ready,
|
||
background_ready,
|
||
required_level_count,
|
||
publish_ready: blockers.is_empty(),
|
||
blockers,
|
||
}
|
||
}
|
||
|
||
pub fn build_generated_asset_slot(
|
||
session_id: &str,
|
||
draft: &BigFishGameDraft,
|
||
asset_kind: BigFishAssetKind,
|
||
level: Option<u32>,
|
||
motion_key: Option<String>,
|
||
asset_url: Option<String>,
|
||
updated_at_micros: i64,
|
||
) -> Result<BigFishAssetSlotSnapshot, BigFishFieldError> {
|
||
let session_id =
|
||
normalize_required_string(session_id).ok_or(BigFishFieldError::MissingSessionId)?;
|
||
let prompt_snapshot =
|
||
build_asset_prompt_snapshot(draft, asset_kind, level, motion_key.as_deref())?;
|
||
let slot_id = build_asset_slot_id(&session_id, asset_kind, level, motion_key.as_deref());
|
||
let resolved_asset_url = normalize_required_string(asset_url.as_deref().unwrap_or_default())
|
||
.unwrap_or_else(|| build_placeholder_asset_url(asset_kind, level, updated_at_micros));
|
||
|
||
Ok(BigFishAssetSlotSnapshot {
|
||
slot_id,
|
||
session_id,
|
||
asset_kind,
|
||
level,
|
||
motion_key,
|
||
status: BigFishAssetStatus::Ready,
|
||
asset_url: Some(resolved_asset_url),
|
||
prompt_snapshot,
|
||
updated_at_micros,
|
||
})
|
||
}
|
||
|
||
pub fn validate_session_get_input(input: &BigFishSessionGetInput) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)
|
||
}
|
||
|
||
pub fn validate_works_list_input(input: &BigFishWorksListInput) -> Result<(), BigFishFieldError> {
|
||
if input.published_only {
|
||
return Ok(());
|
||
}
|
||
if normalize_required_string(&input.owner_user_id).is_none() {
|
||
return Err(BigFishFieldError::MissingOwnerUserId);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub fn validate_session_create_input(
|
||
input: &BigFishSessionCreateInput,
|
||
) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)?;
|
||
if normalize_required_string(&input.welcome_message_id).is_none() {
|
||
return Err(BigFishFieldError::MissingMessageId);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub fn validate_message_submit_input(
|
||
input: &BigFishMessageSubmitInput,
|
||
) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)?;
|
||
if normalize_required_string(&input.user_message_id).is_none()
|
||
|| normalize_required_string(&input.assistant_message_id).is_none()
|
||
{
|
||
return Err(BigFishFieldError::MissingMessageId);
|
||
}
|
||
if normalize_required_string(&input.user_message_text).is_none() {
|
||
return Err(BigFishFieldError::MissingMessageText);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub fn validate_message_finalize_input(
|
||
input: &BigFishMessageFinalizeInput,
|
||
) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)
|
||
}
|
||
|
||
pub fn validate_draft_compile_input(
|
||
input: &BigFishDraftCompileInput,
|
||
) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)
|
||
}
|
||
|
||
pub fn validate_asset_generate_input(
|
||
input: &BigFishAssetGenerateInput,
|
||
draft: &BigFishGameDraft,
|
||
) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)?;
|
||
match input.asset_kind {
|
||
BigFishAssetKind::LevelMainImage => validate_level(input.level, draft),
|
||
BigFishAssetKind::LevelMotion => {
|
||
validate_level(input.level, draft)?;
|
||
match input.motion_key.as_deref() {
|
||
Some("idle_float" | "move_swim") => Ok(()),
|
||
_ => Err(BigFishFieldError::InvalidAssetKind),
|
||
}
|
||
}
|
||
BigFishAssetKind::StageBackground => Ok(()),
|
||
}
|
||
}
|
||
|
||
pub fn validate_publish_input(input: &BigFishPublishInput) -> Result<(), BigFishFieldError> {
|
||
validate_session_owner(&input.session_id, &input.owner_user_id)
|
||
}
|
||
|
||
pub fn validate_play_report_input(input: &BigFishPlayReportInput) -> Result<(), BigFishFieldError> {
|
||
if normalize_required_string(&input.session_id).is_none() {
|
||
return Err(BigFishFieldError::MissingSessionId);
|
||
}
|
||
if normalize_required_string(&input.user_id).is_none() {
|
||
return Err(BigFishFieldError::MissingOwnerUserId);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
pub fn serialize_anchor_pack(anchor_pack: &BigFishAnchorPack) -> Result<String, serde_json::Error> {
|
||
serde_json::to_string(anchor_pack)
|
||
}
|
||
|
||
pub fn deserialize_anchor_pack(value: &str) -> Result<BigFishAnchorPack, serde_json::Error> {
|
||
serde_json::from_str(value)
|
||
}
|
||
|
||
pub fn serialize_draft(draft: &BigFishGameDraft) -> Result<String, serde_json::Error> {
|
||
serde_json::to_string(draft)
|
||
}
|
||
|
||
pub fn deserialize_draft(value: &str) -> Result<BigFishGameDraft, serde_json::Error> {
|
||
serde_json::from_str(value)
|
||
}
|
||
|
||
pub fn serialize_asset_coverage(
|
||
coverage: &BigFishAssetCoverage,
|
||
) -> Result<String, serde_json::Error> {
|
||
serde_json::to_string(coverage)
|
||
}
|
||
|
||
pub fn deserialize_asset_coverage(value: &str) -> Result<BigFishAssetCoverage, serde_json::Error> {
|
||
serde_json::from_str(value)
|
||
}
|
||
|
||
fn fallback_anchor_value(anchor: &BigFishAnchorItem, fallback: &str) -> String {
|
||
normalize_required_string(&anchor.value).unwrap_or_else(|| fallback.to_string())
|
||
}
|
||
|
||
fn build_level_blueprint(level: u32, level_count: u32, theme: &str) -> BigFishLevelBlueprint {
|
||
let prey_window = (1..level)
|
||
.rev()
|
||
.take(2)
|
||
.collect::<Vec<_>>()
|
||
.into_iter()
|
||
.rev()
|
||
.collect();
|
||
let threat_window = ((level + 1)..=(level + 2).min(level_count)).collect::<Vec<_>>();
|
||
BigFishLevelBlueprint {
|
||
level,
|
||
name: format!("{theme} L{level}"),
|
||
one_line_fantasy: if level == level_count {
|
||
"终局巨兽形态，获得即可通关".to_string()
|
||
} else {
|
||
format!("第 {level} 阶实体，继续吞噬同级和低级个体成长")
|
||
},
|
||
silhouette_direction: format!(
|
||
"体型约为初始的 {:.1} 倍，轮廓更清晰",
|
||
1.0 + level as f32 * 0.22
|
||
),
|
||
size_ratio: 1.0 + (level.saturating_sub(1) as f32 * 0.22),
|
||
visual_prompt_seed: format!(
|
||
"{theme} 第 {level} 级鱼形实体主图，RPG 角色资产口径，透明背景，单体完整入镜，清晰轮廓"
|
||
),
|
||
motion_prompt_seed: format!(
|
||
"{theme} 第 {level} 级鱼形实体 idle_float 与 move_swim 动作，RPG 角色动画资产口径，透明背景"
|
||
),
|
||
merge_source_level: if level == 1 { None } else { Some(level - 1) },
|
||
prey_window,
|
||
threat_window,
|
||
is_final_level: level == level_count,
|
||
}
|
||
}
|
||
|
||
fn build_asset_prompt_snapshot(
|
||
draft: &BigFishGameDraft,
|
||
asset_kind: BigFishAssetKind,
|
||
level: Option<u32>,
|
||
motion_key: Option<&str>,
|
||
) -> Result<String, BigFishFieldError> {
|
||
match asset_kind {
|
||
BigFishAssetKind::LevelMainImage => {
|
||
let level = level.ok_or(BigFishFieldError::InvalidLevel)?;
|
||
let blueprint = draft
|
||
.levels
|
||
.iter()
|
||
.find(|item| item.level == level)
|
||
.ok_or(BigFishFieldError::InvalidLevel)?;
|
||
Ok(blueprint.visual_prompt_seed.clone())
|
||
}
|
||
BigFishAssetKind::LevelMotion => {
|
||
let level = level.ok_or(BigFishFieldError::InvalidLevel)?;
|
||
let blueprint = draft
|
||
.levels
|
||
.iter()
|
||
.find(|item| item.level == level)
|
||
.ok_or(BigFishFieldError::InvalidLevel)?;
|
||
let motion_key = motion_key.ok_or(BigFishFieldError::InvalidAssetKind)?;
|
||
Ok(format!(
|
||
"{}，动作位：{}，透明背景，单体完整入镜",
|
||
blueprint.motion_prompt_seed, motion_key
|
||
))
|
||
}
|
||
BigFishAssetKind::StageBackground => Ok(draft.background.background_prompt_seed.clone()),
|
||
}
|
||
}
|
||
|
||
fn build_asset_slot_id(
|
||
session_id: &str,
|
||
asset_kind: BigFishAssetKind,
|
||
level: Option<u32>,
|
||
motion_key: Option<&str>,
|
||
) -> String {
|
||
let level_part = level
|
||
.map(|value| value.to_string())
|
||
.unwrap_or_else(|| "stage".to_string());
|
||
let motion_part = motion_key.unwrap_or("main");
|
||
format!(
|
||
"{BIG_FISH_ASSET_SLOT_ID_PREFIX}{session_id}_{}_{}_{}",
|
||
asset_kind.as_str(),
|
||
level_part,
|
||
motion_part
|
||
)
|
||
}
|
||
|
||
fn build_placeholder_asset_url(
|
||
asset_kind: BigFishAssetKind,
|
||
level: Option<u32>,
|
||
seed_micros: i64,
|
||
) -> String {
|
||
let level_part = level
|
||
.map(|value| format!("level-{value}"))
|
||
.unwrap_or_else(|| "stage".to_string());
|
||
format!(
|
||
"/generated-big-fish/{}/{}/{}.png",
|
||
asset_kind.as_str(),
|
||
level_part,
|
||
seed_micros
|
||
)
|
||
}
|
||
|
||
fn validate_session_owner(session_id: &str, owner_user_id: &str) -> Result<(), BigFishFieldError> {
|
||
if normalize_required_string(session_id).is_none() {
|
||
return Err(BigFishFieldError::MissingSessionId);
|
||
}
|
||
if normalize_required_string(owner_user_id).is_none() {
|
||
return Err(BigFishFieldError::MissingOwnerUserId);
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
fn validate_level(level: Option<u32>, draft: &BigFishGameDraft) -> Result<(), BigFishFieldError> {
|
||
match level {
|
||
Some(value) if (1..=draft.runtime_params.level_count).contains(&value) => Ok(()),
|
||
_ => Err(BigFishFieldError::InvalidLevel),
|
||
}
|
||
}
|
||
|
||
impl fmt::Display for BigFishFieldError {
|
||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||
match self {
|
||
Self::MissingSessionId => f.write_str("big_fish.session_id 不能为空"),
|
||
Self::MissingOwnerUserId => f.write_str("big_fish.owner_user_id 不能为空"),
|
||
Self::MissingMessageId => f.write_str("big_fish.message_id 不能为空"),
|
||
Self::MissingMessageText => f.write_str("big_fish.message_text 不能为空"),
|
||
Self::MissingDraft => f.write_str("big_fish.draft 尚未编译"),
|
||
Self::InvalidLevel => f.write_str("big_fish.level 不在合法等级范围内"),
|
||
Self::InvalidAssetKind => f.write_str("big_fish.asset_kind 或动作位非法"),
|
||
}
|
||
}
|
||
}
|
||
|
||
impl Error for BigFishFieldError {}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn default_draft_compiles_eight_levels_with_fixed_runtime_params() {
|
||
let draft = compile_default_draft(&infer_anchor_pack("机械深海，节奏偏爽", None));
|
||
|
||
assert_eq!(draft.levels.len(), BIG_FISH_DEFAULT_LEVEL_COUNT as usize);
|
||
assert_eq!(draft.runtime_params.merge_count_per_upgrade, 3);
|
||
assert_eq!(draft.runtime_params.offscreen_cull_seconds, 3.0);
|
||
assert_eq!(draft.runtime_params.prey_spawn_delta_levels, vec![1, 2]);
|
||
assert_eq!(draft.runtime_params.threat_spawn_delta_levels, vec![1, 2]);
|
||
assert!(
|
||
draft
|
||
.levels
|
||
.last()
|
||
.is_some_and(|level| level.is_final_level)
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn asset_coverage_requires_main_images_two_motions_and_background() {
|
||
let draft = compile_default_draft(&infer_anchor_pack("深海", None));
|
||
let coverage = build_asset_coverage(Some(&draft), &[]);
|
||
|
||
assert!(!coverage.publish_ready);
|
||
assert_eq!(coverage.required_level_count, 8);
|
||
assert!(
|
||
coverage
|
||
.blockers
|
||
.iter()
|
||
.any(|item| item.contains("等级主图"))
|
||
);
|
||
assert!(
|
||
coverage
|
||
.blockers
|
||
.iter()
|
||
.any(|item| item.contains("基础动作"))
|
||
);
|
||
assert!(coverage.blockers.iter().any(|item| item.contains("背景图")));
|
||
}
|
||
}
|