jake/elseware
1
0
Fork 0
Code Issues 63 Pull Requests 1 Projects Releases Wiki Activity

mostly appease clippy

Browse Source
This commit is contained in:
jake 2022-04-27 23:53:26 -06:00 committed by andy
parent 46af418adb
commit a764fe9835
6 changed files with 41 additions and 246 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/entity/gateway/entitygateway.rs
View File

@ -158,7 +158,7 @@ pub trait EntityGateway: Send + Sync {
#[async_trait::async_trait] #[async_trait::async_trait]
pub trait EntityGatewayTransaction: Send + Sync { pub trait EntityGatewayTransaction: Send + Sync {
fn gateway<'a>(&'a mut self) -> &'a mut dyn EntityGateway { fn gateway(&mut self) -> &mut dyn EntityGateway {
unimplemented!() unimplemented!()
} }

4
src/entity/gateway/inmemory.rs
View File

@ -17,7 +17,7 @@ pub struct InMemoryGatewayTransaction<'a> {
#[async_trait::async_trait] #[async_trait::async_trait]
impl<'a> EntityGatewayTransaction for InMemoryGatewayTransaction<'a> { impl<'a> EntityGatewayTransaction for InMemoryGatewayTransaction<'a> {
fn gateway<'b>(&'b mut self) -> &'b mut dyn EntityGateway { fn gateway(&mut self) -> &mut dyn EntityGateway {
&mut self.working_gateway &mut self.working_gateway
} }
@ -220,7 +220,7 @@ impl EntityGateway for InMemoryGateway {
original_gateway: self, original_gateway: self,
}); });
let (mut transaction, result) = func(transaction).await?; let (transaction, result) = func(transaction).await?;
transaction.commit().await?; transaction.commit().await?;
Ok(result) Ok(result)

6
src/entity/gateway/postgres/postgres.rs
View File

