4 changed files with 817 additions and 1 deletions
@ -0,0 +1,813 @@ |
|||
use std::collections::HashMap;
|
|||
use crate::ship::items::ClientItemId;
|
|||
use crate::entity::item::{Meseta, ItemEntityId, ItemDetail, ItemEntity, ItemType, InventoryEntity, InventoryItemEntity, EquippedEntity, ItemNote};
|
|||
use std::cell::{RefMut, RefCell};
|
|||
use std::ops::{Deref, DerefMut};
|
|||
use std::convert::{From, Into};
|
|||
use std::future::Future;
|
|||
use std::pin::Pin;
|
|||
use async_std::sync::{Arc, Mutex};
|
|||
use std::borrow::BorrowMut;
|
|||
|
|||
use crate::ship::location::{AreaClient, RoomId};
|
|||
use crate::entity::character::{CharacterEntity, CharacterEntityId, TechLevel};
|
|||
use crate::entity::gateway::{EntityGateway, GatewayError};
|
|||
use crate::entity::gateway::entitygateway::EntityGatewayTransaction;
|
|||
use crate::entity::item::tool::{Tool, ToolType};
|
|||
use crate::ship::drops::ItemDrop;
|
|||
|
|||
pub enum TriggerCreateItem {
|
|||
Yes,
|
|||
No
|
|||
}
|
|||
|
|||
|
|||
|
|||
#[derive(thiserror::Error, Debug)]
|
|||
enum ItemStateError {
|
|||
#[error("character {0} not found")]
|
|||
NoCharacter(CharacterEntityId),
|
|||
#[error("room {0} not found")]
|
|||
NoRoom(RoomId),
|
|||
#[error("floor item {0} not found")]
|
|||
NoFloorItem(ClientItemId),
|
|||
|
|||
#[error("inventory error {0}")]
|
|||
InventoryError(#[from] InventoryError),
|
|||
|
|||
#[error("invalid drop? {0:?} (this shouldn't occur)")]
|
|||
BadItemDrop(ItemDrop),
|
|||
|
|||
#[error("idk")]
|
|||
Dummy,
|
|||
|
|||
#[error("gateway")]
|
|||
GatewayError(GatewayError),
|
|||
}
|
|||
|
|||
impl From<GatewayError> for ItemStateError {
|
|||
fn from(other: GatewayError) -> ItemStateError {
|
|||
ItemStateError::GatewayError(other)
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
|
|||
enum GatewayActions {
|
|||
ItemNote(ItemEntityId, ItemNote),
|
|||
}
|
|||
|
|||
/*
|
|||
enum ItemStateChange {
|
|||
Inventory(CharacterInventory),
|
|||
Bank(CharacterBank),
|
|||
CharacterMeseta(CharacterMeseta),
|
|||
BankMeseta(BankMeseta),
|
|||
SharedFloor(SharedFloor),
|
|||
LocalFloor(LocalFloor),
|
|||
}
|
|||
*/
|
|||
|
|||
#[async_trait::async_trait]
|
|||
trait ItemAction {
|
|||
type Input;
|
|||
type Output;
|
|||
type Start;
|
|||
type Error;
|
|||
|
|||
async fn action(&self, s: Self::Start, i: Self::Input) -> Result<(Self::Start, Self::Output), Self::Error>;
|
|||
async fn commit(&self, v: Self::Start) -> Result<(Self::Start, Self::Output), Self::Error>;
|
|||
}
|
|||
|
|||
|
|||
struct ItemStateAction<T, S, E> {
|
|||
_t: std::marker::PhantomData<T>,
|
|||
_s: std::marker::PhantomData<S>,
|
|||
_e: std::marker::PhantomData<E>,
|
|||
}
|
|||
|
|||
impl<T, S, E> Default for ItemStateAction<T, S, E> {
|
|||
fn default() -> ItemStateAction<T, S, E> {
|
|||
ItemStateAction {
|
|||
_t: std::marker::PhantomData,
|
|||
_s: std::marker::PhantomData,
|
|||
_e: std::marker::PhantomData,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
impl<T, S, E> ItemStateAction<T, S, E>
|
|||
where
|
|||
T: Send + Sync,
|
|||
S: Send + Sync,
|
|||
E: Send + Sync,
|
|||
{
|
|||
fn act<O, F>(self, f: F) -> ItemActionStage<O, ItemStateAction<T, S, E>, F, S, E>
|
|||
where
|
|||
F: Fn(S, ()) -> Pin<Box<dyn Future<Output=Result<(S, O), E>> + Send>> + Send + Sync
|
|||
{
|
|||
ItemActionStage {
|
|||
_s: Default::default(),
|
|||
_e: std::marker::PhantomData,
|
|||
prev: self,
|
|||
actionf: f,
|
|||
//actionf: |s, t| f(s, ()),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
struct ItemActionStage<O, P, F, S, E>
|
|||
where
|
|||
P: ItemAction,
|
|||
//F: Fn(&mut S, P::Output) -> Result<O, E> + for<'r> std::ops::Fn<(&'r mut S, T)>,
|
|||
F: Fn(S, P::Output) -> Pin<Box<dyn Future<Output=Result<(S, O) , E>> + Send>> + Send + Sync,
|
|||
{
|
|||
_s: std::marker::PhantomData<S>,
|
|||
_e: std::marker::PhantomData<E>,
|
|||
prev: P,
|
|||
actionf: F,
|
|||
}
|
|||
|
|||
#[async_trait::async_trait]
|
|||
impl<O, P: ItemAction, F, S, E> ItemAction for ItemActionStage<O, P, F, S, E>
|
|||
where
|
|||
P: ItemAction + ItemAction<Start = S, Error = E> + Send + Sync,
|
|||
F: Fn(S, P::Output) -> Pin<Box<dyn Future<Output=Result<(S, O), E>> + Send>> + Send + Sync,
|
|||
S: Send + Sync,
|
|||
P::Output: Send + Sync,
|
|||
E: Send + Sync,
|
|||
O: Send + Sync,
|
|||
P::Error: Send + Sync,
|
|||
{
|
|||
type Input = P::Output;
|
|||
type Output = O;
|
|||
type Start = S;
|
|||
type Error = P::Error;
|
|||
|
|||
async fn action(&self, s: Self::Start, i: Self::Input) -> Result<(Self::Start, Self::Output), Self::Error> {
|
|||
(self.actionf)(s, i).await
|
|||
}
|
|||
|
|||
async fn commit(&self, i: Self::Start) -> Result<(Self::Start, Self::Output), Self::Error> {
|
|||
let (i, prev) = self.prev.commit(i).await?;
|
|||
self.action(i, prev).await
|
|||
}
|
|||
}
|
|||
|
|||
impl<O, P: ItemAction, F, S, E> ItemActionStage<O, P, F, S, E>
|
|||
where
|
|||
P: ItemAction<Start = S, Error = E> + Send + Sync,
|
|||
F: Fn(S, P::Output) -> Pin<Box<dyn Future<Output=Result<(S, O), E>> + Send>> + Send + Sync,
|
|||
S: Send + Sync,
|
|||
P::Output: Send + Sync,
|
|||
E: Send + Sync,
|
|||
O: Send + Sync,
|
|||
P::Error: Send + Sync,
|
|||
{
|
|||
fn act<O2, G>(self, g: G) -> ItemActionStage<O2, ItemActionStage<O, P, F, S, E>, G, S, E>
|
|||
where
|
|||
S: Send + Sync,
|
|||
G: Fn(S, <ItemActionStage<O, P, F, S, E> as ItemAction>::Output) -> Pin<Box<dyn Future<Output=Result<(S, O2), E>> + Send>> + Send + Sync,
|
|||
O2: Send + Sync,
|
|||
{
|
|||
ItemActionStage {
|
|||
_s: Default::default(),
|
|||
_e: Default::default(),
|
|||
prev: self,
|
|||
actionf: g,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[async_trait::async_trait]
|
|||
impl<T, S, E> ItemAction for ItemStateAction<T, S, E>
|
|||
where
|
|||
T: Send + Sync,
|
|||
S: Send + Sync,
|
|||
E: Send + Sync,
|
|||
{
|
|||
type Input = T;
|
|||
type Output = ();
|
|||
type Start = T;
|
|||
type Error = E;
|
|||
|
|||
async fn action(&self, s: Self::Start, i: Self::Input) -> Result<(Self::Start, Self::Output), Self::Error> {
|
|||
Ok((s, ()))
|
|||
}
|
|||
|
|||
async fn commit(&self, i: Self::Start) -> Result<(Self::Start, Self::Output), Self::Error> {
|
|||
Ok((i, ()))
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Clone)]
|
|||
struct IndividualItemDetail {
|
|||
entity_id: ItemEntityId,
|
|||
item: ItemDetail,
|
|||
}
|
|||
|
|||
#[derive(Clone)]
|
|||
pub struct StackedItemDetail {
|
|||
pub entity_ids: Vec<ItemEntityId>,
|
|||
pub tool: Tool,
|
|||
}
|
|||
|
|||
#[derive(Clone)]
|
|||
enum InventoryItemDetail {
|
|||
Individual(IndividualItemDetail),
|
|||
Stacked(StackedItemDetail),
|
|||
}
|
|||
|
|||
impl InventoryItemDetail {
|
|||
fn stacked<'a>(&'a self) -> Option<&'a StackedItemDetail> {
|
|||
match self {
|
|||
InventoryItemDetail::Stacked(sitem) => Some(sitem),
|
|||
_ => None,
|
|||
}
|
|||
}
|
|||
fn stacked_mut <'a>(&'a mut self) -> Option<&'a mut StackedItemDetail> {
|
|||
match self {
|
|||
InventoryItemDetail::Stacked(sitem) => Some(sitem),
|
|||
_ => None,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
#[derive(Clone)]
|
|||
struct InventoryItem {
|
|||
item_id: ClientItemId,
|
|||
item: InventoryItemDetail,
|
|||
}
|
|||
|
|||
#[derive(Clone)]
|
|||
enum FloorItemDetail {
|
|||
Individual(IndividualItemDetail),
|
|||
Stacked(StackedItemDetail),
|
|||
Meseta(Meseta),
|
|||
}
|
|||
|
|||
impl FloorItemDetail {
|
|||
fn stacked<'a>(&'a self) -> Option<&'a StackedItemDetail> {
|
|||
match self {
|
|||
FloorItemDetail::Stacked(sitem) => Some(sitem),
|
|||
_ => None,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
#[derive(Clone)]
|
|||
struct FloorItem {
|
|||
item_id: ClientItemId,
|
|||
item: FloorItemDetail,
|
|||
}
|
|||
|
|||
// meseta is a floor item
|
|||
/*
|
|||
impl Into<InventoryItem> for FloorItem {
|
|||
fn into(&self) -> InventoryItem {
|
|||
InventoryItem {
|
|||
item_id: self.item_id,
|
|||
item: |
|||
}
|
|||
}
|
|||
}
|
|||
*/
|
|||
|
|||
#[derive(Clone)]
|
|||
struct Inventory(Vec<InventoryItem>);
|
|||
|
|||
|
|||
#[derive(thiserror::Error, Debug)]
|
|||
enum InventoryError {
|
|||
#[error("inventory full")]
|
|||
InventoryFull,
|
|||
#[error("stack full")]
|
|||
StackFull,
|
|||
#[error("meseta full")]
|
|||
MesetaFull,
|
|||
}
|
|||
|
|||
enum AddItemResult {
|
|||
NewItem,
|
|||
AddToStack,
|
|||
Meseta,
|
|||
}
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
#[derive(Clone)]
|
|||
struct LocalFloor(Vec<FloorItem>);
|
|||
#[derive(Clone)]
|
|||
struct SharedFloor(Vec<FloorItem>);
|
|||
#[derive(Clone)]
|
|||
struct RoomFloorItems(Vec<FloorItem>);
|
|||
|
|||
struct InventoryState {
|
|||
character_id: CharacterEntityId,
|
|||
inventory: Inventory,
|
|||
meseta: Meseta,
|
|||
}
|
|||
|
|||
|
|||
/*
|
|||
impl Deref for InventoryState {
|
|||
type Target = Inventory;
|
|||
|
|||
fn deref(&self) -> &Self::Target {
|
|||
&self.inventory
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
impl DerefMut for InventoryState {
|
|||
fn deref_mut(&mut self) -> &mut Self::Target {
|
|||
&mut self.inventory
|
|||
}
|
|||
}
|
|||
*/
|
|||
|
|||
impl InventoryState {
|
|||
fn add_floor_item(&mut self, item: FloorItem) -> Result<AddItemResult, InventoryError> {
|
|||
match item.item {
|
|||
FloorItemDetail::Individual(iitem) => {
|
|||
if self.inventory.0.len() >= 30 {
|
|||
return Err(InventoryError::InventoryFull)
|
|||
}
|
|||
else {
|
|||
self.inventory.0.push(InventoryItem {
|
|||
item_id: item.item_id,
|
|||
item: InventoryItemDetail::Individual(iitem)
|
|||
});
|
|||
Ok(AddItemResult::NewItem)
|
|||
}
|
|||
},
|
|||
FloorItemDetail::Stacked(sitem) => {
|
|||
let existing_stack = self.inventory.0
|
|||
.iter_mut()
|
|||
.filter_map(|item| item.item.stacked_mut())
|
|||
.find(|item| {
|
|||
item.tool == sitem.tool
|
|||
});
|
|||
match existing_stack {
|
|||
Some(existing_stack) => {
|
|||
if existing_stack.entity_ids.len() + sitem.entity_ids.len() > sitem.tool.max_stack() {
|
|||
return Err(InventoryError::StackFull)
|
|||
}
|
|||
else {
|
|||
existing_stack.entity_ids.append(&mut sitem.entity_ids.clone());
|
|||
Ok(AddItemResult::AddToStack)
|
|||
}
|
|||
},
|
|||
None => {
|
|||
if self.inventory.0.len() >= 30 {
|
|||
return Err(InventoryError::InventoryFull)
|
|||
}
|
|||
else {
|
|||
self.inventory.0.push(InventoryItem {
|
|||
item_id: item.item_id,
|
|||
item: InventoryItemDetail::Stacked(sitem)
|
|||
});
|
|||
Ok(AddItemResult::NewItem)
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
},
|
|||
FloorItemDetail::Meseta(meseta) => {
|
|||
if self.meseta == Meseta(999999) {
|
|||
Err(InventoryError::MesetaFull)
|
|||
}
|
|||
else {
|
|||
self.meseta.0 = std::cmp::min(self.meseta.0 + meseta.0 ,999999);
|
|||
Ok(AddItemResult::Meseta)
|
|||
}
|
|||
},
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
struct FloorState {
|
|||
character_id: CharacterEntityId,
|
|||
local: LocalFloor,
|
|||
shared: SharedFloor,
|
|||
}
|
|||
|
|||
impl FloorState {
|
|||
fn take_item(&mut self, item_id: &ClientItemId) -> Option<FloorItem> {
|
|||
let item = self.local.0
|
|||
.drain_filter(|item| {
|
|||
item.item_id == *item_id
|
|||
})
|
|||
.next();
|
|||
item.or_else(|| {
|
|||
self.shared.0
|
|||
.drain_filter(|item| {
|
|||
item.item_id == *item_id
|
|||
})
|
|||
.next()
|
|||
})
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
struct ItemState {
|
|||
character_inventory: HashMap<CharacterEntityId, Inventory>,
|
|||
//character_bank: HashMap<CharacterEntityId, Bank>,
|
|||
character_meseta: HashMap<CharacterEntityId, Meseta>,
|
|||
//bank_meseta: HashMap<CharacterEntityId, Meseta>,
|
|||
|
|||
character_room: HashMap<CharacterEntityId, RoomId>,
|
|||
character_floor: HashMap<CharacterEntityId, LocalFloor>,
|
|||
room_floor: HashMap<RoomId, SharedFloor>,
|
|||
|
|||
//room_item_id_counter: Arc<RefCell<HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send + Sync>>>>,
|
|||
room_item_id_counter: u32,
|
|||
}
|
|||
|
|||
impl Default for ItemState {
|
|||
fn default() -> ItemState {
|
|||
ItemState {
|
|||
character_inventory: HashMap::new(),
|
|||
character_meseta: HashMap::new(),
|
|||
character_room: HashMap::new(),
|
|||
character_floor: HashMap::new(),
|
|||
room_floor: HashMap::new(),
|
|||
room_item_id_counter: 0x00810000,
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
/*
|
|||
struct ProxiedItemState {
|
|||
character_inventory: RefCell<HashMap<CharacterEntityId, RefCell<Inventory>>>,
|
|||
//character_bank: HashMap<CharacterEntityId, RefCell<Bank>>,
|
|||
//character_meseta: HashMap<CharacterEntityId, RefCell<Meseta>>,
|
|||
//bank_meseta: HashMap<CharacterEntityId, RefCell<Meseta>>,
|
|||
|
|||
character_room: RefCell<HashMap<CharacterEntityId, RefCell<RoomId>>>,
|
|||
character_floor: RefCell<HashMap<CharacterEntityId, RefCell<RoomFloorItems>>>,
|
|||
room_floor: RefCell<HashMap<RoomId, RefCell<RoomFloorItems>>>,
|
|||
|
|||
//room_item_id_counter: HashMap<RoomId, RefCell<Box<dyn FnMut() -> ClientItemId + Send>>>,
|
|||
}
|
|||
|
|||
impl Default for ProxiedItemState {
|
|||
fn default() -> Self {
|
|||
ProxiedItemState {
|
|||
character_inventory: RefCell::new(HashMap::new()),
|
|||
//character_bank: HashMap::new(),
|
|||
//character_meseta: HashMap::new(),
|
|||
//bank_meseta: HashMap::new(),
|
|||
character_floor: RefCell::new(HashMap::new()),
|
|||
character_room: RefCell::new(HashMap::new()),
|
|||
room_floor: RefCell::new(HashMap::new()),
|
|||
//room_item_id_counter: HashMap::new(),
|
|||
}
|
|||
}
|
|||
}
|
|||
*/
|
|||
|
|||
struct ProxiedItemState {
|
|||
character_inventory: HashMap<CharacterEntityId, Inventory>,
|
|||
//character_bank: HashMap<CharacterEntityId, RefCell<Bank>>,
|
|||
character_meseta: HashMap<CharacterEntityId, Meseta>,
|
|||
//bank_meseta: HashMap<CharacterEntityId, RefCell<Meseta>>,
|
|||
|
|||
character_room: HashMap<CharacterEntityId, RoomId>,
|
|||
character_floor: HashMap<CharacterEntityId, LocalFloor>,
|
|||
room_floor: HashMap<RoomId, SharedFloor>,
|
|||
|
|||
//room_item_id_counter: HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send>>,
|
|||
|
|||
}
|
|||
|
|||
impl Default for ProxiedItemState {
|
|||
fn default() -> Self {
|
|||
ProxiedItemState {
|
|||
character_inventory: HashMap::new(),
|
|||
//character_bank: HashMap::new(),
|
|||
character_meseta: HashMap::new(),
|
|||
//bank_meseta: HashMap::new(),
|
|||
character_floor: HashMap::new(),
|
|||
character_room: HashMap::new(),
|
|||
room_floor: HashMap::new(),
|
|||
//room_item_id_counter: HashMap::new(),
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
struct ItemStateProxy<'a> {
|
|||
item_state: &'a mut ItemState,
|
|||
//entity_gateway: &'a mut dyn EntityGateway,
|
|||
transaction: Box<dyn EntityGatewayTransaction>,
|
|||
//entity_gateway: &'a mut Box<dyn EntityGateway>,
|
|||
//entity_gateway: &'a mut Box<dyn EntityGateway>,
|
|||
proxied_state: ProxiedItemState,
|
|||
|
|||
gateway_actions: Vec<GatewayActions>,
|
|||
|
|||
//_eg: std::marker::PhantomData<EG>,
|
|||
}
|
|||
|
|||
/*
|
|||
fn get_or_clone<'a, K, V>(master: &HashMap<K, V>, proxy: &'a RefCell<HashMap<K, RefCell<V>>>, key: K, err: fn(K) -> ItemStateError) -> Result<impl Deref<Target = V> + 'a, ItemStateError>
|
|||
where
|
|||
K: Eq + std::hash::Hash + Copy,
|
|||
V: Clone |
|||
{
|
|||
let existing_element = master.get(&key).ok_or_else(|| err(key))?;
|
|||
Ok(proxy.borrow_mut().entry(key)
|
|||
.or_insert(RefCell::new(existing_element.clone()))
|
|||
.borrow_mut())
|
|||
|
|||
}
|
|||
*/
|
|||
|
|||
|
|||
/*
|
|||
fn get_or_clone<'a, K, V>(master: &HashMap<K, V>, proxy: &'a mut HashMap<K, RefCell<V>>, key: K, err: fn(K) -> ItemStateError) -> Result<impl Deref<Target = V> + 'a, ItemStateError>
|
|||
where
|
|||
K: Eq + std::hash::Hash + Copy,
|
|||
V: Clone |
|||
{
|
|||
let existing_element = master.get(&key).ok_or_else(|| err(key))?;
|
|||
Ok(proxy.entry(key)
|
|||
.or_insert(RefCell::new(existing_element.clone()))
|
|||
.borrow_mut())
|
|||
|
|||
}
|
|||
*/
|
|||
|
|||
fn get_or_clone<K, V>(master: &HashMap<K, V>, proxy: &mut HashMap<K, V>, key: K, err: fn(K) -> ItemStateError) -> Result<V, ItemStateError>
|
|||
where
|
|||
K: Eq + std::hash::Hash + Copy,
|
|||
V: Clone |
|||
{
|
|||
let existing_element = master.get(&key).ok_or_else(|| err(key))?;
|
|||
Ok(proxy.entry(key)
|
|||
.or_insert(existing_element.clone()).clone())
|
|||
|
|||
}
|
|||
|
|||
impl<'a> ItemStateProxy<'a> {
|
|||
//fn new(item_state: &'a mut ItemState, entity_gateway: &'a mut EG) -> Self {
|
|||
//fn new(item_state: &'a mut ItemState, entity_gateway: &'a mut dyn EntityGateway) -> Self {
|
|||
fn new(item_state: &'a mut ItemState, transaction: Box<dyn EntityGatewayTransaction>) -> Self {
|
|||
ItemStateProxy {
|
|||
item_state,
|
|||
//entity_gateway,
|
|||
transaction,
|
|||
proxied_state: Default::default(),
|
|||
gateway_actions: Vec::new(),
|
|||
//_eg: std::marker::PhantomData,
|
|||
}
|
|||
}
|
|||
|
|||
fn inventory(&mut self, character_id: &CharacterEntityId) -> Result<InventoryState, ItemStateError> {
|
|||
Ok(InventoryState {
|
|||
character_id: *character_id,
|
|||
inventory: get_or_clone(&self.item_state.character_inventory, &mut self.proxied_state.character_inventory, *character_id, |c| ItemStateError::NoCharacter(c))?,
|
|||
meseta: get_or_clone(&self.item_state.character_meseta, &mut self.proxied_state.character_meseta, *character_id, |c| ItemStateError::NoCharacter(c))?,
|
|||
})
|
|||
}
|
|||
|
|||
fn set_inventory(&mut self, inventory: InventoryState) {
|
|||
self.proxied_state.character_inventory.insert(inventory.character_id, inventory.inventory);
|
|||
self.proxied_state.character_meseta.insert(inventory.character_id, inventory.meseta);
|
|||
}
|
|||
|
|||
fn floor(&mut self, character_id: &CharacterEntityId) -> Result<FloorState, ItemStateError> {
|
|||
let room_id = get_or_clone(&self.item_state.character_room, &mut self.proxied_state.character_room, *character_id, |c| ItemStateError::NoCharacter(c))?;
|
|||
Ok(FloorState {
|
|||
character_id: *character_id,
|
|||
local: get_or_clone(&self.item_state.character_floor, &mut self.proxied_state.character_floor, *character_id, |c| ItemStateError::NoCharacter(c))?,
|
|||
shared: get_or_clone(&self.item_state.room_floor, &mut self.proxied_state.room_floor, room_id, |r| ItemStateError::NoRoom(r))?,
|
|||
})
|
|||
}
|
|||
|
|||
fn set_floor(&mut self, floor: FloorState) {
|
|||
let room_id = get_or_clone(&self.item_state.character_room, &mut self.proxied_state.character_room, floor.character_id, |c| ItemStateError::NoCharacter(c)).unwrap();
|
|||
self.proxied_state.character_floor.insert(floor.character_id, floor.local);
|
|||
self.proxied_state.room_floor.insert(room_id, floor.shared);
|
|||
}
|
|||
|
|||
fn new_item_id(&mut self) -> Result<ClientItemId, ItemStateError> {
|
|||
//let room_id = get_or_clone(&self.item_state.character_room, &mut self.proxied_state.character_room, *character_id, |c| ItemStateError::NoCharacter(c))?;
|
|||
self.item_state.room_item_id_counter += 1;
|
|||
Ok(ClientItemId(self.item_state.room_item_id_counter))
|
|||
/*
|
|||
self.item_state.room_item_id_counter
|
|||
.borrow_mut()
|
|||
.get_mut(&room_id)
|
|||
.ok_or(ItemStateError::NoRoom(room_id))
|
|||
.map(|f| f())
|
|||
*/
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
fn take_item_from_floor(character_id: CharacterEntityId, item_id: ClientItemId)
|
|||
-> impl for<'a> Fn(ItemStateProxy<'a>, ())
|
|||
-> Pin<Box<dyn Future<Output=Result<(ItemStateProxy, FloorItem), ItemStateError>> + Send + 'a>> {
|
|||
move |mut item_state, _| {
|
|||
Box::pin(async move {
|
|||
let mut floor = item_state.floor(&character_id)?;
|
|||
let item = floor.take_item(&item_id).ok_or(ItemStateError::NoFloorItem(item_id))?;
|
|||
item_state.set_floor(floor);
|
|||
Ok((item_state, item))
|
|||
})
|
|||
}
|
|||
}
|
|||
|
|||
fn add_floor_item_to_inventory(character_id: CharacterEntityId)
|
|||
-> impl for<'a> Fn(ItemStateProxy<'a>, FloorItem)
|
|||
-> Pin<Box<dyn Future<Output=Result<(ItemStateProxy, TriggerCreateItem), ItemStateError>> + Send + 'a>> {
|
|||
move |mut item_state, floor_item| Box::pin(async move {
|
|||
let mut inventory = item_state.inventory(&character_id)?;
|
|||
let add_result = inventory.add_floor_item(floor_item)?;
|
|||
item_state.set_inventory(inventory);
|
|||
Ok((item_state,
|
|||
match add_result {
|
|||
AddItemResult::NewItem => TriggerCreateItem::Yes,
|
|||
AddItemResult::AddToStack => TriggerCreateItem::No,
|
|||
AddItemResult::Meseta => TriggerCreateItem::No,
|
|||
}))
|
|||
})
|
|||
}
|
|||
|
|||
|
|||
//hint<R, F: FnOnce(&mut dyn EntityGateway) -> R>(f: F) -> F {f}
|
|||
|
|||
|
|||
#[fix_hidden_lifetime_bug]
|
|||
async fn pick_up_item<'a, EG>(
|
|||
item_state: &'a mut ItemState,
|
|||
//item_state: Arc<Mutex<ItemState>>,
|
|||
entity_gateway: &'a mut EG,
|
|||
character_id: &CharacterEntityId,
|
|||
item_id: &ClientItemId)
|
|||
-> Result<TriggerCreateItem, ItemStateError>
|
|||
where
|
|||
'a: 'static,
|
|||
EG: EntityGateway,
|
|||
{
|
|||
/*
|
|||
let transaction = entity_gateway.transaction().await.unwrap();
|
|||
|
|||
let item_state_proxy = ItemStateProxy::new(item_state, transaction);
|
|||
let (mut item_state_proxy, result) = ItemStateAction::default()
|
|||
.act(take_item_from_floor(*character_id, *item_id))
|
|||
.act(add_floor_item_to_inventory(*character_id))
|
|||
.commit(item_state_proxy)
|
|||
.await?;
|
|||
item_state_proxy.transaction.commit().await.unwrap();
|
|||
*/
|
|||
|
|||
//drop(item_state_proxy);
|
|||
//transaction.commit().await.unwrap();
|
|||
//item_state_proxy.entity_gateway.commit().await.unwrap();
|
|||
|
|||
let k: Result<TriggerCreateItem, ItemStateError> = entity_gateway.with_transaction(|transaction| async move {
|
|||
let item_state_proxy = ItemStateProxy::new(item_state, transaction);
|
|||
let (item_state_proxy, result) = ItemStateAction::default()
|
|||
.act(take_item_from_floor(*character_id, *item_id))
|
|||
.act(add_floor_item_to_inventory(*character_id))
|
|||
.commit(item_state_proxy)
|
|||
.await?;
|
|||
|
|||
//let u = transaction.get_user_by_id(crate::entity::account::UserAccountId(0)).await?;
|
|||
//Ok((transaction, ()))
|
|||
//drop(item_state_proxy);
|
|||
Ok((item_state_proxy.transaction, result))
|
|||
}).await;
|
|||
|
|||
/*
|
|||
//fn subaction(transaction: &mut dyn EntityGateway) -> Pin<Box<dyn Future<Output=Result<(), GatewayError>> + Send + 'static>> {
|
|||
async fn subaction(transaction: &mut dyn EntityGateway) -> Result<(), GatewayError> {
|
|||
let item_state_proxy = ItemStateProxy::new(item_state, transaction);
|
|||
|
|||
Ok(())
|
|||
}
|
|||
|
|||
//async fn action(item_state: &mut ItemState, entity_gateway: &mut EG) -> Result<(), GatewayError> {
|
|||
fn action(item_state: &mut ItemState)
|
|||
-> impl FnOnce(&mut dyn EntityGateway) -> Pin<Box<dyn Future<Output=Result<(), GatewayError>> + Send + 'static>>
|
|||
{
|
|||
/*
|
|||
|transaction| Box::pin(async move {
|
|||
Ok(())
|
|||
})
|
|||
*/
|
|||
subaction
|
|||
}
|
|||
*/
|
|||
|
|||
//let k: Result<(), GatewayError> = entity_gateway.with_transaction(action(item_state)).await;
|
|||
|
|||
//let item_state = item_state.clone();
|
|||
/*
|
|||
let k: Result<(), GatewayError> = entity_gateway.with_transaction(|transaction| async move {
|
|||
let item_state_proxy = ItemStateProxy::new(item_state, transaction);
|
|||
/*
|
|||
let item_state = item_state.clone();
|
|||
let mut s = item_state.lock().await;
|
|||
//let s = s.borrow_mut();
|
|||
let item_state_proxy = ItemStateProxy::new(&mut s, transaction);
|
|||
ItemStateAction::default()
|
|||
.act(take_item_from_floor(*character_id, *item_id))
|
|||
.act(add_floor_item_to_inventory(*character_id))
|
|||
.commit(item_state_proxy)
|
|||
.await
|
|||
*/
|
|||
Ok(())
|
|||
}).await;
|
|||
*/
|
|||
|
|||
//let mut transaction = entity_gateway.transaction().await?;
|
|||
|
|||
/*entity_gateway.with_transaction(|transaction| {
|
|||
item_state_proxy.execute(&mut transaction)?.await
|
|||
}).await?;*/
|
|||
|
|||
//Ok(result)
|
|||
Ok(TriggerCreateItem::Yes)
|
|||
//.exec_gateway(&mut entity_gateway)
|
|||
}
|
|||
|
|||
|
|||
/*
|
|||
fn record_item_drop(character_id: CharacterEntityId, item_drop: ItemDrop) -> impl Fn(&mut ItemStateProxy, ()) -> Result<(), ItemStateError> {
|
|||
move |item_state, _| {
|
|||
// how do I do this? I need EG to add_item_note but how should I kick that till later?
|
|||
// general purpose vec in item_state `misc_gateway_actions`?
|
|||
// can't quite use actions here as it relies on an ItemEntityId which at this point does not yet exist for the dropped item
|
|||
//item_state.gateway_actions.push(GatewayAction::ItemNote(item_drop.))
|
|||
Ok(())
|
|||
}
|
|||
}
|
|||
*/
|
|||
|
|||
/*
|
|||
fn map_drop_to_floor_item(character_id: CharacterEntityId, item_drop: ItemDrop) -> impl Fn(&mut ItemStateProxy, ()) -> Result<FloorItem, ItemStateError> {
|
|||
move |item_state, _| {
|
|||
match item_drop.item {
|
|||
ItemDropType::Weapon(w) => FloorItem {
|
|||
item_id: item_state.new_item_id(&character_id)?,
|
|||
item: FloorItemDetail::Individual(item_drop.item)
|
|||
},
|
|||
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::IndividualTool(t) => ItemOrMeseta::Individual(ItemDetail::Tool(t)),
|
|||
//ItemDropType::StackedTool(t, _) => ItemOrMeseta::Stacked(t),
|
|||
ItemDropType::Tool(t) if t.tool.is_stackable() => ItemOrMeseta::Stacked(t),
|
|||
ItemDropType::Tool(t) if !t.tool.is_stackable() => ItemOrMeseta::Individual(ItemDetail::Tool(t)),
|
|||
ItemDropType::Meseta(m) => ItemOrMeseta::Meseta(Meseta(m)),
|
|||
_ => unreachable!() // rust isnt smart enough to see that the conditional on tool catches everything
|
|||
}
|
|||
}
|
|||
}
|
|||
|
|||
|
|||
|
|||
fn enemy_drops_item<EG>(item_state: &mut ItemState,
|
|||
entity_gateway: &mut EG,
|
|||
character: &CharacterEntity,
|
|||
item_drop: ItemDrop)
|
|||
-> Result<FloorItem, ItemStateError>
|
|||
where
|
|||
EG: EntityGateway,
|
|||
{
|
|||
ItemStateAction::default()
|
|||
.act(record_item_drop(character.id, item_drop.clone()))
|
|||
.act(map_drop_to_floor_item(character.id, item_drop))
|
|||
.act(add_item_drop_to_floor(character.id))
|
|||
.commit(&mut ItemStateProxy::new(item_state))
|
|||
}
|
|||
*/
|
|||
|
|||
/*
|
|||
fn sell_item<EG: EntityGateway>(item_state: &mut ItemState,
|
|||
entity_gateway: &mut EG,
|
|||
character_id: &CharacterEntityId,
|
|||
item_id: &ClientItemId,
|
|||
amount: usize)
|
|||
-> Result<TriggerCreateItem, ItemStateError>
|
|||
where
|
|||
EG: EntityGateway,
|
|||
{
|
|||
ItemStateAction::default()
|
|||
.act(take_item_from_inventory(*character_id, *item_id))
|
|||
.act(sell_inventory_item(*character_id, *item_id))
|
|||
.exec_state(&mut ItemStateProxy::new(item_state))
|
|||
.exec_gateway(&mut entity_gateway)
|
|||
}
|
|||
*/
|
|||
|
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue