// TODO: replace various u32s and usizes denoting item amounts for ItemAmount(u32) for consistency use crate::ClientItemId; use entity::item::{Meseta, ItemNote}; use async_std::sync::Arc; use std::future::Future; use futures::future::BoxFuture; use std::pin::Pin; use std::iter::IntoIterator; use anyhow::Context; use libpso::packet::{ship::Message, messages::GameMessage}; use entity::character::{CharacterEntity, CharacterEntityId}; use entity::gateway::{EntityGateway, EntityGatewayTransaction}; use entity::item::{ItemDetail, NewItemEntity, TradeId, ItemModifier}; use entity::item::tool::Tool; use entity::room::RoomEntityId; use maps::area::MapArea; use crate::state::{ItemStateProxy, ItemStateError, AddItemResult, StackedItemDetail, IndividualItemDetail}; use crate::bank::{BankItem, BankItemDetail}; use crate::inventory::{InventoryItem, InventoryItemDetail}; use crate::floor::{FloorItem, FloorItemDetail}; use crate::apply_item::{apply_item, ApplyItemAction}; use shops::ShopItem; use drops::{ItemDrop, ItemDropType}; //use crate::ship::packet::builder; use location::AreaClient; use maps::monster::MonsterType; pub enum TriggerCreateItem { Yes, No } #[derive(Clone)] pub enum CreateItem { Individual(AreaClient, ClientItemId, IndividualItemDetail), Stacked(AreaClient, ClientItemId, Tool, usize), } pub(super) fn take_item_from_floor<'a, EG, TR>( character_id: CharacterEntityId, item_id: ClientItemId ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> + 'a where EG: EntityGateway + Send, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction): (ItemStateProxy, TR) , _| { Box::pin(async move { let mut floor = item_state.floor(&character_id).await?; let item = floor.take_item(&item_id).ok_or_else(|| ItemStateError::NoFloorItem(item_id))?; item_state.set_floor(floor).await; Ok(((item_state, transaction), item)) }) } } pub(super) fn add_floor_item_to_inventory<'a, EG, TR>( character: &CharacterEntity ) -> impl Fn((ItemStateProxy, TR), FloorItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), TriggerCreateItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + Clone + 'a, { let character = character.clone(); move |(mut item_state, transaction), floor_item| { let character = character.clone(); Box::pin(async move { let mut inventory = item_state.inventory(&character.id).await?; let character_id = character.id; let transaction = floor_item.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::Pickup { character_id }).await?; Ok(transaction) }}).await?; let mut transaction = floor_item.with_mag(transaction, |mut transaction, entity_id, _mag| { let character = character.clone(); async move { transaction.gateway().change_mag_owner(&entity_id, &character).await?; Ok(transaction) }}).await?; let add_result = inventory.add_floor_item(floor_item)?; transaction.gateway().set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?; transaction.gateway().set_character_meseta(&character_id, inventory.meseta).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), match add_result { AddItemResult::NewItem => TriggerCreateItem::Yes, AddItemResult::AddToStack => TriggerCreateItem::No, AddItemResult::Meseta => TriggerCreateItem::No, })) }) } } pub(super) fn remove_item_from_inventory<'a, EG, TR>( character_id: CharacterEntityId, item_id: ClientItemId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItemDetail), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; let item = inventory.remove_item(&item_id, amount) .await .ok_or_else(|| ItemStateError::NoInventoryItem(item_id)) .with_context(|| format!("{inventory:#?}"))?; transaction.gateway().set_character_inventory(&character_id, &inventory.as_inventory_entity(&character_id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), item)) }) } } pub(super) fn take_item_from_inventory<'a, EG, TR>( character_id: CharacterEntityId, item_id: ClientItemId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> where EG: EntityGateway + 'a, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; let item = inventory.take_item(&item_id, amount) .await .ok_or_else(|| ItemStateError::NoInventoryItem(item_id)) .with_context(|| format!("{inventory:#?}"))?; transaction.gateway().set_character_inventory(&character_id, &inventory.as_inventory_entity(&character_id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), item)) }) } } pub(super) fn add_inventory_item_to_shared_floor<'a, EG, TR>( character_id: CharacterEntityId, map_area: MapArea, drop_position: (f32, f32, f32), ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), inventory_item| { Box::pin(async move { let transaction = inventory_item.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::PlayerDrop { character_id, map_area, x: drop_position.0, y: drop_position.1, z: drop_position.2, }).await?; Ok(transaction) }}).await?; let mut floor = item_state.floor(&character_id).await?; let floor_item = floor.add_inventory_item(inventory_item, map_area, drop_position).clone(); item_state.set_floor(floor).await; Ok(((item_state, transaction), floor_item)) }) } } pub(super) fn take_meseta_from_inventory<'a, EG, TR>( character_id: CharacterEntityId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; inventory.remove_meseta(amount)?; transaction.gateway().set_character_meseta(&character_id, inventory.meseta).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn add_meseta_to_inventory<'a, EG, TR>( character_id: CharacterEntityId, amount: u32 ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; inventory.add_meseta(amount)?; transaction.gateway().set_character_meseta(&character_id, inventory.meseta).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn add_meseta_to_shared_floor<'a, EG, TR>( character_id: CharacterEntityId, amount: u32, map_area: MapArea, drop_position: (f32, f32) ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), _| { Box::pin(async move { let floor_item = FloorItem { item_id: item_state.new_item_id().await?, item: FloorItemDetail::Meseta(Meseta(amount)), map_area, x: drop_position.0, y: 0.0, z: drop_position.1, }; let mut floor = item_state.floor(&character_id).await?; let floor_item = floor.add_shared_item(floor_item).clone(); item_state.set_floor(floor).await; Ok(((item_state, transaction), floor_item)) }) } } pub(super) fn take_meseta_from_bank<'a, EG, TR>( character_id: CharacterEntityId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut bank = item_state.bank(&character_id).await?; bank.remove_meseta(amount)?; transaction.gateway().set_bank_meseta(&character_id, &bank.identifier, bank.meseta).await?; item_state.set_bank(bank).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn add_meseta_from_bank_to_inventory<'a, EG, TR>( character_id: CharacterEntityId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; inventory.add_meseta_no_overflow(amount)?; transaction.gateway().set_character_meseta(&character_id, inventory.meseta).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn add_meseta_to_bank<'a, EG, TR>( character_id: CharacterEntityId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut bank = item_state.bank(&character_id).await?; bank.add_meseta(amount)?; transaction.gateway().set_bank_meseta(&character_id, &bank.identifier, bank.meseta).await?; item_state.set_bank(bank).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn take_item_from_bank<'a, EG, TR>( character_id: CharacterEntityId, item_id: ClientItemId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), BankItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut bank = item_state.bank(&character_id).await?; let item = bank.take_item(&item_id, amount) .await .ok_or_else(|| ItemStateError::NoBankItem(item_id))?; transaction.gateway().set_character_bank(&character_id, &bank.as_bank_entity(), &bank.identifier).await?; item_state.set_bank(bank).await; Ok(((item_state, transaction), item)) }) } } pub(super) fn add_bank_item_to_inventory<'a, EG, TR>( character: &CharacterEntity, ) -> impl Fn((ItemStateProxy, TR), BankItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { let character = character.clone(); move |(mut item_state, transaction), bank_item| { let character = character.clone(); Box::pin(async move { let bank_identifier = item_state.bank(&character.id).await?.identifier; let mut inventory = item_state.inventory(&character.id).await?; let character_id = character.id; let transaction = bank_item.with_entity_id(transaction, |mut transaction, entity_id| { let bank_identifier = bank_identifier.clone(); async move { transaction.gateway().add_item_note(&entity_id, ItemNote::Withdraw { character_id, bank: bank_identifier, }).await?; Ok(transaction) }}).await?; let inventory_item = InventoryItem { item_id: bank_item.item_id, item: match bank_item.item { BankItemDetail::Individual(individual_item) => InventoryItemDetail::Individual(individual_item), BankItemDetail::Stacked(stacked_item) => InventoryItemDetail::Stacked(stacked_item), }, }; let mut transaction = inventory_item.with_mag(transaction, |mut transaction, entity_id, _mag| { let character = character.clone(); async move { transaction.gateway().change_mag_owner(&entity_id, &character).await?; Ok(transaction) }}).await?; inventory.add_item(inventory_item.clone())?; transaction.gateway().set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), inventory_item)) }) } } pub(super) fn add_inventory_item_to_bank<'a, EG, TR>( character_id: CharacterEntityId, ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), inventory_item| { Box::pin(async move { let mut bank = item_state.bank(&character_id).await?; let bank_identifier = bank.identifier.clone(); let mut transaction = inventory_item.with_entity_id(transaction, move |mut transaction, entity_id| { let bank_identifier = bank_identifier.clone(); async move { transaction.gateway().add_item_note(&entity_id, ItemNote::Deposit { character_id, bank: bank_identifier, }).await?; Ok(transaction) }}).await?; bank.add_inventory_item(inventory_item)?; transaction.gateway().set_character_bank(&character_id, &bank.as_bank_entity(), &bank.identifier).await?; item_state.set_bank(bank).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn equip_inventory_item<'a, EG, TR>( character_id: CharacterEntityId, item_id: ClientItemId, equip_slot: u8, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; inventory.equip(&item_id, equip_slot); transaction.gateway().set_character_equips(&character_id, &inventory.as_equipped_entity()).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn unequip_inventory_item<'a, EG, TR>( character_id: CharacterEntityId, item_id: ClientItemId, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; inventory.unequip(&item_id); transaction.gateway().set_character_equips(&character_id, &inventory.as_equipped_entity()).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn sort_inventory_items<'a, EG, TR>( character_id: CharacterEntityId, item_ids: Vec, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { let item_ids = item_ids.clone(); Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; inventory.sort(&item_ids); transaction.gateway().set_character_inventory(&character_id, &inventory.as_inventory_entity(&character_id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), ())) }) } } pub(super) fn use_consumed_item<'a, EG, TR>( character: &CharacterEntity, ) -> impl Fn((ItemStateProxy, TR), InventoryItemDetail) -> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec), anyhow::Error>> where EG: EntityGateway + Clone + 'a, TR: EntityGatewayTransaction + 'a, { let character = character.clone(); move |(mut item_state, transaction), inventory_item| { let mut character = character.clone(); Box::pin(async move { let mut transaction = inventory_item.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::Consumed { character_id: character.id, }).await?; Ok(transaction) }}).await?; let apply_item_actions = apply_item(&mut item_state, transaction.gateway(), &mut character, inventory_item).await?; Ok(((item_state, transaction), apply_item_actions)) }) } } pub(super) fn feed_mag_item<'a, EG, TR>( character: CharacterEntity, mag_item_id: ClientItemId, ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), CharacterEntity), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), tool| { let character = character.clone(); Box::pin(async move { let mut inventory = item_state.inventory(&character.id).await?; let mag_entity = inventory.get_by_client_id_mut(&mag_item_id) .ok_or_else(|| ItemStateError::InvalidItemId(mag_item_id))? .item .as_individual_mut() .ok_or_else(|| ItemStateError::NotAMag(mag_item_id))?; let mag_entity_id = mag_entity.entity_id; let mut transaction = tool.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::FedToMag { character_id: character.id, mag: mag_entity_id, }).await?; transaction.gateway().feed_mag(&mag_entity_id, &entity_id).await?; Ok(transaction) }}).await?; let food_tool = tool .item .stacked() .ok_or_else(|| ItemStateError::NotMagFood(tool.item_id))? .tool .tool; let mag_entity = mag_entity .as_mag_mut() .ok_or_else(|| ItemStateError::NotAMag(mag_item_id))?; mag_entity.feed(food_tool); transaction.gateway().set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), character)) }) } } #[allow(clippy::needless_lifetimes)] // clippy this lifetime is not needless get off my case pub(super) fn add_bought_item_to_inventory<'a, EG, TR>( character_id: CharacterEntityId, shop_item: &'a (dyn ShopItem + Send + Sync), item_id: ClientItemId, amount: u32, ) -> impl Fn((ItemStateProxy, TR), ()) -> Pin> + Send + 'a>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; let bought_item = shop_item.as_item(); let inventory_item = match bought_item { ItemDetail::Tool(tool) if tool.is_stackable() => { let mut item_entities = Vec::new(); for _ in 0..amount { let item_entity = transaction.gateway().create_item(NewItemEntity { item: ItemDetail::Tool(tool), }).await?; transaction.gateway().add_item_note(&item_entity.id, ItemNote::BoughtAtShop { character_id, }).await?; item_entities.push(item_entity); } let inventory_item = InventoryItem { item_id, item: InventoryItemDetail::Stacked(StackedItemDetail { entity_ids: item_entities.into_iter().map(|i| i.id).collect(), tool, }) }; inventory.add_item(inventory_item.clone()) .with_context(|| format!("inventory {inventory:?}\nitem {inventory_item:?}"))?.1 }, item_detail => { let item_entity = transaction.gateway().create_item(NewItemEntity { item: item_detail.clone(), }).await?; transaction.gateway().add_item_note(&item_entity.id, ItemNote::BoughtAtShop { character_id, }).await?; let inventory_item = InventoryItem { item_id, item: InventoryItemDetail::Individual(IndividualItemDetail { entity_id: item_entity.id, item: item_detail, }) }; inventory.add_item(inventory_item.clone()) .with_context(|| format!("inventory {inventory:?}\nitem {inventory_item:?}"))?.1 }, }; transaction.gateway().set_character_inventory(&character_id, &inventory.as_inventory_entity(&character_id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), inventory_item)) }) } } pub(super) fn sell_inventory_item<'a, EG, TR>( character_id: CharacterEntityId, ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), inventory_item| { Box::pin(async move { let mut inventory = item_state.inventory(&character_id).await?; let price = inventory_item.item.sell_price()?; inventory.add_meseta_no_overflow(price)?; let mut transaction = inventory_item.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::SoldToShop { character_id, }).await?; Ok(transaction) }}).await?; transaction.gateway().set_character_meseta(&character_id, inventory.meseta).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), inventory_item)) }) } } #[async_recursion::async_recursion] async fn iterate_inner<'a, EG, TR, I, O, T, F, FR>( state: (ItemStateProxy, TR), mut input: Vec, func: F, arg: T, ) -> Result<((ItemStateProxy, TR), Vec), anyhow::Error> where 'a: 'async_recursion, EG: EntityGateway, TR: EntityGatewayTransaction, I: Send, O: Send, T: Clone + Send + Sync, F: Fn(I) -> FR + Send + Sync + Clone + 'a, FR: Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), O), anyhow::Error>> + Send + Sync, { let item = match input.pop() { Some(item) => item, None => return Ok((state, Vec::new())) }; let (state, mut output) = iterate_inner(state, input, func.clone(), arg.clone()).await.unwrap(); let rfunc = func(item); let (state, result) = rfunc(state, arg.clone()).await.unwrap(); output.push(result); Ok((state, output)) } pub(super) fn iterate<'a, EG, TR, I, O, T, F, FR>( input: Vec, func: F, ) -> impl Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, O: Send, I: Send + Clone + 'static + std::fmt::Debug, T: Send + Clone + 'static + std::fmt::Debug, F: Fn(I) -> FR + Send + Sync + Clone + 'a, FR: Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), O), anyhow::Error>> + Send + Sync, T: Clone + Send + Sync, { move |(item_state, transaction), arg| { let input = input.clone(); let func = func.clone(); Box::pin(async move { let (state, result) = iterate_inner((item_state, transaction), input, func, arg.clone()).await?; Ok((state, result)) }) } } #[async_recursion::async_recursion] async fn foreach_inner<'a, EG, TR, O, T, F, I>( state: (ItemStateProxy, TR), mut input: I, func: Arc, ) -> Result<((ItemStateProxy, TR), Vec), anyhow::Error> where 'a: 'async_recursion, EG: EntityGateway, TR: EntityGatewayTransaction + 'a, O: Send, T: Send, F: Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), O), anyhow::Error>> + Send + Sync, I: Iterator + Send + Sync + 'a, { let item = match input.next() { Some(item) => item, None => return Ok((state, Vec::new())) }; let (state, mut output) = foreach_inner(state, input, func.clone()).await?; let (state, result) = func(state, item).await?; output.push(result); Ok((state, output)) } pub(super) fn foreach<'a, EG, TR, O, T, F, I>( func: F ) -> impl Fn((ItemStateProxy, TR), I) -> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, O: Send, T: Send + Clone + 'static + std::fmt::Debug, F: Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), O), anyhow::Error>> + Send + Sync + 'a, T: Send + Sync, I: IntoIterator + Send + Sync + 'a, I::IntoIter: Send + Sync, { let func = Arc::new(func); move |(item_state, transaction), items| { let func = func.clone(); let items = items.into_iter(); Box::pin(async move { let (state, result) = foreach_inner((item_state, transaction), items, func).await?; Ok((state, result)) }) } } pub(super) fn insert<'a, EG, TR, T>( element: T ) -> impl Fn((ItemStateProxy, TR), ()) -> Pin> + Send + 'a>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, T: Send + Clone + 'a, { move |state, _| { let element = element.clone(); Box::pin(async move { Ok((state, element)) }) } } pub(super) fn fork<'a, EG, TR, F1, F2, T, O1, O2>( func1: F1, func2: F2, ) -> impl Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), (O1, O2)), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, F1: Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), O1), anyhow::Error>> + Send + Sync + 'a, F2: Fn((ItemStateProxy, TR), T) -> BoxFuture<'a, Result<((ItemStateProxy, TR), O2), anyhow::Error>> + Send + Sync + 'a, T: Send + Sync + Clone + 'a, O1: Send, O2: Send, { let func1 = Arc::new(func1); let func2 = Arc::new(func2); move |(item_state, transaction), input| { let func1 = func1.clone(); let func2 = func2.clone(); Box::pin(async move { let ((item_state, transaction), result1) = func1((item_state, transaction), input.clone()).await?; let ((item_state, transaction), result2) = func2((item_state, transaction), input).await?; Ok(((item_state, transaction), (result1, result2))) }) } } pub(super) fn add_item_to_inventory<'a, EG, TR>( character: CharacterEntity, ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> + Clone where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), inventory_item| { let character = character.clone(); Box::pin(async move { let mut inventory = item_state.inventory(&character.id).await?; let mut transaction = inventory_item.with_mag(transaction, |mut transaction, entity_id, _mag| { let character = character.clone(); async move { transaction.gateway().change_mag_owner(&entity_id, &character).await?; Ok(transaction) }}).await?; inventory.add_item(inventory_item.clone())?; transaction.gateway().set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?; item_state.set_inventory(inventory).await; Ok(((item_state, transaction), inventory_item)) }) } } pub(super) fn record_trade<'a, EG, TR>( trade_id: TradeId, character_to: CharacterEntityId, character_from: CharacterEntityId, ) -> impl Fn((ItemStateProxy, TR), Vec) -> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec), anyhow::Error>> + Clone where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(item_state, mut transaction), traded_items| { Box::pin(async move { for item in &traded_items { transaction = item.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::Trade { trade_id, character_to, character_from, }).await?; Ok(transaction) }}).await?; } Ok(((item_state, transaction), traded_items)) }) } } pub(super) fn assign_new_item_id<'a, EG, TR>( ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> + Clone where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction), mut inventory_item| { Box::pin(async move { inventory_item.item_id = item_state.new_item_id().await?; Ok(((item_state, transaction), inventory_item)) }) } } pub(super) fn convert_item_drop_to_floor_item<'a, EG, TR>( item_drop: ItemDrop, ) -> impl Fn((ItemStateProxy, TR), ()) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> + Clone where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), _| { let item_drop = item_drop.clone(); Box::pin(async move { enum ItemOrMeseta { Individual(ItemDetail), Stacked(Tool), Meseta(Meseta) } let item = match item_drop.item { ItemDropType::Weapon(w) => ItemOrMeseta::Individual(ItemDetail::Weapon(w)), ItemDropType::Armor(w) => ItemOrMeseta::Individual(ItemDetail::Armor(w)), ItemDropType::Shield(w) => ItemOrMeseta::Individual(ItemDetail::Shield(w)), ItemDropType::Unit(w) => ItemOrMeseta::Individual(ItemDetail::Unit(w)), ItemDropType::TechniqueDisk(w) => ItemOrMeseta::Individual(ItemDetail::TechniqueDisk(w)), ItemDropType::Mag(w) => ItemOrMeseta::Individual(ItemDetail::Mag(w)), ItemDropType::Tool(t) => { if t.tool.is_stackable() { ItemOrMeseta::Stacked(t) } else { ItemOrMeseta::Individual(ItemDetail::Tool(t)) } }, ItemDropType::Meseta(m) => ItemOrMeseta::Meseta(Meseta(m)), }; let item_id = item_state.new_item_id().await?; let floor_item = match item { ItemOrMeseta::Individual(item_detail) => { let entity = transaction.gateway().create_item(NewItemEntity { item: item_detail.clone(), }).await?; FloorItem { item_id, item: FloorItemDetail::Individual(IndividualItemDetail { entity_id: entity.id, item: item_detail, }), map_area: item_drop.map_area, x: item_drop.x, y: item_drop.y, z: item_drop.z, } }, ItemOrMeseta::Stacked(tool) => { let entity = transaction.gateway().create_item(NewItemEntity { item: ItemDetail::Tool(tool), }).await?; FloorItem { item_id, item: FloorItemDetail::Stacked(StackedItemDetail{ entity_ids: vec![entity.id], tool, }), map_area: item_drop.map_area, x: item_drop.x, y: item_drop.y, z: item_drop.z, } }, ItemOrMeseta::Meseta(meseta) => { FloorItem { item_id, item: FloorItemDetail::Meseta(meseta), map_area: item_drop.map_area, x: item_drop.x, y: item_drop.y, z: item_drop.z, } }, }; Ok(((item_state, transaction), floor_item)) }) } } pub(super) fn item_note_enemy_drop<'a, EG, TR>( character_id: CharacterEntityId, room_id: RoomEntityId, monster_type: MonsterType, ) -> impl Fn((ItemStateProxy, TR), FloorItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> + Clone where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(item_state, mut transaction), floor_item| { Box::pin(async move { match &floor_item.item { FloorItemDetail::Individual(individual) => { transaction.gateway().add_item_note(&individual.entity_id, ItemNote::EnemyDrop { character_id, room_id, monster_type, map_area: floor_item.map_area, x: floor_item.x, y: floor_item.y, z: floor_item.z, }).await?; }, FloorItemDetail::Stacked(stacked) => { transaction.gateway().add_item_note(&stacked.entity_ids[0], ItemNote::EnemyDrop { character_id, room_id, monster_type, map_area: floor_item.map_area, x: floor_item.x, y: floor_item.y, z: floor_item.z, }).await?; }, _ => {}, } Ok(((item_state, transaction), floor_item)) }) } } pub(super) fn item_note_box_drop<'a, EG, TR>( character_id: CharacterEntityId, room_id: RoomEntityId, ) -> impl Fn((ItemStateProxy, TR), FloorItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> + Clone where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(item_state, mut transaction), floor_item| { Box::pin(async move { match &floor_item.item { FloorItemDetail::Individual(individual) => { transaction.gateway().add_item_note(&individual.entity_id, ItemNote::BoxDrop { character_id, room_id, map_area: floor_item.map_area, x: floor_item.x, y: floor_item.y, z: floor_item.z, }).await?; }, FloorItemDetail::Stacked(stacked) => { transaction.gateway().add_item_note(&stacked.entity_ids[0], ItemNote::BoxDrop { character_id, room_id, map_area: floor_item.map_area, x: floor_item.x, y: floor_item.y, z: floor_item.z, }).await?; }, _ => {}, } Ok(((item_state, transaction), floor_item)) }) } } pub(super) fn add_item_to_local_floor<'a, EG, TR>( character_id: CharacterEntityId, ) -> impl Fn((ItemStateProxy, TR), FloorItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), FloorItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, transaction) , floor_item| { Box::pin(async move { let mut floor = item_state.floor(&character_id).await?; let item = floor.add_local_item(floor_item).clone(); item_state.set_floor(floor).await; Ok(((item_state, transaction), item)) }) } } pub(super) fn apply_modifier_to_inventory_item<'a, EG, TR>( modifier: ItemModifier, ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(item_state, mut transaction), mut inventory_item| { let modifier = modifier.clone(); Box::pin(async move { match (&mut inventory_item.item, modifier) { (InventoryItemDetail::Individual(IndividualItemDetail{entity_id, item: ItemDetail::Weapon(ref mut weapon), ..}), ItemModifier::WeaponModifier(modifier)) => { weapon.apply_modifier(&modifier); transaction.gateway().add_weapon_modifier(entity_id, &modifier).await?; }, _ => return Err(ItemStateError::InvalidModifier.into()) } Ok(((item_state, transaction), inventory_item)) }) } } pub(super) fn as_individual_item<'a, EG, TR>( ) -> impl Fn((ItemStateProxy, TR), InventoryItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), IndividualItemDetail), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(item_state, transaction), inventory_item| { Box::pin(async move { let item = match inventory_item.item { InventoryItemDetail::Individual(individual_item) => individual_item, _ => return Err(ItemStateError::WrongItemType(inventory_item.item_id).into()) }; Ok(((item_state, transaction), item)) }) } } pub(super) fn apply_item_action_packets<'a, EG, TR>( character_id: CharacterEntityId, area_client: AreaClient, ) -> impl Fn((ItemStateProxy, TR), ApplyItemAction) -> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { move |(mut item_state, mut transaction), apply_item_action| { Box::pin(async move { let pkts = if let ApplyItemAction::CreateItem(item_detail) = apply_item_action { let new_item = transaction.gateway().create_item(NewItemEntity { item: item_detail.clone(), }).await?; let item_id = item_state.new_item_id().await?; let (inventory_item_detail, create_item) = if item_detail.is_stackable() { let tool = item_detail.as_tool().ok_or_else(|| ItemStateError::NotATool(ClientItemId(0xFFFFFFFF)))?; //let create_item = builder::message::create_stacked_item(area_client, item_id, &tool, 1).map_err(|_err| ItemStateError::Dummy)?; let create_item = CreateItem::Stacked(area_client, item_id, tool.clone(), 1); let item_detail = StackedItemDetail { entity_ids: vec![new_item.id], tool }; (InventoryItemDetail::Stacked(item_detail), create_item) } else { let item_detail = IndividualItemDetail { entity_id: new_item.id, item: item_detail, }; //let create_item = builder::message::create_individual_item(area_client, item_id, &item_detail).map_err(|_err| ItemStateError::Dummy)?; let create_item = CreateItem::Individual(area_client, item_id, item_detail.clone()); (InventoryItemDetail::Individual(item_detail), create_item) }; let inventory_item = InventoryItem { item_id, item: inventory_item_detail, }; let mut inventory = item_state.inventory(&character_id).await?; inventory.add_item(inventory_item)?; transaction.gateway().set_character_inventory(&character_id, &inventory.as_inventory_entity(&character_id)).await?; item_state.set_inventory(inventory).await; //vec![SendShipPacket::Message(Message::new(GameMessage::CreateItem(create_item)))] vec![create_item] } else { Vec::new() }; Ok(((item_state, transaction), pkts)) }) } } pub(super) fn apply_item_action_character<'a, EG, TR>( character: &CharacterEntity ) -> impl Fn((ItemStateProxy, TR), Vec) -> BoxFuture<'a, Result<((ItemStateProxy, TR), CharacterEntity), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + 'a, { let character = character.clone(); move |(item_state, transaction), apply_item_actions| { let mut character = character.clone(); Box::pin(async move { for action in apply_item_actions { if let ApplyItemAction::UpdateCharacter(new_character) = action { character = *new_character } } Ok(((item_state, transaction), character)) }) } } pub(super) fn delete_item_from_floor<'a, EG, TR>( map_area: MapArea ) -> impl Fn((ItemStateProxy, TR), FloorItem) -> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>> where EG: EntityGateway, TR: EntityGatewayTransaction + Clone + 'a, { move |(item_state, transaction), floor_item| { Box::pin(async move { let transaction = floor_item.with_entity_id(transaction, |mut transaction, entity_id| { async move { transaction.gateway().add_item_note(&entity_id, ItemNote::FloorLimitReached { map_area }).await?; Ok(transaction) }}).await?; Ok(((item_state, transaction), ())) }) } }