1064 lines
38 KiB
Rust
1064 lines
38 KiB
Rust
use std::{error::Error, fmt};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use shared_kernel::{
|
|
build_prefixed_seed_id, format_timestamp_micros,
|
|
normalize_optional_string as normalize_shared_optional_string, normalize_required_string,
|
|
normalize_string_list as normalize_shared_string_list,
|
|
};
|
|
#[cfg(feature = "spacetime-types")]
|
|
use spacetimedb::SpacetimeType;
|
|
|
|
pub const INVENTORY_SLOT_ID_PREFIX: &str = "invslot_";
|
|
pub const INVENTORY_MUTATION_ID_PREFIX: &str = "invmut_";
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub enum InventoryContainerKind {
|
|
Backpack,
|
|
Equipment,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub enum InventoryItemRarity {
|
|
Common,
|
|
Uncommon,
|
|
Rare,
|
|
Epic,
|
|
Legendary,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub enum InventoryEquipmentSlot {
|
|
Weapon,
|
|
Armor,
|
|
Relic,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub enum InventoryItemSourceKind {
|
|
StoryReward,
|
|
QuestReward,
|
|
TreasureReward,
|
|
NpcGift,
|
|
NpcTrade,
|
|
CombatDrop,
|
|
ForgeCraft,
|
|
ForgeReforge,
|
|
ManualPatch,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct InventoryItemSnapshot {
|
|
pub item_id: String,
|
|
pub category: String,
|
|
pub name: String,
|
|
pub description: Option<String>,
|
|
pub quantity: u32,
|
|
pub rarity: InventoryItemRarity,
|
|
pub tags: Vec<String>,
|
|
pub stackable: bool,
|
|
pub stack_key: String,
|
|
pub equipment_slot_id: Option<InventoryEquipmentSlot>,
|
|
pub source_kind: InventoryItemSourceKind,
|
|
pub source_reference_id: Option<String>,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct InventorySlotSnapshot {
|
|
pub slot_id: String,
|
|
pub runtime_session_id: String,
|
|
pub story_session_id: Option<String>,
|
|
pub actor_user_id: String,
|
|
pub container_kind: InventoryContainerKind,
|
|
pub slot_key: String,
|
|
pub item_id: String,
|
|
pub category: String,
|
|
pub name: String,
|
|
pub description: Option<String>,
|
|
pub quantity: u32,
|
|
pub rarity: InventoryItemRarity,
|
|
pub tags: Vec<String>,
|
|
pub stackable: bool,
|
|
pub stack_key: String,
|
|
pub equipment_slot_id: Option<InventoryEquipmentSlot>,
|
|
pub source_kind: InventoryItemSourceKind,
|
|
pub source_reference_id: Option<String>,
|
|
pub created_at_micros: i64,
|
|
pub updated_at_micros: i64,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct GrantInventoryItemInput {
|
|
pub slot_id: String,
|
|
pub item: InventoryItemSnapshot,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct ConsumeInventoryItemInput {
|
|
pub slot_id: String,
|
|
pub quantity: u32,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct EquipInventoryItemInput {
|
|
pub slot_id: String,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct UnequipInventoryItemInput {
|
|
pub slot_id: String,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub enum InventoryMutation {
|
|
GrantItem(GrantInventoryItemInput),
|
|
ConsumeItem(ConsumeInventoryItemInput),
|
|
EquipItem(EquipInventoryItemInput),
|
|
UnequipItem(UnequipInventoryItemInput),
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct InventoryMutationInput {
|
|
pub mutation_id: String,
|
|
pub runtime_session_id: String,
|
|
pub story_session_id: Option<String>,
|
|
pub actor_user_id: String,
|
|
pub mutation: InventoryMutation,
|
|
pub updated_at_micros: i64,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct RuntimeInventoryStateQueryInput {
|
|
pub runtime_session_id: String,
|
|
pub actor_user_id: String,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct RuntimeInventoryStateSnapshot {
|
|
pub runtime_session_id: String,
|
|
pub actor_user_id: String,
|
|
pub backpack_items: Vec<InventorySlotSnapshot>,
|
|
pub equipment_items: Vec<InventorySlotSnapshot>,
|
|
}
|
|
|
|
#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
pub struct RuntimeInventoryStateProcedureResult {
|
|
pub ok: bool,
|
|
pub snapshot: Option<RuntimeInventoryStateSnapshot>,
|
|
pub error_message: Option<String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct RuntimeInventorySlotRecord {
|
|
pub slot_id: String,
|
|
pub container_kind: String,
|
|
pub slot_key: String,
|
|
pub item_id: String,
|
|
pub category: String,
|
|
pub name: String,
|
|
pub description: Option<String>,
|
|
pub quantity: u32,
|
|
pub rarity: String,
|
|
pub tags: Vec<String>,
|
|
pub stackable: bool,
|
|
pub stack_key: String,
|
|
pub equipment_slot_id: Option<String>,
|
|
pub source_kind: String,
|
|
pub source_reference_id: Option<String>,
|
|
pub created_at: String,
|
|
pub updated_at: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct RuntimeInventoryStateRecord {
|
|
pub runtime_session_id: String,
|
|
pub actor_user_id: String,
|
|
pub backpack_items: Vec<RuntimeInventorySlotRecord>,
|
|
pub equipment_items: Vec<RuntimeInventorySlotRecord>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct InventoryMutationOutcome {
|
|
pub next_slots: Vec<InventorySlotSnapshot>,
|
|
pub changed: bool,
|
|
pub updated_slot_ids: Vec<String>,
|
|
pub removed_slot_ids: Vec<String>,
|
|
pub affected_equipment_slot: Option<InventoryEquipmentSlot>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub enum InventoryMutationFieldError {
|
|
MissingMutationId,
|
|
MissingRuntimeSessionId,
|
|
MissingActorUserId,
|
|
MissingSlotId,
|
|
MissingItemId,
|
|
MissingCategory,
|
|
MissingName,
|
|
InvalidQuantity,
|
|
MissingStackKey,
|
|
NonStackableItemMustStaySingleQuantity,
|
|
EquipmentItemCannotStack,
|
|
SlotScopeMismatch,
|
|
ItemNotFound,
|
|
ItemNotInBackpack,
|
|
ItemNotEquipped,
|
|
InsufficientQuantity,
|
|
ItemNotEquippable,
|
|
}
|
|
|
|
impl InventoryEquipmentSlot {
|
|
pub fn as_str(self) -> &'static str {
|
|
match self {
|
|
Self::Weapon => "weapon",
|
|
Self::Armor => "armor",
|
|
Self::Relic => "relic",
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn generate_inventory_slot_id(seed_micros: i64) -> String {
|
|
build_prefixed_seed_id(INVENTORY_SLOT_ID_PREFIX, seed_micros)
|
|
}
|
|
|
|
pub fn generate_inventory_mutation_id(seed_micros: i64) -> String {
|
|
build_prefixed_seed_id(INVENTORY_MUTATION_ID_PREFIX, seed_micros)
|
|
}
|
|
|
|
pub fn normalize_optional_text(value: Option<String>) -> Option<String> {
|
|
normalize_shared_optional_string(value)
|
|
}
|
|
|
|
pub fn normalize_string_list(values: Vec<String>) -> Vec<String> {
|
|
normalize_shared_string_list(values)
|
|
}
|
|
|
|
pub fn build_runtime_inventory_state_query_input(
|
|
runtime_session_id: String,
|
|
actor_user_id: String,
|
|
) -> Result<RuntimeInventoryStateQueryInput, InventoryMutationFieldError> {
|
|
let input = RuntimeInventoryStateQueryInput {
|
|
runtime_session_id: normalize_required_text(
|
|
runtime_session_id,
|
|
InventoryMutationFieldError::MissingRuntimeSessionId,
|
|
)?,
|
|
actor_user_id: normalize_required_text(
|
|
actor_user_id,
|
|
InventoryMutationFieldError::MissingActorUserId,
|
|
)?,
|
|
};
|
|
|
|
Ok(input)
|
|
}
|
|
|
|
pub fn build_runtime_inventory_state_snapshot(
|
|
input: RuntimeInventoryStateQueryInput,
|
|
slots: Vec<InventorySlotSnapshot>,
|
|
) -> RuntimeInventoryStateSnapshot {
|
|
let mut backpack_items = Vec::new();
|
|
let mut equipment_items = Vec::new();
|
|
|
|
for slot in slots {
|
|
match slot.container_kind {
|
|
InventoryContainerKind::Backpack => backpack_items.push(slot),
|
|
InventoryContainerKind::Equipment => equipment_items.push(slot),
|
|
}
|
|
}
|
|
|
|
backpack_items.sort_by(|left, right| {
|
|
left.slot_key
|
|
.cmp(&right.slot_key)
|
|
.then(left.slot_id.cmp(&right.slot_id))
|
|
});
|
|
equipment_items.sort_by(|left, right| {
|
|
equipment_slot_order(left.equipment_slot_id)
|
|
.cmp(&equipment_slot_order(right.equipment_slot_id))
|
|
.then(left.slot_id.cmp(&right.slot_id))
|
|
});
|
|
|
|
RuntimeInventoryStateSnapshot {
|
|
runtime_session_id: input.runtime_session_id,
|
|
actor_user_id: input.actor_user_id,
|
|
backpack_items,
|
|
equipment_items,
|
|
}
|
|
}
|
|
|
|
pub fn apply_inventory_mutation(
|
|
current_slots: Vec<InventorySlotSnapshot>,
|
|
input: InventoryMutationInput,
|
|
) -> Result<InventoryMutationOutcome, InventoryMutationFieldError> {
|
|
let _mutation_id = normalize_required_text(
|
|
input.mutation_id,
|
|
InventoryMutationFieldError::MissingMutationId,
|
|
)?;
|
|
let runtime_session_id = normalize_required_text(
|
|
input.runtime_session_id,
|
|
InventoryMutationFieldError::MissingRuntimeSessionId,
|
|
)?;
|
|
let actor_user_id = normalize_required_text(
|
|
input.actor_user_id,
|
|
InventoryMutationFieldError::MissingActorUserId,
|
|
)?;
|
|
let story_session_id = normalize_optional_text(input.story_session_id);
|
|
|
|
let mut slots = current_slots;
|
|
for slot in &slots {
|
|
if slot.runtime_session_id != runtime_session_id || slot.actor_user_id != actor_user_id {
|
|
return Err(InventoryMutationFieldError::SlotScopeMismatch);
|
|
}
|
|
}
|
|
|
|
let outcome = match input.mutation {
|
|
InventoryMutation::GrantItem(grant) => apply_grant_item(
|
|
&mut slots,
|
|
runtime_session_id,
|
|
story_session_id,
|
|
actor_user_id,
|
|
grant,
|
|
input.updated_at_micros,
|
|
)?,
|
|
InventoryMutation::ConsumeItem(consume) => {
|
|
apply_consume_item(&mut slots, consume, input.updated_at_micros)?
|
|
}
|
|
InventoryMutation::EquipItem(equip) => {
|
|
apply_equip_item(&mut slots, equip, input.updated_at_micros)?
|
|
}
|
|
InventoryMutation::UnequipItem(unequip) => {
|
|
apply_unequip_item(&mut slots, unequip, input.updated_at_micros)?
|
|
}
|
|
};
|
|
|
|
Ok(InventoryMutationOutcome {
|
|
next_slots: sort_inventory_slots(slots),
|
|
changed: outcome.changed,
|
|
updated_slot_ids: sort_string_list(outcome.updated_slot_ids),
|
|
removed_slot_ids: sort_string_list(outcome.removed_slot_ids),
|
|
affected_equipment_slot: outcome.affected_equipment_slot,
|
|
})
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
struct InventoryMutationInternalOutcome {
|
|
changed: bool,
|
|
updated_slot_ids: Vec<String>,
|
|
removed_slot_ids: Vec<String>,
|
|
affected_equipment_slot: Option<InventoryEquipmentSlot>,
|
|
}
|
|
|
|
fn apply_grant_item(
|
|
slots: &mut Vec<InventorySlotSnapshot>,
|
|
runtime_session_id: String,
|
|
story_session_id: Option<String>,
|
|
actor_user_id: String,
|
|
grant: GrantInventoryItemInput,
|
|
updated_at_micros: i64,
|
|
) -> Result<InventoryMutationInternalOutcome, InventoryMutationFieldError> {
|
|
let slot_id =
|
|
normalize_required_text(grant.slot_id, InventoryMutationFieldError::MissingSlotId)?;
|
|
let item = normalize_inventory_item_snapshot(grant.item)?;
|
|
|
|
if item.stackable {
|
|
if let Some(existing) = slots.iter_mut().find(|slot| {
|
|
slot.container_kind == InventoryContainerKind::Backpack
|
|
&& slot.stackable
|
|
&& slot.item_id == item.item_id
|
|
&& slot.stack_key == item.stack_key
|
|
}) {
|
|
existing.category = item.category;
|
|
existing.name = item.name;
|
|
existing.description = item.description;
|
|
existing.quantity += item.quantity;
|
|
existing.rarity = item.rarity;
|
|
existing.tags = item.tags;
|
|
existing.stackable = item.stackable;
|
|
existing.stack_key = item.stack_key;
|
|
existing.equipment_slot_id = item.equipment_slot_id;
|
|
existing.source_kind = item.source_kind;
|
|
existing.source_reference_id = item.source_reference_id;
|
|
existing.updated_at_micros = updated_at_micros;
|
|
|
|
return Ok(InventoryMutationInternalOutcome {
|
|
changed: true,
|
|
updated_slot_ids: vec![existing.slot_id.clone()],
|
|
removed_slot_ids: vec![],
|
|
affected_equipment_slot: None,
|
|
});
|
|
}
|
|
}
|
|
|
|
slots.push(InventorySlotSnapshot {
|
|
slot_id: slot_id.clone(),
|
|
runtime_session_id,
|
|
story_session_id,
|
|
actor_user_id,
|
|
container_kind: InventoryContainerKind::Backpack,
|
|
slot_key: build_backpack_slot_key(&slot_id),
|
|
item_id: item.item_id,
|
|
category: item.category,
|
|
name: item.name,
|
|
description: item.description,
|
|
quantity: item.quantity,
|
|
rarity: item.rarity,
|
|
tags: item.tags,
|
|
stackable: item.stackable,
|
|
stack_key: item.stack_key,
|
|
equipment_slot_id: item.equipment_slot_id,
|
|
source_kind: item.source_kind,
|
|
source_reference_id: item.source_reference_id,
|
|
created_at_micros: updated_at_micros,
|
|
updated_at_micros,
|
|
});
|
|
|
|
Ok(InventoryMutationInternalOutcome {
|
|
changed: true,
|
|
updated_slot_ids: vec![slot_id],
|
|
removed_slot_ids: vec![],
|
|
affected_equipment_slot: None,
|
|
})
|
|
}
|
|
|
|
fn apply_consume_item(
|
|
slots: &mut Vec<InventorySlotSnapshot>,
|
|
consume: ConsumeInventoryItemInput,
|
|
updated_at_micros: i64,
|
|
) -> Result<InventoryMutationInternalOutcome, InventoryMutationFieldError> {
|
|
let slot_id =
|
|
normalize_required_text(consume.slot_id, InventoryMutationFieldError::MissingSlotId)?;
|
|
if consume.quantity == 0 {
|
|
return Err(InventoryMutationFieldError::InvalidQuantity);
|
|
}
|
|
|
|
let slot_index = slots
|
|
.iter()
|
|
.position(|slot| slot.slot_id == slot_id)
|
|
.ok_or(InventoryMutationFieldError::ItemNotFound)?;
|
|
|
|
if slots[slot_index].container_kind != InventoryContainerKind::Backpack {
|
|
return Err(InventoryMutationFieldError::ItemNotInBackpack);
|
|
}
|
|
|
|
if slots[slot_index].quantity < consume.quantity {
|
|
return Err(InventoryMutationFieldError::InsufficientQuantity);
|
|
}
|
|
|
|
if slots[slot_index].quantity == consume.quantity {
|
|
slots.remove(slot_index);
|
|
return Ok(InventoryMutationInternalOutcome {
|
|
changed: true,
|
|
updated_slot_ids: vec![],
|
|
removed_slot_ids: vec![slot_id],
|
|
affected_equipment_slot: None,
|
|
});
|
|
}
|
|
|
|
slots[slot_index].quantity -= consume.quantity;
|
|
slots[slot_index].updated_at_micros = updated_at_micros;
|
|
|
|
Ok(InventoryMutationInternalOutcome {
|
|
changed: true,
|
|
updated_slot_ids: vec![slots[slot_index].slot_id.clone()],
|
|
removed_slot_ids: vec![],
|
|
affected_equipment_slot: None,
|
|
})
|
|
}
|
|
|
|
fn apply_equip_item(
|
|
slots: &mut [InventorySlotSnapshot],
|
|
equip: EquipInventoryItemInput,
|
|
updated_at_micros: i64,
|
|
) -> Result<InventoryMutationInternalOutcome, InventoryMutationFieldError> {
|
|
let slot_id =
|
|
normalize_required_text(equip.slot_id, InventoryMutationFieldError::MissingSlotId)?;
|
|
let source_index = slots
|
|
.iter()
|
|
.position(|slot| slot.slot_id == slot_id)
|
|
.ok_or(InventoryMutationFieldError::ItemNotFound)?;
|
|
let target_slot = slots[source_index]
|
|
.equipment_slot_id
|
|
.ok_or(InventoryMutationFieldError::ItemNotEquippable)?;
|
|
|
|
if slots[source_index].stackable {
|
|
return Err(InventoryMutationFieldError::EquipmentItemCannotStack);
|
|
}
|
|
if slots[source_index].quantity != 1 {
|
|
return Err(InventoryMutationFieldError::NonStackableItemMustStaySingleQuantity);
|
|
}
|
|
if slots[source_index].container_kind != InventoryContainerKind::Backpack {
|
|
if slots[source_index].container_kind == InventoryContainerKind::Equipment {
|
|
return Ok(InventoryMutationInternalOutcome {
|
|
changed: false,
|
|
updated_slot_ids: vec![],
|
|
removed_slot_ids: vec![],
|
|
affected_equipment_slot: Some(target_slot),
|
|
});
|
|
}
|
|
|
|
return Err(InventoryMutationFieldError::ItemNotInBackpack);
|
|
}
|
|
|
|
let occupied_index = slots.iter().position(|slot| {
|
|
slot.container_kind == InventoryContainerKind::Equipment
|
|
&& slot.slot_key == build_equipment_slot_key(target_slot)
|
|
});
|
|
|
|
let mut updated_slot_ids = vec![slot_id.clone()];
|
|
if let Some(occupied_index) = occupied_index {
|
|
// 首版装备互换直接在同一条 slot 真相记录上切容器，不生成临时副本。
|
|
slots[occupied_index].container_kind = InventoryContainerKind::Backpack;
|
|
slots[occupied_index].slot_key = build_backpack_slot_key(&slots[occupied_index].slot_id);
|
|
slots[occupied_index].updated_at_micros = updated_at_micros;
|
|
updated_slot_ids.push(slots[occupied_index].slot_id.clone());
|
|
}
|
|
|
|
slots[source_index].container_kind = InventoryContainerKind::Equipment;
|
|
slots[source_index].slot_key = build_equipment_slot_key(target_slot);
|
|
slots[source_index].updated_at_micros = updated_at_micros;
|
|
|
|
Ok(InventoryMutationInternalOutcome {
|
|
changed: true,
|
|
updated_slot_ids,
|
|
removed_slot_ids: vec![],
|
|
affected_equipment_slot: Some(target_slot),
|
|
})
|
|
}
|
|
|
|
fn apply_unequip_item(
|
|
slots: &mut [InventorySlotSnapshot],
|
|
unequip: UnequipInventoryItemInput,
|
|
updated_at_micros: i64,
|
|
) -> Result<InventoryMutationInternalOutcome, InventoryMutationFieldError> {
|
|
let slot_id =
|
|
normalize_required_text(unequip.slot_id, InventoryMutationFieldError::MissingSlotId)?;
|
|
let slot_index = slots
|
|
.iter()
|
|
.position(|slot| slot.slot_id == slot_id)
|
|
.ok_or(InventoryMutationFieldError::ItemNotFound)?;
|
|
|
|
if slots[slot_index].container_kind != InventoryContainerKind::Equipment {
|
|
return Err(InventoryMutationFieldError::ItemNotEquipped);
|
|
}
|
|
|
|
let affected_equipment_slot = slots[slot_index].equipment_slot_id;
|
|
slots[slot_index].container_kind = InventoryContainerKind::Backpack;
|
|
slots[slot_index].slot_key = build_backpack_slot_key(&slot_id);
|
|
slots[slot_index].updated_at_micros = updated_at_micros;
|
|
|
|
Ok(InventoryMutationInternalOutcome {
|
|
changed: true,
|
|
updated_slot_ids: vec![slot_id],
|
|
removed_slot_ids: vec![],
|
|
affected_equipment_slot,
|
|
})
|
|
}
|
|
|
|
fn normalize_inventory_item_snapshot(
|
|
item: InventoryItemSnapshot,
|
|
) -> Result<InventoryItemSnapshot, InventoryMutationFieldError> {
|
|
let item_id =
|
|
normalize_required_text(item.item_id, InventoryMutationFieldError::MissingItemId)?;
|
|
let category =
|
|
normalize_required_text(item.category, InventoryMutationFieldError::MissingCategory)?;
|
|
let name = normalize_required_text(item.name, InventoryMutationFieldError::MissingName)?;
|
|
if item.quantity == 0 {
|
|
return Err(InventoryMutationFieldError::InvalidQuantity);
|
|
}
|
|
|
|
if !item.stackable && item.quantity != 1 {
|
|
return Err(InventoryMutationFieldError::NonStackableItemMustStaySingleQuantity);
|
|
}
|
|
|
|
if item.equipment_slot_id.is_some() && item.stackable {
|
|
return Err(InventoryMutationFieldError::EquipmentItemCannotStack);
|
|
}
|
|
|
|
let stack_key = if item.stackable {
|
|
normalize_required_text(item.stack_key, InventoryMutationFieldError::MissingStackKey)?
|
|
} else {
|
|
normalize_optional_text(Some(item.stack_key)).unwrap_or_else(|| item_id.clone())
|
|
};
|
|
|
|
Ok(InventoryItemSnapshot {
|
|
item_id,
|
|
category,
|
|
name,
|
|
description: normalize_optional_text(item.description),
|
|
quantity: item.quantity,
|
|
rarity: item.rarity,
|
|
tags: normalize_string_list(item.tags),
|
|
stackable: item.stackable,
|
|
stack_key,
|
|
equipment_slot_id: item.equipment_slot_id,
|
|
source_kind: item.source_kind,
|
|
source_reference_id: normalize_optional_text(item.source_reference_id),
|
|
})
|
|
}
|
|
|
|
fn normalize_required_text(
|
|
value: String,
|
|
error: InventoryMutationFieldError,
|
|
) -> Result<String, InventoryMutationFieldError> {
|
|
normalize_required_string(value).ok_or(error)
|
|
}
|
|
|
|
fn sort_inventory_slots(mut slots: Vec<InventorySlotSnapshot>) -> Vec<InventorySlotSnapshot> {
|
|
slots.sort_by(|left, right| {
|
|
container_order(left.container_kind)
|
|
.cmp(&container_order(right.container_kind))
|
|
.then(left.slot_key.cmp(&right.slot_key))
|
|
.then(left.slot_id.cmp(&right.slot_id))
|
|
});
|
|
slots
|
|
}
|
|
|
|
fn sort_string_list(mut values: Vec<String>) -> Vec<String> {
|
|
values.sort();
|
|
values
|
|
}
|
|
|
|
fn container_order(kind: InventoryContainerKind) -> u8 {
|
|
match kind {
|
|
InventoryContainerKind::Equipment => 0,
|
|
InventoryContainerKind::Backpack => 1,
|
|
}
|
|
}
|
|
|
|
fn equipment_slot_order(slot: Option<InventoryEquipmentSlot>) -> u8 {
|
|
match slot {
|
|
Some(InventoryEquipmentSlot::Weapon) => 0,
|
|
Some(InventoryEquipmentSlot::Armor) => 1,
|
|
Some(InventoryEquipmentSlot::Relic) => 2,
|
|
None => 3,
|
|
}
|
|
}
|
|
|
|
fn build_backpack_slot_key(slot_id: &str) -> String {
|
|
slot_id.to_string()
|
|
}
|
|
|
|
fn build_equipment_slot_key(slot: InventoryEquipmentSlot) -> String {
|
|
slot.as_str().to_string()
|
|
}
|
|
|
|
pub fn build_runtime_inventory_state_record(
|
|
snapshot: RuntimeInventoryStateSnapshot,
|
|
) -> RuntimeInventoryStateRecord {
|
|
RuntimeInventoryStateRecord {
|
|
runtime_session_id: snapshot.runtime_session_id,
|
|
actor_user_id: snapshot.actor_user_id,
|
|
backpack_items: snapshot
|
|
.backpack_items
|
|
.into_iter()
|
|
.map(build_runtime_inventory_slot_record)
|
|
.collect(),
|
|
equipment_items: snapshot
|
|
.equipment_items
|
|
.into_iter()
|
|
.map(build_runtime_inventory_slot_record)
|
|
.collect(),
|
|
}
|
|
}
|
|
|
|
fn build_runtime_inventory_slot_record(slot: InventorySlotSnapshot) -> RuntimeInventorySlotRecord {
|
|
RuntimeInventorySlotRecord {
|
|
slot_id: slot.slot_id,
|
|
container_kind: format_inventory_container_kind(slot.container_kind).to_string(),
|
|
slot_key: slot.slot_key,
|
|
item_id: slot.item_id,
|
|
category: slot.category,
|
|
name: slot.name,
|
|
description: slot.description,
|
|
quantity: slot.quantity,
|
|
rarity: format_inventory_item_rarity(slot.rarity).to_string(),
|
|
tags: slot.tags,
|
|
stackable: slot.stackable,
|
|
stack_key: slot.stack_key,
|
|
equipment_slot_id: slot
|
|
.equipment_slot_id
|
|
.map(|value| value.as_str().to_string()),
|
|
source_kind: format_inventory_item_source_kind(slot.source_kind).to_string(),
|
|
source_reference_id: slot.source_reference_id,
|
|
created_at: format_timestamp_micros(slot.created_at_micros),
|
|
updated_at: format_timestamp_micros(slot.updated_at_micros),
|
|
}
|
|
}
|
|
|
|
fn format_inventory_container_kind(value: InventoryContainerKind) -> &'static str {
|
|
match value {
|
|
InventoryContainerKind::Backpack => "backpack",
|
|
InventoryContainerKind::Equipment => "equipment",
|
|
}
|
|
}
|
|
|
|
fn format_inventory_item_rarity(value: InventoryItemRarity) -> &'static str {
|
|
match value {
|
|
InventoryItemRarity::Common => "common",
|
|
InventoryItemRarity::Uncommon => "uncommon",
|
|
InventoryItemRarity::Rare => "rare",
|
|
InventoryItemRarity::Epic => "epic",
|
|
InventoryItemRarity::Legendary => "legendary",
|
|
}
|
|
}
|
|
|
|
fn format_inventory_item_source_kind(value: InventoryItemSourceKind) -> &'static str {
|
|
match value {
|
|
InventoryItemSourceKind::StoryReward => "story_reward",
|
|
InventoryItemSourceKind::QuestReward => "quest_reward",
|
|
InventoryItemSourceKind::TreasureReward => "treasure_reward",
|
|
InventoryItemSourceKind::NpcGift => "npc_gift",
|
|
InventoryItemSourceKind::NpcTrade => "npc_trade",
|
|
InventoryItemSourceKind::CombatDrop => "combat_drop",
|
|
InventoryItemSourceKind::ForgeCraft => "forge_craft",
|
|
InventoryItemSourceKind::ForgeReforge => "forge_reforge",
|
|
InventoryItemSourceKind::ManualPatch => "manual_patch",
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for InventoryMutationFieldError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::MissingMutationId => f.write_str("inventory_mutation.mutation_id 不能为空"),
|
|
Self::MissingRuntimeSessionId => {
|
|
f.write_str("inventory_mutation.runtime_session_id 不能为空")
|
|
}
|
|
Self::MissingActorUserId => f.write_str("inventory_mutation.actor_user_id 不能为空"),
|
|
Self::MissingSlotId => f.write_str("inventory_slot.slot_id 不能为空"),
|
|
Self::MissingItemId => f.write_str("inventory_item.item_id 不能为空"),
|
|
Self::MissingCategory => f.write_str("inventory_item.category 不能为空"),
|
|
Self::MissingName => f.write_str("inventory_item.name 不能为空"),
|
|
Self::InvalidQuantity => f.write_str("inventory_item.quantity 必须大于 0"),
|
|
Self::MissingStackKey => f.write_str("可堆叠物品必须提供 stack_key"),
|
|
Self::NonStackableItemMustStaySingleQuantity => {
|
|
f.write_str("不可堆叠物品必须固定为单槽位单数量")
|
|
}
|
|
Self::EquipmentItemCannotStack => f.write_str("可装备物品不能标记为 stackable"),
|
|
Self::SlotScopeMismatch => {
|
|
f.write_str("当前 inventory_slot 不属于本次 mutation 作用域")
|
|
}
|
|
Self::ItemNotFound => f.write_str("目标 inventory_slot 不存在"),
|
|
Self::ItemNotInBackpack => f.write_str("目标物品当前不在背包中"),
|
|
Self::ItemNotEquipped => f.write_str("目标物品当前不在装备位上"),
|
|
Self::InsufficientQuantity => f.write_str("当前背包数量不足，无法完成扣减"),
|
|
Self::ItemNotEquippable => f.write_str("目标物品当前不可装备"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Error for InventoryMutationFieldError {}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn build_stackable_item(quantity: u32) -> InventoryItemSnapshot {
|
|
InventoryItemSnapshot {
|
|
item_id: "consumable_heal_potion".to_string(),
|
|
category: "消耗品".to_string(),
|
|
name: "疗伤药".to_string(),
|
|
description: Some("用于恢复少量气血。".to_string()),
|
|
quantity,
|
|
rarity: InventoryItemRarity::Common,
|
|
tags: vec!["healing".to_string()],
|
|
stackable: true,
|
|
stack_key: "heal_potion".to_string(),
|
|
equipment_slot_id: None,
|
|
source_kind: InventoryItemSourceKind::TreasureReward,
|
|
source_reference_id: Some("treasure_001".to_string()),
|
|
}
|
|
}
|
|
|
|
fn build_weapon_item(slot_id: &str, name: &str) -> InventorySlotSnapshot {
|
|
InventorySlotSnapshot {
|
|
slot_id: slot_id.to_string(),
|
|
runtime_session_id: "runtime_001".to_string(),
|
|
story_session_id: Some("storysess_001".to_string()),
|
|
actor_user_id: "user_001".to_string(),
|
|
container_kind: InventoryContainerKind::Backpack,
|
|
slot_key: slot_id.to_string(),
|
|
item_id: format!("weapon:{slot_id}"),
|
|
category: "武器".to_string(),
|
|
name: name.to_string(),
|
|
description: Some("测试武器".to_string()),
|
|
quantity: 1,
|
|
rarity: InventoryItemRarity::Rare,
|
|
tags: vec!["weapon".to_string(), "快剑".to_string()],
|
|
stackable: false,
|
|
stack_key: format!("weapon:{slot_id}"),
|
|
equipment_slot_id: Some(InventoryEquipmentSlot::Weapon),
|
|
source_kind: InventoryItemSourceKind::StoryReward,
|
|
source_reference_id: Some("storyevt_001".to_string()),
|
|
created_at_micros: 1,
|
|
updated_at_micros: 1,
|
|
}
|
|
}
|
|
|
|
fn build_mutation_input(mutation: InventoryMutation) -> InventoryMutationInput {
|
|
InventoryMutationInput {
|
|
mutation_id: "invmut_001".to_string(),
|
|
runtime_session_id: "runtime_001".to_string(),
|
|
story_session_id: Some("storysess_001".to_string()),
|
|
actor_user_id: "user_001".to_string(),
|
|
mutation,
|
|
updated_at_micros: 10,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn grant_item_merges_existing_stackable_slot() {
|
|
let current = vec![InventorySlotSnapshot {
|
|
slot_id: "invslot_existing".to_string(),
|
|
runtime_session_id: "runtime_001".to_string(),
|
|
story_session_id: Some("storysess_001".to_string()),
|
|
actor_user_id: "user_001".to_string(),
|
|
container_kind: InventoryContainerKind::Backpack,
|
|
slot_key: "invslot_existing".to_string(),
|
|
item_id: "consumable_heal_potion".to_string(),
|
|
category: "消耗品".to_string(),
|
|
name: "疗伤药".to_string(),
|
|
description: None,
|
|
quantity: 2,
|
|
rarity: InventoryItemRarity::Common,
|
|
tags: vec!["healing".to_string()],
|
|
stackable: true,
|
|
stack_key: "heal_potion".to_string(),
|
|
equipment_slot_id: None,
|
|
source_kind: InventoryItemSourceKind::TreasureReward,
|
|
source_reference_id: Some("treasure_000".to_string()),
|
|
created_at_micros: 1,
|
|
updated_at_micros: 1,
|
|
}];
|
|
|
|
let outcome = apply_inventory_mutation(
|
|
current,
|
|
build_mutation_input(InventoryMutation::GrantItem(GrantInventoryItemInput {
|
|
slot_id: "invslot_new".to_string(),
|
|
item: build_stackable_item(3),
|
|
})),
|
|
)
|
|
.expect("grant should merge stackable row");
|
|
|
|
assert!(outcome.changed);
|
|
assert_eq!(outcome.next_slots.len(), 1);
|
|
assert_eq!(outcome.next_slots[0].quantity, 5);
|
|
assert_eq!(
|
|
outcome.updated_slot_ids,
|
|
vec!["invslot_existing".to_string()]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn grant_non_stackable_item_requires_single_quantity() {
|
|
let error = apply_inventory_mutation(
|
|
vec![],
|
|
build_mutation_input(InventoryMutation::GrantItem(GrantInventoryItemInput {
|
|
slot_id: "invslot_weapon".to_string(),
|
|
item: InventoryItemSnapshot {
|
|
item_id: "weapon_001".to_string(),
|
|
category: "武器".to_string(),
|
|
name: "试作短剑".to_string(),
|
|
description: None,
|
|
quantity: 2,
|
|
rarity: InventoryItemRarity::Rare,
|
|
tags: vec!["weapon".to_string()],
|
|
stackable: false,
|
|
stack_key: String::new(),
|
|
equipment_slot_id: Some(InventoryEquipmentSlot::Weapon),
|
|
source_kind: InventoryItemSourceKind::StoryReward,
|
|
source_reference_id: None,
|
|
},
|
|
})),
|
|
)
|
|
.expect_err("non-stackable item quantity must stay single");
|
|
|
|
assert_eq!(
|
|
error,
|
|
InventoryMutationFieldError::NonStackableItemMustStaySingleQuantity
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn consume_item_removes_slot_when_quantity_exhausted() {
|
|
let current = vec![InventorySlotSnapshot {
|
|
slot_id: "invslot_potion".to_string(),
|
|
runtime_session_id: "runtime_001".to_string(),
|
|
story_session_id: Some("storysess_001".to_string()),
|
|
actor_user_id: "user_001".to_string(),
|
|
container_kind: InventoryContainerKind::Backpack,
|
|
slot_key: "invslot_potion".to_string(),
|
|
item_id: "consumable_heal_potion".to_string(),
|
|
category: "消耗品".to_string(),
|
|
name: "疗伤药".to_string(),
|
|
description: None,
|
|
quantity: 1,
|
|
rarity: InventoryItemRarity::Common,
|
|
tags: vec!["healing".to_string()],
|
|
stackable: true,
|
|
stack_key: "heal_potion".to_string(),
|
|
equipment_slot_id: None,
|
|
source_kind: InventoryItemSourceKind::TreasureReward,
|
|
source_reference_id: None,
|
|
created_at_micros: 1,
|
|
updated_at_micros: 1,
|
|
}];
|
|
|
|
let outcome = apply_inventory_mutation(
|
|
current,
|
|
build_mutation_input(InventoryMutation::ConsumeItem(ConsumeInventoryItemInput {
|
|
slot_id: "invslot_potion".to_string(),
|
|
quantity: 1,
|
|
})),
|
|
)
|
|
.expect("consume should remove exhausted slot");
|
|
|
|
assert!(outcome.next_slots.is_empty());
|
|
assert_eq!(outcome.removed_slot_ids, vec!["invslot_potion".to_string()]);
|
|
}
|
|
|
|
#[test]
|
|
fn equip_item_swaps_existing_equipment_back_to_backpack() {
|
|
let equipped = InventorySlotSnapshot {
|
|
container_kind: InventoryContainerKind::Equipment,
|
|
slot_key: InventoryEquipmentSlot::Weapon.as_str().to_string(),
|
|
..build_weapon_item("invslot_old_weapon", "旧佩剑")
|
|
};
|
|
let backpack_weapon = build_weapon_item("invslot_new_weapon", "逐风短剑");
|
|
|
|
let outcome = apply_inventory_mutation(
|
|
vec![equipped, backpack_weapon],
|
|
build_mutation_input(InventoryMutation::EquipItem(EquipInventoryItemInput {
|
|
slot_id: "invslot_new_weapon".to_string(),
|
|
})),
|
|
)
|
|
.expect("equip should swap weapon");
|
|
|
|
assert!(outcome.changed);
|
|
assert_eq!(
|
|
outcome.affected_equipment_slot,
|
|
Some(InventoryEquipmentSlot::Weapon)
|
|
);
|
|
|
|
let weapon_slot = outcome
|
|
.next_slots
|
|
.iter()
|
|
.find(|slot| slot.slot_id == "invslot_new_weapon")
|
|
.expect("new weapon slot should exist");
|
|
assert_eq!(
|
|
weapon_slot.container_kind,
|
|
InventoryContainerKind::Equipment
|
|
);
|
|
assert_eq!(weapon_slot.slot_key, "weapon");
|
|
|
|
let old_weapon_slot = outcome
|
|
.next_slots
|
|
.iter()
|
|
.find(|slot| slot.slot_id == "invslot_old_weapon")
|
|
.expect("old weapon slot should exist");
|
|
assert_eq!(
|
|
old_weapon_slot.container_kind,
|
|
InventoryContainerKind::Backpack
|
|
);
|
|
assert_eq!(old_weapon_slot.slot_key, "invslot_old_weapon");
|
|
}
|
|
|
|
#[test]
|
|
fn unequip_item_moves_equipment_back_to_backpack() {
|
|
let equipped = InventorySlotSnapshot {
|
|
container_kind: InventoryContainerKind::Equipment,
|
|
slot_key: InventoryEquipmentSlot::Relic.as_str().to_string(),
|
|
equipment_slot_id: Some(InventoryEquipmentSlot::Relic),
|
|
..build_weapon_item("invslot_relic", "旧誓护符")
|
|
};
|
|
|
|
let outcome = apply_inventory_mutation(
|
|
vec![equipped],
|
|
build_mutation_input(InventoryMutation::UnequipItem(UnequipInventoryItemInput {
|
|
slot_id: "invslot_relic".to_string(),
|
|
})),
|
|
)
|
|
.expect("unequip should move relic back to backpack");
|
|
|
|
assert!(outcome.changed);
|
|
assert_eq!(
|
|
outcome.affected_equipment_slot,
|
|
Some(InventoryEquipmentSlot::Relic)
|
|
);
|
|
assert_eq!(outcome.next_slots.len(), 1);
|
|
assert_eq!(
|
|
outcome.next_slots[0].container_kind,
|
|
InventoryContainerKind::Backpack
|
|
);
|
|
assert_eq!(outcome.next_slots[0].slot_key, "invslot_relic");
|
|
}
|
|
|
|
#[test]
|
|
fn build_runtime_inventory_state_query_input_trims_scope_fields() {
|
|
let input = build_runtime_inventory_state_query_input(
|
|
" runtime_001 ".to_string(),
|
|
" user_001 ".to_string(),
|
|
)
|
|
.expect("query input should build");
|
|
|
|
assert_eq!(input.runtime_session_id, "runtime_001");
|
|
assert_eq!(input.actor_user_id, "user_001");
|
|
}
|
|
|
|
#[test]
|
|
fn build_runtime_inventory_state_snapshot_splits_backpack_and_equipment() {
|
|
let snapshot = build_runtime_inventory_state_snapshot(
|
|
RuntimeInventoryStateQueryInput {
|
|
runtime_session_id: "runtime_001".to_string(),
|
|
actor_user_id: "user_001".to_string(),
|
|
},
|
|
vec![
|
|
InventorySlotSnapshot {
|
|
container_kind: InventoryContainerKind::Equipment,
|
|
slot_key: "weapon".to_string(),
|
|
..build_weapon_item("invslot_weapon", "逐风短剑")
|
|
},
|
|
InventorySlotSnapshot {
|
|
slot_id: "invslot_potion".to_string(),
|
|
runtime_session_id: "runtime_001".to_string(),
|
|
story_session_id: Some("storysess_001".to_string()),
|
|
actor_user_id: "user_001".to_string(),
|
|
container_kind: InventoryContainerKind::Backpack,
|
|
slot_key: "invslot_potion".to_string(),
|
|
item_id: "consumable_heal_potion".to_string(),
|
|
category: "消耗品".to_string(),
|
|
name: "疗伤药".to_string(),
|
|
description: Some("用于恢复少量气血。".to_string()),
|
|
quantity: 2,
|
|
rarity: InventoryItemRarity::Common,
|
|
tags: vec!["healing".to_string()],
|
|
stackable: true,
|
|
stack_key: "heal_potion".to_string(),
|
|
equipment_slot_id: None,
|
|
source_kind: InventoryItemSourceKind::TreasureReward,
|
|
source_reference_id: Some("treasure_001".to_string()),
|
|
created_at_micros: 1,
|
|
updated_at_micros: 2,
|
|
},
|
|
],
|
|
);
|
|
|
|
assert_eq!(snapshot.backpack_items.len(), 1);
|
|
assert_eq!(snapshot.equipment_items.len(), 1);
|
|
assert_eq!(snapshot.backpack_items[0].slot_id, "invslot_potion");
|
|
assert_eq!(snapshot.equipment_items[0].slot_id, "invslot_weapon");
|
|
}
|
|
}
|