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

lint src/ship/items/*

Browse Source
This commit is contained in:
jake 2021-06-18 14:08:23 -06:00
parent 03906a7f0a
commit 3457996afd
6 changed files with 63 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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 { impl Default for RoomFloorItems {
pub fn new() -> 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 {

48
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 { if let InventoryItem::Stacked(self_stacked_item) = self {
InventoryItem::Stacked(self_stacked_item) => { 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

69
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 { impl Default for ItemManager {
pub fn new() -> 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 { if let Some(default_bank ) = default_bank {
Some(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.character_floor.insert(character.id, RoomFloorItems::default());
self.room_floor.entry(room_id).or_insert(RoomFloorItems::new()); 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) if let Some(room) = self.character_room.remove(&character.id).as_ref() {
.as_ref() if self.character_room.iter().any(|(_, r)| r == room) {
.map(|room| { self.room_floor.remove(room);
if self.character_room.iter().find(|(_, r)| *r == room).is_none() { }
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),