Browse Source

convert item pickup to new itemtransaction model

pull/80/head
jake 3 years ago
parent
commit
8e82d6c4b4
  1. 243
      src/ship/items/manager.rs

243
src/ship/items/manager.rs

@ -1,10 +1,10 @@
use crate::ship::items::ClientItemId;
use std::collections::HashMap;
use thiserror::Error;
use crate::entity::gateway::EntityGateway;
use crate::entity::gateway::{EntityGateway, GatewayError};
use crate::entity::character::{CharacterEntity, CharacterEntityId, TechLevel};
use crate::entity::item::{ItemDetail, ItemLocation, BankName};
use crate::entity::item::{Meseta, NewItemEntity, ItemEntity, InventoryItemEntity, BankItemEntity};
use crate::entity::item::{Meseta, NewItemEntity, ItemEntity, ItemEntityId, InventoryItemEntity, BankItemEntity};
use crate::entity::item::tool::{Tool, ToolType};
use crate::entity::item::weapon;
use crate::ship::map::MapArea;
@ -17,6 +17,7 @@ use crate::ship::items::bank::*;
use crate::ship::items::floor::*;
use crate::ship::items::inventory::*;
use crate::ship::items::use_tool;
use crate::ship::items::transaction::{ItemTransaction, ItemAction, TransactionError, TransactionCommitError};
#[derive(PartialEq, Eq)]
pub enum FloorType {
@ -35,6 +36,7 @@ pub enum ItemManagerError {
EntityGatewayError,
NoSuchItemId(ClientItemId),
NoCharacter(CharacterEntityId),
NoRoom(RoomId),
CouldNotAddToInventory(ClientItemId),
//ItemBelongsToOtherPlayer,
Idunnoman,
@ -53,10 +55,36 @@ pub enum ItemManagerError {
CannotGetIndividualItem,
InvalidSlot(u8, u8), // slots available, slot attempted
NoArmorEquipped,
GatewayError(#[from] crate::entity::gateway::GatewayError),
GatewayError(#[from] GatewayError),
StackedItemError(Vec<ItemEntity>),
ItemTransactionAction(Box<dyn std::error::Error + Send + Sync>),
InvalidTrade,
}
impl<E> std::convert::From<TransactionError<E>> for ItemManagerError
where
E: std::fmt::Debug + std::marker::Send + std::marker::Sync + std::error::Error + 'static,
{
fn from(other: TransactionError<E>) -> ItemManagerError {
match other {
TransactionError::Action(err) => {
ItemManagerError::ItemTransactionAction(Box::new(err))
},
TransactionError::Commit(err) => {
match err {
TransactionCommitError::Gateway(gw) => {
ItemManagerError::GatewayError(gw)
},
TransactionCommitError::ItemManager(im) => {
im
}
}
}
}
}
}
pub struct ItemManager {
pub(super) id_counter: u32,
@ -225,80 +253,88 @@ impl ItemManager {
pub async fn character_picks_up_item<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &mut CharacterEntity, item_id: ClientItemId)
-> Result<TriggerCreateItem, anyhow::Error> {
let local_floor = self.character_floor.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let inventory = self.character_inventory.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let room_id = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let floor_item = local_floor.get_item_handle_by_id(item_id)
.or_else(|| {
shared_floor.get_item_handle_by_id(item_id)
})
.ok_or(ItemManagerError::NoSuchItemId(item_id))?;
let trigger_create_item = match floor_item.item() {
Some(FloorItem::Individual(individual_floor_item)) => {
let new_inventory_item = inventory.pick_up_individual_floor_item(individual_floor_item);
match new_inventory_item {
Some((new_inventory_item, _slot)) => {
entity_gateway.change_item_location(
&new_inventory_item.entity_id,
ItemLocation::Inventory {
let it = ItemTransaction::new(&self, (character, item_id))
.act(|it, (character, item_id)| -> Result<_, ItemManagerError> {
let local_floor = it.manager.character_floor.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let inventory = it.manager.character_inventory.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let room_id = it.manager.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = it.manager.room_floor.get(room_id).ok_or(ItemManagerError::NoRoom(*room_id))?;
let floor_item = match local_floor.get_item_by_id(*item_id) {
Some(floor_item) => {
it.action(Box::new(RemoveFromLocalFloor {
character_id: character.id,
}
).await?;
if new_inventory_item.mag().is_some() {
entity_gateway.change_mag_owner(&new_inventory_item.entity_id, character).await?;
}
item_id: item_id.clone()
}));
floor_item
},
None => {
return Err(ItemManagerError::CouldNotAddToInventory(item_id).into());
match shared_floor.get_item_by_id(*item_id) {
Some(floor_item) => {
it.action(Box::new(RemoveFromSharedFloor {
room_id: *room_id,
item_id: item_id.clone()
}));
floor_item
},
None => {
return Err(ItemManagerError::NoSuchItemId(item_id.clone())).into()
}
TriggerCreateItem::Yes
},
Some(FloorItem::Stacked(stacked_floor_item)) => {
let new_inventory_item = inventory.pick_up_stacked_floor_item(stacked_floor_item);
match new_inventory_item {
Some((new_inventory_item, _slot)) => {
for entity_id in &new_inventory_item.entity_ids {
entity_gateway.change_item_location(
entity_id,
ItemLocation::Inventory {
character_id: character.id,
}
).await?;
}
};
if stacked_floor_item.count() != new_inventory_item.count() {
TriggerCreateItem::No
let create_trigger = match floor_item {
FloorItem::Individual(individual_floor_item) => {
if inventory.space_for_individual_item() {
it.action(Box::new(AddIndividualFloorItemToInventory {
character: (**character).clone(),
item: individual_floor_item.clone()
}))
}
else {
TriggerCreateItem::Yes
return Err(ItemManagerError::CouldNotAddToInventory(*item_id).into());
}
TriggerCreateItem::Yes
},
FloorItem::Stacked(stacked_floor_item) => {
match inventory.space_for_stacked_item(&stacked_floor_item.tool, stacked_floor_item.entity_ids.len()) {
SpaceForStack::Yes(YesThereIsSpace::NewStack) => {
it.action(Box::new(AddStackedFloorItemToInventory {
character_id: character.id,
item: stacked_floor_item.clone()
}));
TriggerCreateItem::Yes
},
SpaceForStack::Yes(YesThereIsSpace::ExistingStack) => {
it.action(Box::new(AddStackedFloorItemToInventory {
character_id: character.id,
item: stacked_floor_item.clone()
}));
TriggerCreateItem::No
},
SpaceForStack::No => {
return Err(ItemManagerError::CouldNotAddToInventory(*item_id).into());
},
None => {
return Err(ItemManagerError::CouldNotAddToInventory(item_id).into());
}
}
},
Some(FloorItem::Meseta(meseta_floor_item)) => {
FloorItem::Meseta(meseta_floor_item) => {
if character.meseta >= 999999 {
return Err(ItemManagerError::CouldNotAddToInventory(item_id).into());
return Err(ItemManagerError::CouldNotAddToInventory(*item_id).into());
}
character.meseta = std::cmp::min(character.meseta + meseta_floor_item.meseta.0, 999999);
entity_gateway.save_character(character).await?;
it.action(Box::new(AddMesetaFloorItemToInventory {
character: (**character).clone(),
item: meseta_floor_item.clone()
}));
TriggerCreateItem::No
},
None => {
return Err(ItemManagerError::CouldNotAddToInventory(item_id).into());
}
};
entity_gateway.set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?;
floor_item.remove_from_floor();
Ok(trigger_create_item)
Ok(create_trigger)
});
it.commit(self, entity_gateway)
.await
.map_err(|err| err.into())
}
pub async fn enemy_drop_item_on_local_floor<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity, item_drop: ItemDrop) -> Result<&FloorItem, anyhow::Error> {
@ -924,14 +960,93 @@ impl ItemManager {
Ok(weapon)
}
pub async fn send_items_to_other_player<EG: EntityGateway>(&mut self,
entity_gateway: &mut EG,
source_character: &CharacterEntity,
dest_character: &CharacterEntity,
items: &Vec<TradeItem>)
-> Result<(), anyhow::Error> {
struct RemoveFromLocalFloor {
character_id: CharacterEntityId,
item_id: ClientItemId,
}
#[async_trait::async_trait]
impl<EG: EntityGateway> ItemAction<EG> for RemoveFromLocalFloor {
async fn commit(&self, item_manager: &mut ItemManager, entity_gateway: &mut EG) -> Result<(), TransactionCommitError> {
let local_floor = item_manager.character_floor.get_mut(&self.character_id).ok_or(ItemManagerError::NoCharacter(self.character_id))?;
local_floor.remove_item(&self.item_id);
Ok(())
}
}
struct RemoveFromSharedFloor {
room_id: RoomId,
item_id: ClientItemId,
}
#[async_trait::async_trait]
impl<EG: EntityGateway> ItemAction<EG> for RemoveFromSharedFloor {
async fn commit(&self, item_manager: &mut ItemManager, entity_gateway: &mut EG) -> Result<(), TransactionCommitError> {
let shared_floor = item_manager.room_floor.get_mut(&self.room_id).ok_or(ItemManagerError::NoRoom(self.room_id))?;
shared_floor.remove_item(&self.item_id);
Ok(())
}
}
struct AddIndividualFloorItemToInventory{
character: CharacterEntity,
item: IndividualFloorItem,
}
#[async_trait::async_trait]
impl<EG: EntityGateway> ItemAction<EG> for AddIndividualFloorItemToInventory {
async fn commit(&self, item_manager: &mut ItemManager, entity_gateway: &mut EG) -> Result<(), TransactionCommitError> {
let inventory = item_manager.character_inventory.get_mut(&self.character.id).ok_or(ItemManagerError::NoCharacter(self.character.id))?;
let inv_item = inventory.add_individual_floor_item(&self.item);
entity_gateway.change_item_location(
&self.item.entity_id,
ItemLocation::Inventory {
character_id: self.character.id,
}
).await?;
if inv_item.mag().is_some() {
entity_gateway.change_mag_owner(&self.item.entity_id, &self.character).await?;
}
entity_gateway.set_character_inventory(&self.character.id, &inventory.as_inventory_entity(&self.character.id)).await?;
Ok(())
}
}
struct AddStackedFloorItemToInventory{
character_id: CharacterEntityId,
item: StackedFloorItem,
}
#[async_trait::async_trait]
impl<EG: EntityGateway> ItemAction<EG> for AddStackedFloorItemToInventory {
async fn commit(&self, item_manager: &mut ItemManager, entity_gateway: &mut EG) -> Result<(), TransactionCommitError> {
let inventory = item_manager.character_inventory.get_mut(&self.character_id).ok_or(ItemManagerError::NoCharacter(self.character_id))?;
inventory.add_stacked_floor_item(&self.item);
entity_gateway.set_character_inventory(&self.character_id, &inventory.as_inventory_entity(&self.character_id)).await?;
Ok(())
}
}
struct AddMesetaFloorItemToInventory{
character: CharacterEntity,
item: MesetaFloorItem,
}
#[async_trait::async_trait]
impl<EG: EntityGateway> ItemAction<EG> for AddMesetaFloorItemToInventory {
async fn commit(&self, _item_manager: &mut ItemManager, entity_gateway: &mut EG) -> Result<(), TransactionCommitError> {
let mut nchar = self.character.clone();
nchar.meseta = std::cmp::min(self.character.meseta + self.item.meseta.0, 999999);
entity_gateway.save_character(&nchar).await?;
Ok(())
}
}
Loading…
Cancel
Save