You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1244 lines
46 KiB
1244 lines
46 KiB
// TODO: replace various u32s and usizes denoting item amounts for ItemAmount(u32) for consistency
|
|
use crate::ship::items::ClientItemId;
|
|
use crate::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 crate::entity::character::{CharacterEntity, CharacterEntityId};
|
|
use crate::entity::gateway::{EntityGateway, EntityGatewayTransaction};
|
|
use crate::entity::item::{ItemDetail, NewItemEntity, TradeId, ItemModifier};
|
|
use crate::entity::item::tool::Tool;
|
|
use crate::entity::room::RoomEntityId;
|
|
use crate::ship::map::MapArea;
|
|
use crate::ship::ship::SendShipPacket;
|
|
use crate::ship::items::state::{ItemStateProxy, ItemStateError, AddItemResult, StackedItemDetail, IndividualItemDetail};
|
|
use crate::ship::items::bank::{BankItem, BankItemDetail};
|
|
use crate::ship::items::inventory::{InventoryItem, InventoryItemDetail};
|
|
use crate::ship::items::floor::{FloorItem, FloorItemDetail};
|
|
use crate::ship::items::apply_item::{apply_item, ApplyItemAction};
|
|
use crate::ship::shops::ShopItem;
|
|
use crate::ship::drops::{ItemDrop, ItemDropType};
|
|
use crate::ship::packet::builder;
|
|
use crate::ship::location::AreaClient;
|
|
use crate::ship::monster::MonsterType;
|
|
|
|
pub enum TriggerCreateItem {
|
|
Yes,
|
|
No
|
|
}
|
|
|
|
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<ParentGateway = EG> + '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<ParentGateway = EG> + 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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ClientItemId>,
|
|
) -> impl Fn((ItemStateProxy, TR), ())
|
|
-> BoxFuture<'a, Result<((ItemStateProxy, TR), ()), anyhow::Error>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<ApplyItemAction>), anyhow::Error>>
|
|
where
|
|
EG: EntityGateway + Clone + 'a,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<ParentGateway = EG> + '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<Box<dyn Future<Output=Result<((ItemStateProxy, TR), InventoryItem), anyhow::Error>> + Send + 'a>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<ParentGateway = EG> + '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<I>,
|
|
func: F,
|
|
arg: T,
|
|
) -> Result<((ItemStateProxy, TR), Vec<O>), anyhow::Error>
|
|
where
|
|
'a: 'async_recursion,
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG>,
|
|
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<I>,
|
|
func: F,
|
|
) -> impl Fn((ItemStateProxy, TR), T)
|
|
-> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec<O>), anyhow::Error>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<F>,
|
|
) -> Result<((ItemStateProxy, TR), Vec<O>), anyhow::Error>
|
|
where
|
|
'a: 'async_recursion,
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + 'a,
|
|
O: Send,
|
|
T: Send,
|
|
F: Fn((ItemStateProxy, TR), T)
|
|
-> BoxFuture<'a, Result<((ItemStateProxy, TR), O), anyhow::Error>> + Send + Sync,
|
|
I: Iterator<Item = T> + 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<O>), anyhow::Error>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<Item = T> + 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<Box<dyn Future<Output=Result<((ItemStateProxy, TR), T), anyhow::Error>> + Send + 'a>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<InventoryItem>)
|
|
-> BoxFuture<'a, Result<((ItemStateProxy, TR), Vec<InventoryItem>), anyhow::Error>> + Clone
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<ParentGateway = EG> + '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<SendShipPacket>), anyhow::Error>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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 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)?;
|
|
(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)))]
|
|
}
|
|
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<ApplyItemAction>)
|
|
-> BoxFuture<'a, Result<((ItemStateProxy, TR), CharacterEntity), anyhow::Error>>
|
|
where
|
|
EG: EntityGateway,
|
|
TR: EntityGatewayTransaction<ParentGateway = EG> + '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<ParentGateway = EG> + 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), ()))
|
|
})
|
|
}
|
|
}
|