882 lines
31 KiB
Rust
882 lines
31 KiB
Rust
use serde_json::{Map, Value, json};
|
||
|
||
use shared_contracts::runtime_story::{
|
||
RuntimeBattlePresentation, RuntimeStoryActionRequest, RuntimeStoryOptionView, RuntimeStoryPatch,
|
||
};
|
||
|
||
use crate::{
|
||
StoryResolution, append_active_build_buffs, build_status_patch, clear_encounter_only,
|
||
clear_encounter_state, current_encounter_id, current_encounter_name_from_battle,
|
||
ensure_json_object, first_hostile_npc_string_field, grant_player_progression_experience,
|
||
increment_runtime_stat, read_array_field, read_field, read_i32_field, read_object_field,
|
||
read_optional_string_field, remove_player_inventory_item, resolve_action_text,
|
||
write_bool_field, write_current_encounter_i32_field, write_first_hostile_npc_i32_field,
|
||
write_i32_field, write_null_field, write_string_field,
|
||
};
|
||
|
||
/// 战斗纯结算链已经不依赖 HTTP / AppState。
|
||
///
|
||
/// 这里同时承接 battle action 的状态结算、资源恢复和战斗选项编译，
|
||
/// 让 `api-server` 只保留 HTTP 外壳与最终响应拼装。
|
||
struct BattleActionPlan {
|
||
action_text: String,
|
||
result_text: String,
|
||
damage_dealt: i32,
|
||
damage_taken: i32,
|
||
heal: i32,
|
||
mana_restore: i32,
|
||
mana_cost: i32,
|
||
cooldown_tick_turns: i32,
|
||
cooldown_bonus_turns: i32,
|
||
applied_skill_cooldown: Option<(String, i32)>,
|
||
build_buffs: Vec<Value>,
|
||
consumed_item_id: Option<String>,
|
||
}
|
||
|
||
struct BattleSkillView {
|
||
id: String,
|
||
name: String,
|
||
damage: i32,
|
||
mana_cost: i32,
|
||
cooldown_turns: i32,
|
||
build_buffs: Vec<Value>,
|
||
}
|
||
|
||
pub struct BattleInventoryUseProfile {
|
||
hp_restore: i32,
|
||
mana_restore: i32,
|
||
cooldown_reduction: i32,
|
||
build_buffs: Vec<Value>,
|
||
}
|
||
|
||
struct BattleInventoryItemView {
|
||
id: String,
|
||
name: String,
|
||
quantity: i32,
|
||
use_profile: Option<BattleInventoryUseProfile>,
|
||
}
|
||
|
||
/// 战斗结算的胜负状态。
|
||
///
|
||
/// 这里显式补齐失败分支，避免“玩家已死但敌方也被打空时”被错误归类成胜利。
|
||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||
enum BattleResolutionOutcome {
|
||
Ongoing,
|
||
Victory,
|
||
SparComplete,
|
||
Defeat,
|
||
}
|
||
|
||
impl BattleResolutionOutcome {
|
||
fn as_battle_outcome(self) -> &'static str {
|
||
match self {
|
||
Self::Ongoing => "ongoing",
|
||
Self::Victory => "victory",
|
||
Self::SparComplete => "spar_complete",
|
||
Self::Defeat => "defeat",
|
||
}
|
||
}
|
||
|
||
fn as_status_outcome(self) -> Option<&'static str> {
|
||
match self {
|
||
Self::Ongoing => None,
|
||
Self::Victory => Some("fight_victory"),
|
||
Self::SparComplete => Some("spar_complete"),
|
||
Self::Defeat => Some("fight_defeat"),
|
||
}
|
||
}
|
||
}
|
||
|
||
pub 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 plan = build_battle_action_plan(game_state, request, function_id)?;
|
||
spend_player_mana(game_state, plan.mana_cost);
|
||
restore_player_resource(game_state, plan.heal, plan.mana_restore);
|
||
tick_player_skill_cooldowns(game_state, plan.cooldown_tick_turns);
|
||
reduce_player_skill_cooldowns(game_state, plan.cooldown_bonus_turns);
|
||
if let Some((skill_id, turns)) = plan.applied_skill_cooldown.as_ref() {
|
||
set_player_skill_cooldown(game_state, skill_id.as_str(), *turns);
|
||
}
|
||
if !plan.build_buffs.is_empty() {
|
||
append_active_build_buffs(game_state, plan.build_buffs.clone());
|
||
}
|
||
if let Some(item_id) = plan.consumed_item_id.as_ref() {
|
||
remove_player_inventory_item(game_state, item_id.as_str(), 1);
|
||
increment_runtime_stat(game_state, "itemsUsed", 1);
|
||
}
|
||
|
||
let player_hp = apply_player_damage(game_state, plan.damage_taken);
|
||
let target_hp = apply_target_damage(game_state, plan.damage_dealt);
|
||
let outcome = resolve_battle_resolution_outcome(player_hp, target_hp, battle_mode.as_str());
|
||
|
||
let victory_experience = if outcome == BattleResolutionOutcome::Victory {
|
||
battle_victory_experience_reward(game_state)
|
||
} else {
|
||
0
|
||
};
|
||
|
||
if outcome != BattleResolutionOutcome::Ongoing {
|
||
write_bool_field(game_state, "inBattle", false);
|
||
write_bool_field(game_state, "npcInteractionActive", false);
|
||
write_null_field(game_state, "currentNpcBattleMode");
|
||
if let Some(status_outcome) = outcome.as_status_outcome() {
|
||
write_string_field(game_state, "currentNpcBattleOutcome", status_outcome);
|
||
}
|
||
if outcome == BattleResolutionOutcome::Victory {
|
||
clear_encounter_only(game_state);
|
||
increment_runtime_stat(game_state, "hostileNpcsDefeated", 1);
|
||
if victory_experience > 0 {
|
||
grant_player_progression_experience(game_state, victory_experience, "hostile_npc");
|
||
}
|
||
} else if outcome == BattleResolutionOutcome::Defeat {
|
||
clear_encounter_state(game_state);
|
||
}
|
||
}
|
||
|
||
let mut patches = vec![
|
||
RuntimeStoryPatch::BattleResolved {
|
||
function_id: function_id.to_string(),
|
||
target_id: Some(target_id.clone()),
|
||
damage_dealt: Some(plan.damage_dealt),
|
||
damage_taken: Some(plan.damage_taken),
|
||
outcome: outcome.as_battle_outcome().to_string(),
|
||
},
|
||
build_status_patch(game_state),
|
||
];
|
||
if outcome == BattleResolutionOutcome::Victory {
|
||
patches.push(RuntimeStoryPatch::EncounterChanged { encounter_id: None });
|
||
}
|
||
|
||
Ok(StoryResolution {
|
||
action_text: resolve_action_text(plan.action_text.as_str(), request),
|
||
result_text: if outcome == BattleResolutionOutcome::Ongoing {
|
||
plan.result_text
|
||
} else if outcome == BattleResolutionOutcome::SparComplete {
|
||
format!("{target_name} 收住了最后一击，这场切磋已经分出结果。")
|
||
} else if outcome == BattleResolutionOutcome::Defeat {
|
||
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(plan.damage_dealt),
|
||
damage_taken: Some(plan.damage_taken),
|
||
outcome: Some(outcome.as_battle_outcome().to_string()),
|
||
}),
|
||
toast: battle_action_toast(function_id, request),
|
||
})
|
||
}
|
||
|
||
pub 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),
|
||
);
|
||
}
|
||
|
||
pub fn build_battle_runtime_story_options(game_state: &Value) -> Vec<RuntimeStoryOptionView> {
|
||
let mut options = vec![
|
||
RuntimeStoryOptionView {
|
||
detail_text: Some(build_basic_attack_detail_text(game_state)),
|
||
..build_static_runtime_story_option("battle_attack_basic", "普通攻击", "combat")
|
||
},
|
||
RuntimeStoryOptionView {
|
||
detail_text: Some("回血 12 / 回蓝 9 / 冷却 -1".to_string()),
|
||
..build_static_runtime_story_option("battle_recover_breath", "恢复", "combat")
|
||
},
|
||
];
|
||
|
||
let preferred_item = pick_preferred_battle_inventory_item(game_state);
|
||
if let Some(item) = preferred_item {
|
||
let effect = item
|
||
.use_profile
|
||
.expect("preferred battle item must have use profile");
|
||
options.push(build_runtime_story_option_with_payload(
|
||
"inventory_use",
|
||
&format!("使用物品：{}", item.name),
|
||
"combat",
|
||
Some(build_battle_item_summary(&effect)),
|
||
json!({
|
||
"itemId": item.id
|
||
}),
|
||
));
|
||
} else {
|
||
options.push(build_disabled_runtime_story_option(
|
||
"inventory_use",
|
||
"使用物品",
|
||
"combat",
|
||
Some("当前没有可直接结算的战斗消耗品".to_string()),
|
||
"暂无可用物品",
|
||
None,
|
||
));
|
||
}
|
||
|
||
options.extend(build_battle_skill_runtime_story_options(game_state));
|
||
options.push(build_static_runtime_story_option(
|
||
"battle_escape_breakout",
|
||
"强行脱离战斗",
|
||
"combat",
|
||
));
|
||
options
|
||
}
|
||
|
||
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) -> i32 {
|
||
let hp = read_i32_field(game_state, "playerHp").unwrap_or(1).max(0);
|
||
let next_hp = if damage <= 0 {
|
||
hp
|
||
} else {
|
||
(hp - damage).max(0)
|
||
};
|
||
write_i32_field(game_state, "playerHp", next_hp);
|
||
next_hp
|
||
}
|
||
|
||
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 resolve_battle_resolution_outcome(
|
||
player_hp: i32,
|
||
target_hp: i32,
|
||
battle_mode: &str,
|
||
) -> BattleResolutionOutcome {
|
||
// 中文注释：玩家死亡优先级高于敌方倒地。
|
||
// 这样即便同一回合双方都被打到 0，也必须按玩家败北处理，不能误发胜利。
|
||
if player_hp <= 0 {
|
||
return BattleResolutionOutcome::Defeat;
|
||
}
|
||
if target_hp <= 0 {
|
||
if battle_mode == "spar" {
|
||
BattleResolutionOutcome::SparComplete
|
||
} else {
|
||
BattleResolutionOutcome::Victory
|
||
}
|
||
} else {
|
||
BattleResolutionOutcome::Ongoing
|
||
}
|
||
}
|
||
|
||
fn read_player_skills(game_state: &Value) -> Vec<BattleSkillView> {
|
||
read_field(game_state, "playerCharacter")
|
||
.map(|character| read_array_field(character, "skills"))
|
||
.unwrap_or_default()
|
||
.into_iter()
|
||
.filter_map(|entry| {
|
||
let id = read_optional_string_field(entry, "id")?;
|
||
let name = read_optional_string_field(entry, "name").unwrap_or_else(|| id.clone());
|
||
Some(BattleSkillView {
|
||
id,
|
||
name,
|
||
damage: read_i32_field(entry, "damage").unwrap_or(14).max(0),
|
||
mana_cost: read_i32_field(entry, "manaCost").unwrap_or(0).max(0),
|
||
cooldown_turns: read_i32_field(entry, "cooldownTurns").unwrap_or(0).max(0),
|
||
build_buffs: read_array_field(entry, "buildBuffs")
|
||
.into_iter()
|
||
.cloned()
|
||
.collect(),
|
||
})
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn find_player_skill_by_id(game_state: &Value, skill_id: &str) -> Option<BattleSkillView> {
|
||
read_player_skills(game_state)
|
||
.into_iter()
|
||
.find(|skill| skill.id == skill_id)
|
||
}
|
||
|
||
fn build_basic_attack_detail_text(game_state: &Value) -> String {
|
||
let strength = read_field(game_state, "playerCharacter")
|
||
.and_then(|character| read_field(character, "attributes"))
|
||
.and_then(|attributes| read_i32_field(attributes, "strength"))
|
||
.unwrap_or(8);
|
||
let agility = read_field(game_state, "playerCharacter")
|
||
.and_then(|character| read_field(character, "attributes"))
|
||
.and_then(|attributes| read_i32_field(attributes, "agility"))
|
||
.unwrap_or(0);
|
||
let preview_damage = ((strength * 85 + agility * 45) / 100).max(8);
|
||
format!("不耗蓝 / 伤害 {preview_damage}")
|
||
}
|
||
|
||
fn read_player_skill_cooldowns(game_state: &Value) -> std::collections::BTreeMap<String, i32> {
|
||
read_object_field(game_state, "playerSkillCooldowns")
|
||
.and_then(Value::as_object)
|
||
.map(|cooldowns| {
|
||
cooldowns
|
||
.iter()
|
||
.map(|(skill_id, turns)| {
|
||
(
|
||
skill_id.clone(),
|
||
turns
|
||
.as_i64()
|
||
.and_then(|value| i32::try_from(value).ok())
|
||
.unwrap_or(0)
|
||
.max(0),
|
||
)
|
||
})
|
||
.collect()
|
||
})
|
||
.unwrap_or_default()
|
||
}
|
||
|
||
fn build_battle_skill_runtime_story_options(game_state: &Value) -> Vec<RuntimeStoryOptionView> {
|
||
let cooldowns = read_player_skill_cooldowns(game_state);
|
||
let player_mana = read_i32_field(game_state, "playerMana").unwrap_or(0);
|
||
read_player_skills(game_state)
|
||
.into_iter()
|
||
.map(|skill| {
|
||
let detail_text = Some(format!(
|
||
"耗蓝 {} / 伤害 {} / 冷却 {}",
|
||
skill.mana_cost.max(0),
|
||
skill.damage.max(0),
|
||
skill.cooldown_turns.max(0)
|
||
));
|
||
let payload = Some(json!({
|
||
"skillId": skill.id
|
||
}));
|
||
let remaining_cooldown = cooldowns.get(skill.id.as_str()).copied().unwrap_or(0);
|
||
if remaining_cooldown > 0 {
|
||
return build_disabled_runtime_story_option(
|
||
"battle_use_skill",
|
||
&skill.name,
|
||
"combat",
|
||
detail_text,
|
||
format!("冷却中，还需 {} 回合", remaining_cooldown).as_str(),
|
||
payload,
|
||
);
|
||
}
|
||
if skill.mana_cost > player_mana {
|
||
return build_disabled_runtime_story_option(
|
||
"battle_use_skill",
|
||
&skill.name,
|
||
"combat",
|
||
detail_text,
|
||
"灵力不足",
|
||
payload,
|
||
);
|
||
}
|
||
RuntimeStoryOptionView {
|
||
detail_text,
|
||
payload,
|
||
..build_static_runtime_story_option("battle_use_skill", &skill.name, "combat")
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn tick_player_skill_cooldowns(game_state: &mut Value, turns: i32) {
|
||
if turns <= 0 {
|
||
return;
|
||
}
|
||
let root = ensure_json_object(game_state);
|
||
let cooldowns = root
|
||
.entry("playerSkillCooldowns".to_string())
|
||
.or_insert_with(|| Value::Object(Map::new()));
|
||
if !cooldowns.is_object() {
|
||
*cooldowns = Value::Object(Map::new());
|
||
}
|
||
let cooldowns = cooldowns
|
||
.as_object_mut()
|
||
.expect("playerSkillCooldowns should be object");
|
||
for value in cooldowns.values_mut() {
|
||
let current = value
|
||
.as_i64()
|
||
.and_then(|number| i32::try_from(number).ok())
|
||
.unwrap_or(0);
|
||
*value = json!((current - turns).max(0));
|
||
}
|
||
}
|
||
|
||
fn reduce_player_skill_cooldowns(game_state: &mut Value, turns: i32) {
|
||
if turns <= 0 {
|
||
return;
|
||
}
|
||
tick_player_skill_cooldowns(game_state, turns);
|
||
}
|
||
|
||
fn set_player_skill_cooldown(game_state: &mut Value, skill_id: &str, turns: i32) {
|
||
let root = ensure_json_object(game_state);
|
||
let cooldowns = root
|
||
.entry("playerSkillCooldowns".to_string())
|
||
.or_insert_with(|| Value::Object(Map::new()));
|
||
if !cooldowns.is_object() {
|
||
*cooldowns = Value::Object(Map::new());
|
||
}
|
||
cooldowns
|
||
.as_object_mut()
|
||
.expect("playerSkillCooldowns should be object")
|
||
.insert(skill_id.to_string(), json!(turns.max(0)));
|
||
}
|
||
|
||
fn read_player_inventory_items(game_state: &Value) -> Vec<BattleInventoryItemView> {
|
||
read_array_field(game_state, "playerInventory")
|
||
.into_iter()
|
||
.filter_map(|entry| {
|
||
let id = read_optional_string_field(entry, "id")?;
|
||
let name = read_optional_string_field(entry, "name").unwrap_or_else(|| id.clone());
|
||
let use_profile =
|
||
read_field(entry, "useProfile").map(|profile| BattleInventoryUseProfile {
|
||
hp_restore: read_i32_field(profile, "hpRestore").unwrap_or(0).max(0),
|
||
mana_restore: read_i32_field(profile, "manaRestore").unwrap_or(0).max(0),
|
||
cooldown_reduction: read_i32_field(profile, "cooldownReduction")
|
||
.unwrap_or(0)
|
||
.max(0),
|
||
build_buffs: read_array_field(profile, "buildBuffs")
|
||
.into_iter()
|
||
.cloned()
|
||
.collect(),
|
||
});
|
||
Some(BattleInventoryItemView {
|
||
id,
|
||
name,
|
||
quantity: read_i32_field(entry, "quantity").unwrap_or(0).max(0),
|
||
use_profile,
|
||
})
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
pub fn read_inventory_item_use_profile(item: &Value) -> Option<BattleInventoryUseProfile> {
|
||
read_field(item, "useProfile").map(|profile| BattleInventoryUseProfile {
|
||
hp_restore: read_i32_field(profile, "hpRestore").unwrap_or(0).max(0),
|
||
mana_restore: read_i32_field(profile, "manaRestore").unwrap_or(0).max(0),
|
||
cooldown_reduction: read_i32_field(profile, "cooldownReduction")
|
||
.unwrap_or(0)
|
||
.max(0),
|
||
build_buffs: read_array_field(profile, "buildBuffs")
|
||
.into_iter()
|
||
.cloned()
|
||
.collect(),
|
||
})
|
||
}
|
||
|
||
pub fn inventory_item_has_usable_effect(item: &Value) -> bool {
|
||
read_inventory_item_use_profile(item).is_some_and(|effect| {
|
||
effect.hp_restore > 0
|
||
|| effect.mana_restore > 0
|
||
|| effect.cooldown_reduction > 0
|
||
|| !effect.build_buffs.is_empty()
|
||
})
|
||
}
|
||
|
||
fn find_player_inventory_item(
|
||
game_state: &Value,
|
||
item_id: &str,
|
||
) -> Option<BattleInventoryItemView> {
|
||
read_player_inventory_items(game_state)
|
||
.into_iter()
|
||
.find(|item| item.id == item_id)
|
||
}
|
||
|
||
/// 旧前端一次只展示一个“推荐”战斗物品，这里继续用确定性打分，避免展示面漂移。
|
||
fn pick_preferred_battle_inventory_item(game_state: &Value) -> Option<BattleInventoryItemView> {
|
||
let has_cooling_skill = read_player_skill_cooldowns(game_state)
|
||
.values()
|
||
.any(|remaining| *remaining > 0);
|
||
let player_hp = read_i32_field(game_state, "playerHp").unwrap_or(0);
|
||
let player_max_hp = read_i32_field(game_state, "playerMaxHp")
|
||
.unwrap_or(1)
|
||
.max(1);
|
||
let player_mana = read_i32_field(game_state, "playerMana").unwrap_or(0);
|
||
let player_max_mana = read_i32_field(game_state, "playerMaxMana")
|
||
.unwrap_or(1)
|
||
.max(1);
|
||
let hp_low = player_hp * 100 <= player_max_hp * 45;
|
||
let mana_low = player_mana * 100 <= player_max_mana * 45;
|
||
|
||
read_player_inventory_items(game_state)
|
||
.into_iter()
|
||
.filter(|item| item.quantity > 0 && item.use_profile.is_some())
|
||
.filter_map(|item| {
|
||
let effect = item.use_profile.as_ref()?;
|
||
let mut score = effect.build_buffs.len() as i32 * 8;
|
||
score += effect.hp_restore * if hp_low { 3 } else { 1 };
|
||
score += effect.mana_restore * if mana_low { 2 } else { 1 };
|
||
score += effect.cooldown_reduction * if has_cooling_skill { 18 } else { 6 };
|
||
Some((score, item))
|
||
})
|
||
.max_by(|left, right| {
|
||
left.0
|
||
.cmp(&right.0)
|
||
.then_with(|| left.1.name.cmp(&right.1.name).reverse())
|
||
})
|
||
.map(|(_, item)| item)
|
||
}
|
||
|
||
fn build_battle_item_summary(effect: &BattleInventoryUseProfile) -> String {
|
||
let mut parts = Vec::new();
|
||
if effect.hp_restore > 0 {
|
||
parts.push(format!("回血 {}", effect.hp_restore));
|
||
}
|
||
if effect.mana_restore > 0 {
|
||
parts.push(format!("回蓝 {}", effect.mana_restore));
|
||
}
|
||
if effect.cooldown_reduction > 0 {
|
||
parts.push(format!("冷却 -{}", effect.cooldown_reduction));
|
||
}
|
||
if !effect.build_buffs.is_empty() {
|
||
let buff_names = effect
|
||
.build_buffs
|
||
.iter()
|
||
.filter_map(|buff| read_optional_string_field(buff, "name"))
|
||
.collect::<Vec<_>>();
|
||
if !buff_names.is_empty() {
|
||
parts.push(format!("增益 {}", buff_names.join("、")));
|
||
}
|
||
}
|
||
if parts.is_empty() {
|
||
"立即结算一次物品效果".to_string()
|
||
} else {
|
||
parts.join(" / ")
|
||
}
|
||
}
|
||
|
||
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_runtime_story_option_with_payload(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
scope: &str,
|
||
detail_text: Option<String>,
|
||
payload: Value,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
detail_text,
|
||
payload: Some(payload),
|
||
..build_static_runtime_story_option(function_id, action_text, scope)
|
||
}
|
||
}
|
||
|
||
fn build_disabled_runtime_story_option(
|
||
function_id: &str,
|
||
action_text: &str,
|
||
scope: &str,
|
||
detail_text: Option<String>,
|
||
reason: &str,
|
||
payload: Option<Value>,
|
||
) -> RuntimeStoryOptionView {
|
||
RuntimeStoryOptionView {
|
||
detail_text,
|
||
payload,
|
||
disabled: Some(true),
|
||
reason: Some(reason.to_string()),
|
||
..build_static_runtime_story_option(function_id, action_text, scope)
|
||
}
|
||
}
|
||
|
||
fn battle_victory_experience_reward(game_state: &Value) -> i32 {
|
||
let hostile = read_array_field(game_state, "sceneHostileNpcs")
|
||
.first()
|
||
.copied()
|
||
.or_else(|| read_field(game_state, "currentEncounter"));
|
||
let explicit_reward = hostile
|
||
.and_then(|entry| read_i32_field(entry, "experienceReward"))
|
||
.unwrap_or(0)
|
||
.max(0);
|
||
if explicit_reward > 0 {
|
||
return explicit_reward;
|
||
}
|
||
let level = hostile
|
||
.and_then(|entry| read_field(entry, "levelProfile"))
|
||
.and_then(|profile| read_i32_field(profile, "level"))
|
||
.unwrap_or(1)
|
||
.max(1);
|
||
12 + 6 * (level - 1)
|
||
}
|
||
|
||
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 build_battle_action_plan(
|
||
game_state: &Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
function_id: &str,
|
||
) -> Result<BattleActionPlan, String> {
|
||
if function_id == "battle_use_skill" {
|
||
return build_skill_battle_action_plan(game_state, request);
|
||
}
|
||
if function_id == "inventory_use" {
|
||
return build_inventory_use_battle_action_plan(game_state, request);
|
||
}
|
||
|
||
let (damage_dealt, damage_taken, heal, mana_restore, mana_cost, action_text, result_text) =
|
||
battle_action_numbers(function_id);
|
||
Ok(BattleActionPlan {
|
||
action_text: action_text.to_string(),
|
||
result_text: result_text.to_string(),
|
||
damage_dealt,
|
||
damage_taken,
|
||
heal,
|
||
mana_restore,
|
||
mana_cost,
|
||
cooldown_tick_turns: 1,
|
||
cooldown_bonus_turns: 0,
|
||
applied_skill_cooldown: None,
|
||
build_buffs: Vec::new(),
|
||
consumed_item_id: None,
|
||
})
|
||
}
|
||
|
||
fn build_skill_battle_action_plan(
|
||
game_state: &Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<BattleActionPlan, String> {
|
||
let payload = request
|
||
.action
|
||
.payload
|
||
.as_ref()
|
||
.ok_or_else(|| "battle_use_skill 缺少 skillId".to_string())?;
|
||
let skill_id = read_optional_string_field(payload, "skillId")
|
||
.ok_or_else(|| "battle_use_skill 缺少 skillId".to_string())?;
|
||
let skill = find_player_skill_by_id(game_state, skill_id.as_str())
|
||
.ok_or_else(|| format!("未找到技能：{skill_id}"))?;
|
||
let cooldowns = read_player_skill_cooldowns(game_state);
|
||
if cooldowns.get(skill_id.as_str()).copied().unwrap_or(0) > 0 {
|
||
return Err(format!("{} 仍在冷却中", skill.name));
|
||
}
|
||
if skill.mana_cost > read_i32_field(game_state, "playerMana").unwrap_or(0) {
|
||
return Err("当前灵力不足，无法执行这个战斗动作".to_string());
|
||
}
|
||
|
||
Ok(BattleActionPlan {
|
||
action_text: skill.name.clone(),
|
||
result_text: format!("{} 命中了敌人，这一轮技能效果已经直接结算。", skill.name),
|
||
damage_dealt: skill.damage.max(1),
|
||
damage_taken: 4,
|
||
heal: 0,
|
||
mana_restore: 0,
|
||
mana_cost: skill.mana_cost.max(0),
|
||
cooldown_tick_turns: 1,
|
||
cooldown_bonus_turns: 0,
|
||
applied_skill_cooldown: Some((skill.id, skill.cooldown_turns.max(0))),
|
||
build_buffs: skill.build_buffs,
|
||
consumed_item_id: None,
|
||
})
|
||
}
|
||
|
||
fn build_inventory_use_battle_action_plan(
|
||
game_state: &Value,
|
||
request: &RuntimeStoryActionRequest,
|
||
) -> Result<BattleActionPlan, String> {
|
||
let payload = request
|
||
.action
|
||
.payload
|
||
.as_ref()
|
||
.ok_or_else(|| "inventory_use 缺少 itemId".to_string())?;
|
||
let item_id = read_optional_string_field(payload, "itemId")
|
||
.ok_or_else(|| "inventory_use 缺少 itemId".to_string())?;
|
||
let item = find_player_inventory_item(game_state, item_id.as_str())
|
||
.ok_or_else(|| "未找到可用于战斗结算的物品".to_string())?;
|
||
if item.quantity <= 0 {
|
||
return Err("未找到可用于战斗结算的物品".to_string());
|
||
}
|
||
if item.use_profile.is_none() {
|
||
return Err(format!("{} 当前没有可直接结算的战斗效果", item.name));
|
||
}
|
||
let effect = item.use_profile.expect("use_profile should exist");
|
||
if effect.hp_restore <= 0
|
||
&& effect.mana_restore <= 0
|
||
&& effect.cooldown_reduction <= 0
|
||
&& effect.build_buffs.is_empty()
|
||
{
|
||
return Err(format!("{} 当前没有可直接结算的战斗效果", item.name));
|
||
}
|
||
|
||
Ok(BattleActionPlan {
|
||
action_text: format!("使用{}", item.name),
|
||
result_text: format!("你立刻用下{}，当前回合的物品效果已经生效。", item.name),
|
||
damage_dealt: 0,
|
||
damage_taken: 8,
|
||
heal: effect.hp_restore.max(0),
|
||
mana_restore: effect.mana_restore.max(0),
|
||
mana_cost: 0,
|
||
cooldown_tick_turns: 1,
|
||
cooldown_bonus_turns: effect.cooldown_reduction.max(0),
|
||
applied_skill_cooldown: None,
|
||
build_buffs: effect.build_buffs,
|
||
consumed_item_id: Some(item.id),
|
||
})
|
||
}
|
||
|
||
fn battle_action_toast(function_id: &str, request: &RuntimeStoryActionRequest) -> Option<String> {
|
||
if function_id != "inventory_use" {
|
||
return None;
|
||
}
|
||
request
|
||
.action
|
||
.payload
|
||
.as_ref()
|
||
.and_then(|payload| read_optional_string_field(payload, "itemId"))
|
||
.map(|_| "Build 增益已写回当前快照".to_string())
|
||
}
|