@ -25,7 +25,7 @@ pub struct PostgresTransaction<'t> {
#[async_trait::async_trait] #[async_trait::async_trait]
impl<'t> EntityGatewayTransaction for PostgresTransaction<'t> { impl<'t> EntityGatewayTransaction for PostgresTransaction<'t> {
fn gateway<'b>(&'b mut self) -> &'b mut dyn EntityGateway { fn gateway(&mut self) -> &mut dyn EntityGateway {
self self
} }
@ -573,10 +573,10 @@ impl EntityGateway for PostgresGateway {
R: Send, R: Send,
E: From<GatewayError>, E: From<GatewayError>,
{ {
let mut transaction = Box::new(PostgresTransaction { let transaction = Box::new(PostgresTransaction {
pgtransaction: self.pool.begin().await.map_err(|_| ()).unwrap() pgtransaction: self.pool.begin().await.map_err(|_| ()).unwrap()
}); });
let (mut transaction, result) = func(transaction).await.map_err(|_| ()).unwrap(); let (transaction, result) = func(transaction).await.map_err(|_| ()).unwrap();
transaction.commit().await.map_err(|_| ()).unwrap(); transaction.commit().await.map_err(|_| ()).unwrap();
Ok(result) Ok(result)
} }

1
src/lib.rs
View File

@ -3,7 +3,6 @@
#![feature(drain_filter)] #![feature(drain_filter)]
#![feature(try_blocks)] #![feature(try_blocks)]
#[macro_use]
extern crate fix_hidden_lifetime_bug; extern crate fix_hidden_lifetime_bug;

205
src/ship/items/actions.rs
View File

@ -1,43 +1,17 @@
use std::collections::HashMap;
use crate::ship::items::ClientItemId; use crate::ship::items::ClientItemId;
use crate::entity::item::{Meseta, ItemEntityId, ItemDetail, ItemEntity, ItemType, InventoryEntity, InventoryItemEntity, EquippedEntity, ItemNote}; use crate::entity::item::ItemNote;
use std::cell::{RefMut, RefCell};
use std::ops::{Deref, DerefMut};
use std::convert::{From, Into};
use std::future::Future; use std::future::Future;
use std::pin::Pin; 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};
use crate::entity::character::{CharacterEntity, CharacterEntityId, TechLevel}; use crate::entity::gateway::EntityGateway;
use crate::entity::gateway::{EntityGateway, GatewayError}; use crate::ship::items::state::{ItemState, ItemStateProxy, ItemStateAction, ItemAction, ItemStateError, FloorItem, AddItemResult};
use crate::entity::gateway::entitygateway::EntityGatewayTransaction;
use crate::entity::item::tool::{Tool, ToolType};
use crate::ship::items::state::{ItemState, ItemStateProxy, ItemStateAction, ItemAction, ItemStateError, FloorItem, InventoryItem, AddItemResult};
pub enum TriggerCreateItem {ItemAction, pub enum TriggerCreateItem {ItemAction,
Yes, Yes,
No No
} }
/*
fn take_item_from_floor(character_id: CharacterEntityId, item_id: ClientItemId)
-> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), ())
-> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction>), FloorItem), ItemStateError>> + Send + 'a>>
{
move |(mut item_state, transaction), _| {
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, transaction), item))
})
}
}
*/
fn take_item_from_floor(character_id: CharacterEntityId, item_id: ClientItemId) fn take_item_from_floor(character_id: CharacterEntityId, item_id: ClientItemId)
-> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction + 'a>), ()) -> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction + 'a>), ())
-> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction + 'a>), FloorItem), ItemStateError>> + Send + 'a>> -> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction + 'a>), FloorItem), ItemStateError>> + Send + 'a>>
@ -53,71 +27,6 @@ fn take_item_from_floor(character_id: CharacterEntityId, item_id: ClientItemId)
} }
} }
/*
fn take_item_from_floor<'a, F, Fut>(character_id: CharacterEntityId, item_id: ClientItemId) -> F
where
F: Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), ()) -> Fut,
Fut: Future<Output=Result<((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), FloorItem), ItemStateError>> + Send
//Fut: Result<impl Future<Output=((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), FloorItem)> + Send, ItemStateError>
{
async move |(mut item_state, transaction): (ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), _: ()| {
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, transaction), item))
}
}
*/
/*
fn add_floor_item_to_inventory<'a, Fut>(character: &CharacterEntity)
-> impl Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), FloorItem) -> Fut
where
Fut: Future<Output=Result<((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), TriggerCreateItem), ItemStateError>> + Send
{
let character = character.clone();
move |(mut item_state, transaction): (ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), floor_item: FloorItem| {
let character = character.clone();
async move {
let mut inventory = item_state.inventory(&character.id)?;
let character_id = character.id;
let transaction = floor_item.with_entity_id(Ok(transaction), |mut transaction: Result<_, ItemStateError>, entity_id| {
async move {
if let Ok(transaction) = &mut transaction {
transaction.gateway().add_item_note(&entity_id, ItemNote::Pickup {
character_id
}).await?;
}
transaction
}}).await?;
let mut transaction = floor_item.with_mag(Ok(transaction), |mut transaction: Result<_, ItemStateError>, entity_id, _mag| {
let character = character.clone();
async move {
if let Ok(transaction) = &mut transaction {
transaction.gateway().change_mag_owner(&entity_id, &character).await?;
}
transaction
}}).await?;
let add_result = inventory.add_floor_item(floor_item)?;
transaction.gateway().set_character_inventory(&character.id, &inventory.inventory.as_inventory_entity(&character.id)).await?;
item_state.set_inventory(inventory);
Ok(((item_state, transaction),
match add_result {
AddItemResult::NewItem => TriggerCreateItem::Yes,
AddItemResult::AddToStack => TriggerCreateItem::No,
AddItemResult::Meseta => TriggerCreateItem::No,
}))
}
}
}
*/
fn add_floor_item_to_inventory(character: &CharacterEntity) fn add_floor_item_to_inventory(character: &CharacterEntity)
-> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction + 'a>), FloorItem) -> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction + 'a>), FloorItem)
-> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction + 'a>), TriggerCreateItem), ItemStateError>> + Send + 'a>> -> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction + 'a>), TriggerCreateItem), ItemStateError>> + Send + 'a>>
@ -162,109 +71,6 @@ fn add_floor_item_to_inventory(character: &CharacterEntity)
} }
} }
/*
fn add_floor_item_to_inventory(character: &CharacterEntity)
-> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), FloorItem)
-> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction>), TriggerCreateItem), ItemStateError>> + Send + '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)?;
let character_id = character.id;
let transaction = floor_item.with_entity_id(Ok(transaction), |mut transaction: Result<_, ItemStateError>, entity_id| {
async move {
if let Ok(transaction) = &mut transaction {
transaction.gateway().add_item_note(&entity_id, ItemNote::Pickup {
character_id
}).await?;
}
transaction
}}).await?;
let mut transaction = floor_item.with_mag(Ok(transaction), |mut transaction: Result<_, ItemStateError>, entity_id, _mag| {
let character = character.clone();
async move {
if let Ok(transaction) = &mut transaction {
transaction.gateway().change_mag_owner(&entity_id, &character).await?;
}
transaction
}}).await?;
let add_result = inventory.add_floor_item(floor_item)?;
transaction.gateway().set_character_inventory(&character.id, &inventory.inventory.as_inventory_entity(&character.id)).await?;
item_state.set_inventory(inventory);
Ok(((item_state, transaction),
match add_result {
AddItemResult::NewItem => TriggerCreateItem::Yes,
AddItemResult::AddToStack => TriggerCreateItem::No,
AddItemResult::Meseta => TriggerCreateItem::No,
}))
})
}
}
*/
/*
fn take_item_from_inventory(character_id: CharacterEntityId, item_id: ClientItemId)
-> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), ())
-> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction>), InventoryItem), ItemStateError>> + Send + 'a>>
{
move |(mut item_state, transaction), _| {
Box::pin(async move {
let mut inventory = item_state.inventory(&character_id)?;
let item = inventory.take_item(&item_id);
transaction.gateway().set_character_inventory(&character_id, &inventory.inventory.as_inventory_entity(&character_id)).await?;
item_state.set_inventory(inventory);
Ok((item_state, transaction), item)
})
}
}
fn add_inventory_item_to_shared_floor(character: &CharacterEntity)
-> impl for<'a> Fn((ItemStateProxy<'a>, Box<dyn EntityGatewayTransaction>), InventoryItem)
-> Pin<Box<dyn Future<Output=Result<((ItemStateProxy, Box<dyn EntityGatewayTransaction>), ()), ItemStateError>> + Send + 'a>>
{
let character = character.clone();
move |(mut item_state, transaction), inventory_item| {
let character = character.clone();
Box::pin(async move {
})
}
}
*/
/*
pub async fn pick_up_item<'a, EG>(
item_state: &'a mut ItemState,
entity_gateway: &mut EG,
character: &CharacterEntity,
item_id: &ClientItemId)
-> Result<TriggerCreateItem, ItemStateError>
where
//'a: 'static,
EG: EntityGateway,
{
let result: Result<TriggerCreateItem, ItemStateError> = entity_gateway.with_transaction(|transaction| async move {
let item_state_proxy = ItemStateProxy::new(item_state);
let ((item_state_proxy, transaction), result) = ItemStateAction::default()
.act(take_item_from_floor(character.id, *item_id))
.act(add_floor_item_to_inventory(character))
.commit((item_state_proxy, transaction))
.await?;
item_state_proxy.commit();
Ok((transaction, result))
}).await;
Ok(result?)
}
*/
pub async fn pick_up_item<EG>( pub async fn pick_up_item<EG>(
item_state: &mut ItemState, item_state: &mut ItemState,
entity_gateway: &mut EG, entity_gateway: &mut EG,
@ -284,7 +90,7 @@ where
item_state_proxy.commit(); item_state_proxy.commit();
Ok((transaction, result)) Ok((transaction, result))
}).await; }).await;
Ok(result?) result
} }
pub async fn drop_item<EG>( pub async fn drop_item<EG>(
@ -294,7 +100,6 @@ pub async fn drop_item<EG>(
item_id: &ClientItemId) item_id: &ClientItemId)
-> Result<(), ItemStateError> -> Result<(), ItemStateError>
where where
//'a: 'static,
EG: EntityGateway, EG: EntityGateway,
{ {
/* /*

67
src/ship/items/state.rs
View File

@ -1,19 +1,13 @@
use std::collections::HashMap; use std::collections::HashMap;
use crate::ship::items::ClientItemId; use crate::ship::items::ClientItemId;
use crate::entity::item::{Meseta, ItemEntityId, ItemDetail, ItemEntity, ItemType, InventoryEntity, InventoryItemEntity, EquippedEntity, ItemNote}; use crate::entity::item::{Meseta, ItemEntityId, ItemDetail, ItemEntity, InventoryEntity, InventoryItemEntity};
use std::cell::{RefMut, RefCell};
use std::ops::{Deref, DerefMut};
use std::convert::{From, Into};
use std::future::Future; 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::ship::location::RoomId;
use crate::entity::character::{CharacterEntity, CharacterEntityId, TechLevel}; use crate::entity::character::CharacterEntityId;
use crate::entity::gateway::{EntityGateway, GatewayError}; use crate::entity::gateway::GatewayError;
use crate::entity::gateway::entitygateway::EntityGatewayTransaction; use crate::entity::gateway::entitygateway::EntityGatewayTransaction;
use crate::entity::item::tool::{Tool, ToolType}; use crate::entity::item::tool::Tool;
use crate::entity::item::mag::Mag; use crate::entity::item::mag::Mag;
use crate::ship::drops::ItemDrop; use crate::ship::drops::ItemDrop;
@ -139,6 +133,7 @@ where
O: Send + Sync, O: Send + Sync,
P::Error: Send + Sync, P::Error: Send + Sync,
{ {
#[allow(clippy::type_complexity)]
pub fn act<O2, G, GFut>(self, g: G) -> ItemActionStage<O2, ItemActionStage<O, P, F, Fut, S, E>, G, GFut, S, E> pub fn act<O2, G, GFut>(self, g: G) -> ItemActionStage<O2, ItemActionStage<O, P, F, Fut, S, E>, G, GFut, S, E>
where where
S: Send + Sync, S: Send + Sync,
@ -196,13 +191,13 @@ pub enum InventoryItemDetail {
} }
impl InventoryItemDetail { impl InventoryItemDetail {
fn stacked<'a>(&'a self) -> Option<&'a StackedItemDetail> { fn stacked(&self) -> Option<&StackedItemDetail> {
match self { match self {
InventoryItemDetail::Stacked(sitem) => Some(sitem), InventoryItemDetail::Stacked(sitem) => Some(sitem),
_ => None, _ => None,
} }
} }
fn stacked_mut <'a>(&'a mut self) -> Option<&'a mut StackedItemDetail> { fn stacked_mut(&mut self) -> Option<&mut StackedItemDetail> {
match self { match self {
InventoryItemDetail::Stacked(sitem) => Some(sitem), InventoryItemDetail::Stacked(sitem) => Some(sitem),
_ => None, _ => None,
@ -225,11 +220,11 @@ impl InventoryItem {
{ {
match &self.item { match &self.item {
InventoryItemDetail::Individual(individual_item) => { InventoryItemDetail::Individual(individual_item) => {
param = func(param, individual_item.entity_id.clone()).await; param = func(param, individual_item.entity_id).await;
}, },
InventoryItemDetail::Stacked(stacked_item) => { InventoryItemDetail::Stacked(stacked_item) => {
for entity_id in &stacked_item.entity_ids { for entity_id in &stacked_item.entity_ids {
param = func(param, entity_id.clone()).await; param = func(param, *entity_id).await;
} }
} }
} }
@ -246,7 +241,7 @@ pub enum FloorItemDetail {
} }
impl FloorItemDetail { impl FloorItemDetail {
fn stacked<'a>(&'a self) -> Option<&'a StackedItemDetail> { fn stacked(&self) -> Option<&StackedItemDetail> {
match self { match self {
FloorItemDetail::Stacked(sitem) => Some(sitem), FloorItemDetail::Stacked(sitem) => Some(sitem),
_ => None, _ => None,
@ -268,11 +263,11 @@ impl FloorItem {
{ {
match &self.item { match &self.item {
FloorItemDetail::Individual(individual_item) => { FloorItemDetail::Individual(individual_item) => {
param = func(param, individual_item.entity_id.clone()).await; param = func(param, individual_item.entity_id).await;
}, },
FloorItemDetail::Stacked(stacked_item) => { FloorItemDetail::Stacked(stacked_item) => {
for entity_id in &stacked_item.entity_ids { for entity_id in &stacked_item.entity_ids {
param = func(param, entity_id.clone()).await; param = func(param, *entity_id).await;
} }
}, },
FloorItemDetail::Meseta(_meseta) => {}, FloorItemDetail::Meseta(_meseta) => {},
@ -286,18 +281,11 @@ impl FloorItem {
F: FnMut(T, ItemEntityId, Mag) -> Fut, F: FnMut(T, ItemEntityId, Mag) -> Fut,
Fut: Future<Output=T>, Fut: Future<Output=T>,
{ {
match &self.item { if let FloorItemDetail::Individual(individual_item) = &self.item {
FloorItemDetail::Individual(individual_item) => { if let ItemDetail::Mag(mag) = &individual_item.item {
match &individual_item.item { param = func(param, individual_item.entity_id, mag.clone()).await;
ItemDetail::Mag(mag) => {
param = func(param, individual_item.entity_id.clone(), mag.clone()).await;
} }
_ => {}
} }
},
_ => {}
}
param param
} }
} }
@ -370,7 +358,7 @@ impl InventoryState {
match item.item { match item.item {
FloorItemDetail::Individual(iitem) => { FloorItemDetail::Individual(iitem) => {
if self.inventory.0.len() >= 30 { if self.inventory.0.len() >= 30 {
return Err(InventoryError::InventoryFull) Err(InventoryError::InventoryFull)
} }
else { else {
self.inventory.0.push(InventoryItem { self.inventory.0.push(InventoryItem {
@ -390,7 +378,7 @@ impl InventoryState {
match existing_stack { match existing_stack {
Some(existing_stack) => { Some(existing_stack) => {
if existing_stack.entity_ids.len() + sitem.entity_ids.len() > sitem.tool.max_stack() { if existing_stack.entity_ids.len() + sitem.entity_ids.len() > sitem.tool.max_stack() {
return Err(InventoryError::StackFull) Err(InventoryError::StackFull)
} }
else { else {
existing_stack.entity_ids.append(&mut sitem.entity_ids.clone()); existing_stack.entity_ids.append(&mut sitem.entity_ids.clone());
@ -399,7 +387,7 @@ impl InventoryState {
}, },
None => { None => {
if self.inventory.0.len() >= 30 { if self.inventory.0.len() >= 30 {
return Err(InventoryError::InventoryFull) Err(InventoryError::InventoryFull)
} }
else { else {
self.inventory.0.push(InventoryItem { self.inventory.0.push(InventoryItem {
@ -477,6 +465,7 @@ impl Default for ItemState {
} }
#[derive(Default)]
struct ProxiedItemState { struct ProxiedItemState {
character_inventory: HashMap<CharacterEntityId, Inventory>, character_inventory: HashMap<CharacterEntityId, Inventory>,
//character_bank: HashMap<CharacterEntityId, RefCell<Bank>>, //character_bank: HashMap<CharacterEntityId, RefCell<Bank>>,
@ -491,6 +480,7 @@ struct ProxiedItemState {
} }
/*
impl Default for ProxiedItemState { impl Default for ProxiedItemState {
fn default() -> Self { fn default() -> Self {
ProxiedItemState { ProxiedItemState {
@ -505,6 +495,7 @@ impl Default for ProxiedItemState {
} }
} }
} }
*/
pub struct ItemStateProxy<'a> { pub struct ItemStateProxy<'a> {
item_state: &'a mut ItemState, item_state: &'a mut ItemState,
@ -529,7 +520,7 @@ where
{ {
let existing_element = master.get(&key).ok_or_else(|| err(key))?; let existing_element = master.get(&key).ok_or_else(|| err(key))?;
Ok(proxy.entry(key) Ok(proxy.entry(key)
.or_insert(existing_element.clone()).clone()) .or_insert_with(|| existing_element.clone()).clone())
} }
@ -544,8 +535,8 @@ impl<'a> ItemStateProxy<'a> {
pub fn inventory(&mut self, character_id: &CharacterEntityId) -> Result<InventoryState, ItemStateError> { pub fn inventory(&mut self, character_id: &CharacterEntityId) -> Result<InventoryState, ItemStateError> {
Ok(InventoryState { Ok(InventoryState {
character_id: *character_id, 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))?, inventory: get_or_clone(&self.item_state.character_inventory, &mut self.proxied_state.character_inventory, *character_id, ItemStateError::NoCharacter)?,
meseta: get_or_clone(&self.item_state.character_meseta, &mut self.proxied_state.character_meseta, *character_id, |c| ItemStateError::NoCharacter(c))?, meseta: get_or_clone(&self.item_state.character_meseta, &mut self.proxied_state.character_meseta, *character_id, ItemStateError::NoCharacter)?,
}) })
} }
@ -555,16 +546,16 @@ impl<'a> ItemStateProxy<'a> {
} }
pub fn floor(&mut self, character_id: &CharacterEntityId) -> Result<FloorState, ItemStateError> { pub 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))?; let room_id = get_or_clone(&self.item_state.character_room, &mut self.proxied_state.character_room, *character_id, ItemStateError::NoCharacter)?;
Ok(FloorState { Ok(FloorState {
character_id: *character_id, 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))?, local: get_or_clone(&self.item_state.character_floor, &mut self.proxied_state.character_floor, *character_id, ItemStateError::NoCharacter)?,
shared: get_or_clone(&self.item_state.room_floor, &mut self.proxied_state.room_floor, room_id, |r| ItemStateError::NoRoom(r))?, shared: get_or_clone(&self.item_state.room_floor, &mut self.proxied_state.room_floor, room_id, ItemStateError::NoRoom)?,
}) })
} }
pub fn set_floor(&mut self, floor: FloorState) { pub 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(); let room_id = get_or_clone(&self.item_state.character_room, &mut self.proxied_state.character_room, floor.character_id, ItemStateError::NoCharacter).unwrap();
self.proxied_state.character_floor.insert(floor.character_id, floor.local); self.proxied_state.character_floor.insert(floor.character_id, floor.local);
self.proxied_state.room_floor.insert(room_id, floor.shared); self.proxied_state.room_floor.insert(room_id, floor.shared);
} }