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

lint src/ship/items/*

pull/42/head
jake 4 years ago
parent
03906a7f0a
commit
3457996afd
6 changed files with 63 additions and 75 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/ship/item_stats.rs
  2. 7
      src/ship/items/bank.rs
  3. 8
      src/ship/items/floor.rs
  4. 46
      src/ship/items/inventory.rs
  5. 63
      src/ship/items/manager.rs
  6. 2
      src/ship/ship.rs

4
src/ship/item_stats.rs
View File

@ -172,9 +172,9 @@ pub fn mag_stats() -> HashMap<MagType, MagStats> {
pub fn mag_feed_tables() -> MagFeedTables { pub fn mag_feed_tables() -> MagFeedTables {
let mag_feed_tables: BTreeMap<String, Vec<BTreeMap<String, MagFeedStats>>> = load_data_file("data/item_stats/mag_feed_table.toml"); let mag_feed_tables: BTreeMap<String, Vec<BTreeMap<String, MagFeedStats>>> = load_data_file("data/item_stats/mag_feed_table.toml");
MagFeedTables(mag_feed_tables.get("feedtable").unwrap().into_iter()
MagFeedTables(mag_feed_tables.get("feedtable").unwrap().iter()
.map(|feed_table| { .map(|feed_table| {
MagFeedTable(feed_table.into_iter()
MagFeedTable(feed_table.iter()
.map(|(tool, feed_stats)| { .map(|(tool, feed_stats)| {
(tool.parse().unwrap(), *feed_stats) (tool.parse().unwrap(), *feed_stats)
}).collect()) }).collect())

7
src/ship/items/bank.rs
View File

@ -178,13 +178,12 @@ impl CharacterBank {
self.item_id_counter = base_item_id + self.items.len() as u32 + 1; self.item_id_counter = base_item_id + self.items.len() as u32 + 1;
} }
pub fn get_item_handle_by_id<'a>(&'a mut self, item_id: ClientItemId) -> Option<BankItemHandle<'a>> {
pub fn get_item_handle_by_id(&mut self, item_id: ClientItemId) -> Option<BankItemHandle> {
let (index, _) = self.items.iter() let (index, _) = self.items.iter()
.enumerate() .enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
item.item_id() == item_id item.item_id() == item_id
})
.nth(0)?;
})?;
Some(BankItemHandle { Some(BankItemHandle {
bank: self, bank: self,
index: index, index: index,

8
src/ship/items/floor.rs
View File

@ -162,11 +162,13 @@ impl<'a> FloorItemHandle<'a> {
#[derive(Debug)] #[derive(Debug)]
pub struct RoomFloorItems(Vec<FloorItem>); pub struct RoomFloorItems(Vec<FloorItem>);
impl RoomFloorItems {
pub fn new() -> RoomFloorItems {
impl Default for RoomFloorItems {
fn default() -> RoomFloorItems {
RoomFloorItems(Vec::new()) RoomFloorItems(Vec::new())
} }
}
impl RoomFloorItems {
pub fn add_item(&mut self, item: FloorItem) { pub fn add_item(&mut self, item: FloorItem) {
self.0.push(item); self.0.push(item);
} }
@ -186,7 +188,7 @@ impl RoomFloorItems {
pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<FloorItem> { pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<FloorItem> {
self.0 self.0
.drain_filter(|i| i.item_id() == item_id) .drain_filter(|i| i.item_id() == item_id)
.nth(0)
.next()
} }
pub fn drop_individual_inventory_item(&mut self, individual_inventory_item: IndividualInventoryItem, item_drop_location: (MapArea, f32, f32, f32)) -> &IndividualFloorItem { pub fn drop_individual_inventory_item(&mut self, individual_inventory_item: IndividualInventoryItem, item_drop_location: (MapArea, f32, f32, f32)) -> &IndividualFloorItem {

46
src/ship/items/inventory.rs
View File

@ -158,12 +158,8 @@ impl InventoryItem {
// TODO: result // TODO: result
// TOOD: delete? // TOOD: delete?
pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) { pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) {
match self {
InventoryItem::Stacked(self_stacked_item) => {
if let InventoryItem::Stacked(self_stacked_item) = self {
self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids); self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids);
},
_ => {
}
} }
} }
@ -417,85 +413,80 @@ impl CharacterInventory {
self.items.len() self.items.len()
} }
pub fn get_item_handle_by_id<'a>(&'a mut self, item_id: ClientItemId) -> Option<InventoryItemHandle<'a>> {
pub fn get_item_handle_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter() let (slot, _) = self.items.iter()
.enumerate() .enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
item.item_id() == item_id item.item_id() == item_id
})
.nth(0)?;
})?;
Some(InventoryItemHandle { Some(InventoryItemHandle {
inventory: self, inventory: self,
slot: slot, slot: slot,
}) })
} }
pub fn get_equipped_mag_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_mag_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter() let (slot, _) = self.items.iter()
.enumerate() .enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item { if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Mag(_) = &individual_inventory_item.item { if let ItemDetail::Mag(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id) return self.equipped.is_equipped(&individual_inventory_item.entity_id)
} }
} }
false false
})
.nth(0)?;
})?;
Some(InventoryItemHandle { Some(InventoryItemHandle {
inventory: self, inventory: self,
slot: slot, slot: slot,
}) })
} }
pub fn get_equipped_armor_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_armor_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter() let (slot, _) = self.items.iter()
.enumerate() .enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item { if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Armor(_) = &individual_inventory_item.item { if let ItemDetail::Armor(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id) return self.equipped.is_equipped(&individual_inventory_item.entity_id)
} }
} }
false false
})
.nth(0)?;
})?;
Some(InventoryItemHandle { Some(InventoryItemHandle {
inventory: self, inventory: self,
slot: slot, slot: slot,
}) })
} }
pub fn get_equipped_shield_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_shield_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter() let (slot, _) = self.items.iter()
.enumerate() .enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item { if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Shield(_) = &individual_inventory_item.item { if let ItemDetail::Shield(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id) return self.equipped.is_equipped(&individual_inventory_item.entity_id)
} }
} }
false false
})
.nth(0)?;
})?;
Some(InventoryItemHandle { Some(InventoryItemHandle {
inventory: self, inventory: self,
slot: slot, slot: slot,
}) })
} }
pub fn get_equipped_weapon_handle<'a>(&'a mut self) -> Option<InventoryItemHandle<'a>> {
pub fn get_equipped_weapon_handle(&mut self) -> Option<InventoryItemHandle> {
let (slot, _) = self.items.iter() let (slot, _) = self.items.iter()
.enumerate() .enumerate()
.filter(|(_, item)| {
.find(|(_, item)| {
if let InventoryItem::Individual(individual_inventory_item) = item { if let InventoryItem::Individual(individual_inventory_item) = item {
if let ItemDetail::Weapon(_) = &individual_inventory_item.item { if let ItemDetail::Weapon(_) = &individual_inventory_item.item {
return self.equipped.is_equipped(&individual_inventory_item.entity_id) return self.equipped.is_equipped(&individual_inventory_item.entity_id)
} }
} }
false false
})
.nth(0)?;
})?;
Some(InventoryItemHandle { Some(InventoryItemHandle {
inventory: self, inventory: self,
slot: slot, slot: slot,
@ -504,16 +495,15 @@ impl CharacterInventory {
pub fn get_item_by_id(&self, item_id: ClientItemId) -> Option<&InventoryItem> { pub fn get_item_by_id(&self, item_id: ClientItemId) -> Option<&InventoryItem> {
self.items.iter() self.items.iter()
.filter(|item| {
.find(|item| {
item.item_id() == item_id item.item_id() == item_id
}) })
.nth(0)
} }
pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItem> { pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItem> {
self.items self.items
.drain_filter(|i| i.item_id() == item_id) .drain_filter(|i| i.item_id() == item_id)
.nth(0)
.next()
} }
pub fn add_item(&mut self, item: InventoryItem) -> Result<(), InventoryAddError> { // TODO: errors pub fn add_item(&mut self, item: InventoryItem) -> Result<(), InventoryAddError> { // TODO: errors

63
src/ship/items/manager.rs
View File

@ -71,8 +71,8 @@ pub struct ItemManager {
room_item_id_counter: HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send>>, room_item_id_counter: HashMap<RoomId, Box<dyn FnMut() -> ClientItemId + Send>>,
} }
impl ItemManager {
pub fn new() -> ItemManager {
impl Default for ItemManager {
fn default() -> ItemManager {
ItemManager { ItemManager {
id_counter: 0, id_counter: 0,
character_inventory: HashMap::new(), character_inventory: HashMap::new(),
@ -83,7 +83,9 @@ impl ItemManager {
room_item_id_counter: HashMap::new(), room_item_id_counter: HashMap::new(),
} }
} }
}
impl ItemManager {
pub fn next_global_item_id(&mut self) -> ClientItemId { pub fn next_global_item_id(&mut self) -> ClientItemId {
self.id_counter += 1; self.id_counter += 1;
ClientItemId(self.id_counter) ClientItemId(self.id_counter)
@ -110,11 +112,11 @@ impl ItemManager {
entity_ids: items.iter().map(|i| i.id).collect(), entity_ids: items.iter().map(|i| i.id).collect(),
item_id: self.next_global_item_id(), item_id: self.next_global_item_id(),
tool: items.get(0) tool: items.get(0)
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
.item .item
.clone() .clone()
.as_tool() .as_tool()
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
}) })
}, },
}) })
@ -137,11 +139,11 @@ impl ItemManager {
entity_ids: items.iter().map(|i| i.id).collect(), entity_ids: items.iter().map(|i| i.id).collect(),
item_id: self.next_global_item_id(), item_id: self.next_global_item_id(),
tool: items.get(0) tool: items.get(0)
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
.item .item
.clone() .clone()
.as_tool() .as_tool()
.ok_or(ItemManagerError::StackedItemError(items.clone()))?
.ok_or_else(|| ItemManagerError::StackedItemError(items.clone()))?
}) })
}, },
}) })
@ -160,18 +162,15 @@ impl ItemManager {
inventory.initialize_item_ids(base_inventory_id); inventory.initialize_item_ids(base_inventory_id);
let base_bank_id = ((area_client.local_client.id() as u32) << 21) | 0x20000; let base_bank_id = ((area_client.local_client.id() as u32) << 21) | 0x20000;
let default_bank = self.character_bank.get_mut(&character.id); let default_bank = self.character_bank.get_mut(&character.id);
match default_bank {
Some(default_bank) => {
if let Some(default_bank ) = default_bank {
default_bank.initialize_item_ids(base_bank_id); default_bank.initialize_item_ids(base_bank_id);
},
None => {},
} }
self.character_room.insert(character.id, room_id); self.character_room.insert(character.id, room_id);
self.character_floor.insert(character.id, RoomFloorItems::new());
self.room_floor.entry(room_id).or_insert(RoomFloorItems::new());
self.character_floor.insert(character.id, RoomFloorItems::default());
self.room_floor.entry(room_id).or_insert_with(RoomFloorItems::default);
let mut inc = 0x00810000; let mut inc = 0x00810000;
self.room_item_id_counter.entry(room_id).or_insert(Box::new(move || {
self.room_item_id_counter.entry(room_id).or_insert_with(|| Box::new(move || {
inc += 1; inc += 1;
ClientItemId(inc) ClientItemId(inc)
})); }));
@ -202,13 +201,11 @@ impl ItemManager {
pub fn remove_character_from_room(&mut self, character: &CharacterEntity) { pub fn remove_character_from_room(&mut self, character: &CharacterEntity) {
self.character_inventory.remove(&character.id); self.character_inventory.remove(&character.id);
self.character_floor.remove(&character.id); self.character_floor.remove(&character.id);
self.character_room.remove(&character.id)
.as_ref()
.map(|room| {
if self.character_room.iter().find(|(_, r)| *r == room).is_none() {
if let Some(room) = self.character_room.remove(&character.id).as_ref() {
if self.character_room.iter().any(|(_, r)| r == room) {
self.room_floor.remove(room); self.room_floor.remove(room);
} }
});
}
} }
pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<(&FloorItem, FloorType), anyhow::Error> { pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<(&FloorItem, FloorType), anyhow::Error> {
@ -220,7 +217,7 @@ impl ItemManager {
.or_else(|| { .or_else(|| {
shared_floor.get_item_by_id(item_id).map(|item| (item, FloorType::Shared)) shared_floor.get_item_by_id(item_id).map(|item| (item, FloorType::Shared))
}) })
.ok_or(ItemManagerError::NoSuchItemId(item_id).into())
.ok_or_else(|| ItemManagerError::NoSuchItemId(item_id).into())
} }
pub async fn character_picks_up_item<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &mut CharacterEntity, item_id: ClientItemId) pub async fn character_picks_up_item<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &mut CharacterEntity, item_id: ClientItemId)
@ -228,7 +225,7 @@ impl ItemManager {
let local_floor = self.character_floor.get_mut(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?; 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 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 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 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) let floor_item = local_floor.get_item_handle_by_id(item_id)
.or_else(|| { .or_else(|| {
@ -238,7 +235,7 @@ impl ItemManager {
let trigger_create_item = match floor_item.item() { let trigger_create_item = match floor_item.item() {
Some(FloorItem::Individual(individual_floor_item)) => { Some(FloorItem::Individual(individual_floor_item)) => {
let new_inventory_item = inventory.pick_up_individual_floor_item(&individual_floor_item);
let new_inventory_item = inventory.pick_up_individual_floor_item(individual_floor_item);
match new_inventory_item { match new_inventory_item {
Some((new_inventory_item, slot)) => { Some((new_inventory_item, slot)) => {
entity_gateway.change_item_location( entity_gateway.change_item_location(
@ -247,7 +244,7 @@ impl ItemManager {
character_id: character.id, character_id: character.id,
} }
).await?; ).await?;
if let Some(_) = new_inventory_item.mag() {
if new_inventory_item.mag().is_some() {
entity_gateway.change_mag_owner(&new_inventory_item.entity_id, character).await?; entity_gateway.change_mag_owner(&new_inventory_item.entity_id, character).await?;
} }
}, },
@ -258,13 +255,13 @@ impl ItemManager {
TriggerCreateItem::Yes TriggerCreateItem::Yes
}, },
Some(FloorItem::Stacked(stacked_floor_item)) => { Some(FloorItem::Stacked(stacked_floor_item)) => {
let new_inventory_item = inventory.pick_up_stacked_floor_item(&stacked_floor_item);
let new_inventory_item = inventory.pick_up_stacked_floor_item(stacked_floor_item);
match new_inventory_item { match new_inventory_item {
Some((new_inventory_item, slot)) => { Some((new_inventory_item, slot)) => {
for entity_id in &new_inventory_item.entity_ids { for entity_id in &new_inventory_item.entity_ids {
entity_gateway.change_item_location( entity_gateway.change_item_location(
&entity_id,
entity_id,
ItemLocation::Inventory { ItemLocation::Inventory {
character_id: character.id, character_id: character.id,
} }
@ -288,7 +285,7 @@ impl ItemManager {
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); character.meseta = std::cmp::min(character.meseta + meseta_floor_item.meseta.0, 999999);
entity_gateway.save_character(&character).await?;
entity_gateway.save_character(character).await?;
TriggerCreateItem::No TriggerCreateItem::No
}, },
None => { None => {
@ -381,9 +378,9 @@ impl ItemManager {
}, },
}; };
self.character_floor.entry(character.id).or_insert(RoomFloorItems::new()).add_item(floor_item);
self.character_floor.entry(character.id).or_insert_with(RoomFloorItems::default).add_item(floor_item);
// TODO: make these real errors // TODO: make these real errors
self.character_floor.get(&character.id).ok_or(ItemManagerError::Idunnoman)?.get_item_by_id(item_id).ok_or(ItemManagerError::Idunnoman.into())
self.character_floor.get(&character.id).ok_or(ItemManagerError::Idunnoman)?.get_item_by_id(item_id).ok_or_else(|| ItemManagerError::Idunnoman.into())
} }
pub async fn player_drop_item_on_shared_floor<EG: EntityGateway>(&mut self, pub async fn player_drop_item_on_shared_floor<EG: EntityGateway>(&mut self,
@ -395,7 +392,7 @@ impl ItemManager {
-> Result<(), anyhow::Error> { -> Result<(), anyhow::Error> {
let inventory = self.character_inventory.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 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 shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let dropped_inventory_item = inventory.take_item_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?; let dropped_inventory_item = inventory.take_item_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
@ -439,12 +436,12 @@ impl ItemManager {
amount: u32) amount: u32)
-> Result<FloorItem, anyhow::Error> { -> Result<FloorItem, anyhow::Error> {
let room_id = self.character_room.get(&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 shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
if character.meseta < amount { if character.meseta < amount {
return Err(ItemManagerError::CouldNotDropMeseta.into()) return Err(ItemManagerError::CouldNotDropMeseta.into())
} }
character.meseta -= amount; character.meseta -= amount;
entity_gateway.save_character(&character).await?;
entity_gateway.save_character(character).await?;
let item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?(); let item_id = self.room_item_id_counter.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?();
let floor_item = FloorItem::Meseta(MesetaFloorItem { let floor_item = FloorItem::Meseta(MesetaFloorItem {
@ -470,7 +467,7 @@ impl ItemManager {
-> Result<&StackedFloorItem, anyhow::Error> { -> Result<&StackedFloorItem, anyhow::Error> {
let inventory = self.character_inventory.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 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 shared_floor = self.room_floor.get_mut(room_id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let item_to_split = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?; let item_to_split = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
@ -594,7 +591,7 @@ impl ItemManager {
entity_gateway.set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?; entity_gateway.set_character_inventory(&character.id, &inventory.as_inventory_entity(&character.id)).await?;
entity_gateway.set_character_bank(&character.id, &bank.as_bank_entity(&character.id, &BankName("".into())), BankName("".into())).await?; entity_gateway.set_character_bank(&character.id, &bank.as_bank_entity(&character.id, &BankName("".into())), BankName("".into())).await?;
inventory.slot(inventory_item_slot).ok_or(ItemManagerError::Idunnoman.into())
inventory.slot(inventory_item_slot).ok_or_else(|| ItemManagerError::Idunnoman.into())
} }
pub async fn player_feeds_mag_item<EG: EntityGateway>(&mut self, pub async fn player_feeds_mag_item<EG: EntityGateway>(&mut self,
@ -881,7 +878,7 @@ impl ItemManager {
let sorted_inventory_items: Vec<InventoryItem> = item_ids.iter() let sorted_inventory_items: Vec<InventoryItem> = item_ids.iter()
.filter(|&client_item_id| *client_item_id < 0xFFFFFFFF) .filter(|&client_item_id| *client_item_id < 0xFFFFFFFF)
.map(|&client_item_id| inventory.get_item_by_id(ClientItemId(client_item_id))) .map(|&client_item_id| inventory.get_item_by_id(ClientItemId(client_item_id)))
.filter(|&x| x.is_some() == true)
.filter(|&x| x.is_some())
.map(|x| x.cloned().unwrap()) .map(|x| x.cloned().unwrap())
.collect(); .collect();

2
src/ship/ship.rs
View File

@ -367,7 +367,7 @@ impl<EG: EntityGateway> ShipServerStateBuilder<EG> {
clients: HashMap::new(), clients: HashMap::new(),
level_table: CharacterLevelTable::new(), level_table: CharacterLevelTable::new(),
name: self.name.unwrap_or("NAMENOTSET".into()), name: self.name.unwrap_or("NAMENOTSET".into()),
item_manager: items::ItemManager::new(),
item_manager: items::ItemManager::default(),
quests: quests::load_quests("data/quests.toml".into()).unwrap(), quests: quests::load_quests("data/quests.toml".into()).unwrap(),
ip: self.ip.unwrap_or(Ipv4Addr::new(127,0,0,1)), ip: self.ip.unwrap_or(Ipv4Addr::new(127,0,0,1)),
port: self.port.unwrap_or(SHIP_PORT), port: self.port.unwrap_or(SHIP_PORT),

Write Preview
Loading…
Cancel
Save