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

use anyhow for itemmanager

Browse Source
This commit is contained in:
jake 2020-11-16 21:27:03 -07:00
parent f7c6be48b2
commit a3cc29b68f
5 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -89,7 +89,7 @@ impl ItemManager {
} }
// TODO: Result // TODO: Result
pub async fn load_character<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) -> Result<(), ItemManagerError> { pub async fn load_character<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity) -> Result<(), anyhow::Error> {
let inventory = entity_gateway.get_character_inventory(&character.id).await?; let inventory = entity_gateway.get_character_inventory(&character.id).await?;
let bank = entity_gateway.get_character_bank(&character.id, BankName("".into())).await?; let bank = entity_gateway.get_character_bank(&character.id, BankName("".into())).await?;
let equipped = entity_gateway.get_character_equips(&character.id).await?; let equipped = entity_gateway.get_character_equips(&character.id).await?;
@ -176,12 +176,12 @@ impl ItemManager {
})); }));
} }
pub fn get_character_inventory(&self, character: &CharacterEntity) -> Result<&CharacterInventory, ItemManagerError> { pub fn get_character_inventory(&self, character: &CharacterEntity) -> Result<&CharacterInventory, anyhow::Error> {
Ok(self.character_inventory.get(&character.id) Ok(self.character_inventory.get(&character.id)
.ok_or(ItemManagerError::NoCharacter(character.id))?) .ok_or(ItemManagerError::NoCharacter(character.id))?)
} }
pub fn get_character_bank(&self, character: &CharacterEntity) -> Result<&CharacterBank, ItemManagerError> { pub fn get_character_bank(&self, character: &CharacterEntity) -> Result<&CharacterBank, anyhow::Error> {
Ok(self.character_bank Ok(self.character_bank
.get(&character.id) .get(&character.id)
.ok_or(ItemManagerError::NoCharacter(character.id))?) .ok_or(ItemManagerError::NoCharacter(character.id))?)
@ -210,7 +210,7 @@ impl ItemManager {
}); });
} }
pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<(&FloorItem, FloorType), ItemManagerError> { pub fn get_floor_item_by_id(&self, character: &CharacterEntity, item_id: ClientItemId) -> Result<(&FloorItem, FloorType), anyhow::Error> {
let local_floor = self.character_floor.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?; let local_floor = self.character_floor.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let room = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?; let room = self.character_room.get(&character.id).ok_or(ItemManagerError::NoCharacter(character.id))?;
let shared_floor = self.room_floor.get(room).ok_or(ItemManagerError::NoCharacter(character.id))?; let shared_floor = self.room_floor.get(room).ok_or(ItemManagerError::NoCharacter(character.id))?;
@ -219,7 +219,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)) .ok_or(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)
@ -300,7 +300,7 @@ impl ItemManager {
Ok(trigger_create_item) Ok(trigger_create_item)
} }
pub async fn enemy_drop_item_on_local_floor<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity, item_drop: ItemDrop) -> Result<&FloorItem, ItemManagerError> { pub async fn enemy_drop_item_on_local_floor<EG: EntityGateway>(&mut self, entity_gateway: &mut EG, character: &CharacterEntity, item_drop: ItemDrop) -> Result<&FloorItem, anyhow::Error> {
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))?;
enum ItemOrMeseta { enum ItemOrMeseta {
@ -382,7 +382,7 @@ impl ItemManager {
self.character_floor.entry(character.id).or_insert(RoomFloorItems::new()).add_item(floor_item); self.character_floor.entry(character.id).or_insert(RoomFloorItems::new()).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) self.character_floor.get(&character.id).ok_or(ItemManagerError::Idunnoman)?.get_item_by_id(item_id).ok_or(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,
@ -466,7 +466,7 @@ impl ItemManager {
item_id: ClientItemId, item_id: ClientItemId,
drop_location: ItemDropLocation, drop_location: ItemDropLocation,
amount: usize) amount: usize)
-> Result<&StackedFloorItem, ItemManagerError> { -> 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))?;
@ -498,7 +498,7 @@ impl ItemManager {
character: &mut CharacterEntity, character: &mut CharacterEntity,
item_id: ClientItemId, item_id: ClientItemId,
amount: usize) amount: usize)
-> Result<ConsumedItem, ItemManagerError> { -> Result<ConsumedItem, 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 used_item = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?; let used_item = inventory.get_item_handle_by_id(item_id).ok_or(ItemManagerError::NoSuchItemId(item_id))?;
let consumed_item = used_item.consume(amount)?; let consumed_item = used_item.consume(amount)?;
@ -523,7 +523,7 @@ impl ItemManager {
character: &CharacterEntity, character: &CharacterEntity,
item_id: ClientItemId, item_id: ClientItemId,
amount: usize) amount: usize)
-> Result<(), ItemManagerError> { -> 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 bank = self.character_bank let bank = self.character_bank
.get_mut(&character.id) .get_mut(&character.id)
@ -561,7 +561,7 @@ impl ItemManager {
character: &CharacterEntity, character: &CharacterEntity,
item_id: ClientItemId, item_id: ClientItemId,
amount: usize) amount: usize)
-> Result<&InventoryItem, ItemManagerError> { -> Result<&InventoryItem, 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 bank = self.character_bank let bank = self.character_bank
@ -593,7 +593,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) inventory.slot(inventory_item_slot).ok_or(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,
@ -601,7 +601,7 @@ impl ItemManager {
character: &CharacterEntity, character: &CharacterEntity,
mag_id: ClientItemId, mag_id: ClientItemId,
tool_id: ClientItemId) tool_id: ClientItemId)
-> Result<(), ItemManagerError> { -> 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 consumed_tool = { let consumed_tool = {
let item_to_feed = inventory.get_item_handle_by_id(tool_id).ok_or(ItemManagerError::NoSuchItemId(tool_id))?; let item_to_feed = inventory.get_item_handle_by_id(tool_id).ok_or(ItemManagerError::NoSuchItemId(tool_id))?;
@ -619,7 +619,7 @@ impl ItemManager {
let consumed_tool_type = match &consumed_tool { let consumed_tool_type = match &consumed_tool {
ConsumedItem::Stacked(stacked_consumed_item) => stacked_consumed_item.tool.tool, ConsumedItem::Stacked(stacked_consumed_item) => stacked_consumed_item.tool.tool,
_ => return Err(ItemManagerError::WrongItemType(tool_id)) _ => return Err(ItemManagerError::WrongItemType(tool_id).into())
}; };
mag.feed(consumed_tool_type); mag.feed(consumed_tool_type);
@ -637,7 +637,7 @@ impl ItemManager {
pub async fn use_item<EG: EntityGateway>(&mut self, pub async fn use_item<EG: EntityGateway>(&mut self,
used_item: ConsumedItem, used_item: ConsumedItem,
entity_gateway: &mut EG, entity_gateway: &mut EG,
character: &mut CharacterEntity) -> Result<(), ItemManagerError> { character: &mut CharacterEntity) -> 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))?;
match &used_item.item() { match &used_item.item() {
ItemDetail::Weapon(_w) => { ItemDetail::Weapon(_w) => {
@ -754,7 +754,7 @@ impl ItemManager {
shop_item: &(dyn ShopItem + Send + Sync), shop_item: &(dyn ShopItem + Send + Sync),
item_id: ClientItemId, item_id: ClientItemId,
amount: usize) amount: usize)
-> Result<&InventoryItem, ItemManagerError> { -> Result<&InventoryItem, 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 item_detail = shop_item.as_item(); let item_detail = shop_item.as_item();
@ -853,7 +853,7 @@ impl ItemManager {
character: &CharacterEntity, character: &CharacterEntity,
item_id: ClientItemId, item_id: ClientItemId,
equip_slot: u8) equip_slot: u8)
-> Result<(), ItemManagerError> { -> 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))?;
inventory.equip(&item_id, equip_slot); inventory.equip(&item_id, equip_slot);
entity_gateway.set_character_equips(&character.id, &inventory.as_equipped_entity()).await?; entity_gateway.set_character_equips(&character.id, &inventory.as_equipped_entity()).await?;
@ -864,7 +864,7 @@ impl ItemManager {
entity_gateway: &mut EG, entity_gateway: &mut EG,
character: &CharacterEntity, character: &CharacterEntity,
item_id: ClientItemId) item_id: ClientItemId)
-> Result<(), ItemManagerError> { -> 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))?;
inventory.unequip(&item_id); inventory.unequip(&item_id);
entity_gateway.set_character_equips(&character.id, &inventory.as_equipped_entity()).await?; entity_gateway.set_character_equips(&character.id, &inventory.as_equipped_entity()).await?;
@ -875,7 +875,7 @@ impl ItemManager {
entity_gateway: &mut EG, entity_gateway: &mut EG,
character: &CharacterEntity, character: &CharacterEntity,
item_ids: [u32; 30]) item_ids: [u32; 30])
-> Result<(), ItemManagerError> { -> 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 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)

2
src/ship/packet/handler/auth.rs
View File

@ -12,7 +12,7 @@ pub async fn validate_login<EG: EntityGateway>(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
item_manager: &mut ItemManager, item_manager: &mut ItemManager,
ship_name: &String) ship_name: &String)
-> Result<Vec<SendShipPacket>, ShipError> { -> Result<Vec<SendShipPacket>, anyhow::Error> {
Ok(match get_login_status(entity_gateway, pkt).await.and_then(check_if_already_online) { Ok(match get_login_status(entity_gateway, pkt).await.and_then(check_if_already_online) {
Ok(mut user) => { Ok(mut user) => {
user.at_ship= true; user.at_ship= true;

24
src/ship/packet/handler/direct_message.rs
View File

@ -65,7 +65,7 @@ pub async fn request_item<EG>(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
rooms: &mut Rooms, rooms: &mut Rooms,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -77,7 +77,7 @@ where
let monster = room.maps.enemy_by_id(request_item.enemy_id as usize)?; let monster = room.maps.enemy_by_id(request_item.enemy_id as usize)?;
if monster.dropped_item { if monster.dropped_item {
return Err(ShipError::MonsterAlreadyDroppedItem(id, request_item.enemy_id)) return Err(ShipError::MonsterAlreadyDroppedItem(id, request_item.enemy_id).into())
} }
let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?; let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?;
@ -114,7 +114,7 @@ pub async fn pickup_item<EG>(id: ClientId,
client_location: &ClientLocation, client_location: &ClientLocation,
clients: &mut Clients, clients: &mut Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -169,7 +169,7 @@ pub async fn request_box_item<EG>(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
rooms: &mut Rooms, rooms: &mut Rooms,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -181,7 +181,7 @@ EG: EntityGateway
let box_object = room.maps.object_by_id(box_drop_request.object_id as usize)?; let box_object = room.maps.object_by_id(box_drop_request.object_id as usize)?;
if box_object.dropped_item { if box_object.dropped_item {
return Err(ShipError::BoxAlreadyDroppedItem(id, box_drop_request.object_id)) return Err(ShipError::BoxAlreadyDroppedItem(id, box_drop_request.object_id).into())
} }
let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?; let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?;
@ -216,7 +216,7 @@ EG: EntityGateway
pub async fn send_bank_list(id: ClientId, pub async fn send_bank_list(id: ClientId,
clients: &Clients, clients: &Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
{ {
let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
let bank_items = item_manager.get_character_bank(&client.character)?; let bank_items = item_manager.get_character_bank(&client.character)?;
@ -231,7 +231,7 @@ pub async fn bank_interaction<EG>(id: ClientId,
client_location: &ClientLocation, client_location: &ClientLocation,
clients: &mut Clients, clients: &mut Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -292,7 +292,7 @@ pub async fn shop_request(id: ClientId,
rooms: &Rooms, rooms: &Rooms,
level_table: &CharacterLevelTable, level_table: &CharacterLevelTable,
shops: &mut ItemShops) shops: &mut ItemShops)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
{ {
let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?; let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
@ -317,7 +317,7 @@ pub async fn shop_request(id: ClientId,
builder::message::shop_list(shop_request.shop_type, &client.armor_shop) builder::message::shop_list(shop_request.shop_type, &client.armor_shop)
}, },
_ => { _ => {
return Err(ShipError::ShopError) return Err(ShipError::ShopError.into())
} }
}; };
@ -331,7 +331,7 @@ pub async fn buy_item<EG>(id: ClientId,
client_location: &ClientLocation, client_location: &ClientLocation,
clients: &mut Clients, clients: &mut Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -360,12 +360,12 @@ where
(item, remove) (item, remove)
}, },
_ => { _ => {
return Err(ShipError::ShopError) return Err(ShipError::ShopError.into())
} }
}; };
if client.character.meseta < item.price() as u32 { if client.character.meseta < item.price() as u32 {
return Err(ShipError::ShopError) return Err(ShipError::ShopError.into())
} }
client.character.meseta -= item.price() as u32; client.character.meseta -= item.price() as u32;

6
src/ship/packet/handler/lobby.rs
View File

@ -15,7 +15,7 @@ pub fn block_selected(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
item_manager: &ItemManager, item_manager: &ItemManager,
level_table: &CharacterLevelTable) level_table: &CharacterLevelTable)
-> Result<Vec<SendShipPacket>, ShipError> { -> Result<Vec<SendShipPacket>, anyhow::Error> {
let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
client.block = pkt.item as u32; client.block = pkt.item as u32;
@ -52,7 +52,7 @@ pub fn send_player_to_lobby(id: ClientId,
clients: &Clients, clients: &Clients,
item_manager: &ItemManager, item_manager: &ItemManager,
level_table: &CharacterLevelTable) level_table: &CharacterLevelTable)
-> Result<Vec<(ClientId, SendShipPacket)>, ShipError> { -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error> {
let lobby = client_location.add_client_to_next_available_lobby(id, LobbyId(0)).map_err(|_| ShipError::TooManyClients)?; let lobby = client_location.add_client_to_next_available_lobby(id, LobbyId(0)).map_err(|_| ShipError::TooManyClients)?;
let join_lobby = packet::builder::lobby::join_lobby(id, lobby, client_location, clients, item_manager, level_table)?; let join_lobby = packet::builder::lobby::join_lobby(id, lobby, client_location, clients, item_manager, level_table)?;
let addto = packet::builder::lobby::add_to_lobby(id, lobby, client_location, clients, item_manager, level_table)?; let addto = packet::builder::lobby::add_to_lobby(id, lobby, client_location, clients, item_manager, level_table)?;
@ -71,7 +71,7 @@ pub async fn change_lobby<EG: EntityGateway>(id: ClientId,
level_table: &CharacterLevelTable, level_table: &CharacterLevelTable,
ship_rooms: &mut Rooms, ship_rooms: &mut Rooms,
entity_gateway: &mut EG) entity_gateway: &mut EG)
-> Result<Vec<(ClientId, SendShipPacket)>, ShipError> { -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error> {
let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
let prev_area = client_location.get_area(id).map_err(|err| -> ClientLocationError {err.into()})?; let prev_area = client_location.get_area(id).map_err(|err| -> ClientLocationError {err.into()})?;
match prev_area { match prev_area {

30
src/ship/packet/handler/message.rs
View File

@ -16,7 +16,7 @@ pub async fn request_exp<EG: EntityGateway>(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
rooms: &mut Rooms, rooms: &mut Rooms,
level_table: &CharacterLevelTable) level_table: &CharacterLevelTable)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> { -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error> {
let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?; let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;
let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?; let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
@ -70,7 +70,7 @@ pub async fn player_drop_item<EG>(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
rooms: &mut Rooms, rooms: &mut Rooms,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -95,7 +95,7 @@ pub fn drop_coordinates(id: ClientId,
client_location: &ClientLocation, client_location: &ClientLocation,
clients: &mut Clients, clients: &mut Clients,
rooms: &Rooms) rooms: &Rooms)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
{ {
let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?; let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
@ -120,7 +120,7 @@ pub async fn split_item_stack<EG>(id: ClientId,
client_location: &ClientLocation, client_location: &ClientLocation,
clients: &mut Clients, clients: &mut Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -130,7 +130,7 @@ where
let drop_location = client.item_drop_location.ok_or(ShipError::ItemDropLocationNotSet)?; let drop_location = client.item_drop_location.ok_or(ShipError::ItemDropLocationNotSet)?;
if drop_location.item_id.0 != no_longer_has_item.item_id { if drop_location.item_id.0 != no_longer_has_item.item_id {
return Err(ShipError::DropInvalidItemId(no_longer_has_item.item_id)); return Err(ShipError::DropInvalidItemId(no_longer_has_item.item_id).into());
} }
if no_longer_has_item.item_id == 0xFFFFFFFF { if no_longer_has_item.item_id == 0xFFFFFFFF {
@ -164,7 +164,7 @@ pub fn update_player_position(id: ClientId,
clients: &mut Clients, clients: &mut Clients,
client_location: &ClientLocation, client_location: &ClientLocation,
rooms: &Rooms) rooms: &Rooms)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> { -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error> {
let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?; let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
if let Ok(room_id) = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() }) { if let Ok(room_id) = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() }) {
let room = rooms.get(room_id.0) let room = rooms.get(room_id.0)
@ -236,7 +236,7 @@ pub async fn charge_attack<EG>(id: ClientId,
charge: &ChargeAttack, charge: &ChargeAttack,
clients: &mut Clients, clients: &mut Clients,
entity_gateway: &mut EG) entity_gateway: &mut EG)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -246,7 +246,7 @@ where
entity_gateway.save_character(&client.character).await?; entity_gateway.save_character(&client.character).await?;
Ok(Box::new(None.into_iter())) Ok(Box::new(None.into_iter()))
} else { } else {
Err(ShipError::NotEnoughMeseta(id, client.character.meseta)) Err(ShipError::NotEnoughMeseta(id, client.character.meseta).into())
} }
} }
@ -256,7 +256,7 @@ pub async fn use_item<EG>(id: ClientId,
_client_location: &ClientLocation, _client_location: &ClientLocation,
clients: &mut Clients, clients: &mut Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -271,7 +271,7 @@ pub async fn player_used_medical_center<EG>(id: ClientId,
_pumc: &PlayerUsedMedicalCenter, // not needed? _pumc: &PlayerUsedMedicalCenter, // not needed?
entity_gateway: &mut EG, entity_gateway: &mut EG,
clients: &mut Clients) clients: &mut Clients)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -281,7 +281,7 @@ where
entity_gateway.save_character(&client.character).await?; entity_gateway.save_character(&client.character).await?;
Ok(Box::new(None.into_iter())) Ok(Box::new(None.into_iter()))
} else { } else {
Err(ShipError::NotEnoughMeseta(id, client.character.meseta)) Err(ShipError::NotEnoughMeseta(id, client.character.meseta).into())
} }
} }
@ -292,7 +292,7 @@ pub async fn player_feed_mag<EG>(id: ClientId,
client_location: &ClientLocation, client_location: &ClientLocation,
clients: &Clients, clients: &Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -311,7 +311,7 @@ pub async fn player_equips_item<EG>(id: ClientId,
entity_gateway: &mut EG, entity_gateway: &mut EG,
clients: &Clients, clients: &Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -331,7 +331,7 @@ pub async fn player_unequips_item<EG>(id: ClientId,
entity_gateway: &mut EG, entity_gateway: &mut EG,
clients: &Clients, clients: &Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {
@ -345,7 +345,7 @@ pub async fn player_sorts_items<EG>(id: ClientId,
entity_gateway: &mut EG, entity_gateway: &mut EG,
clients: &Clients, clients: &Clients,
item_manager: &mut ItemManager) item_manager: &mut ItemManager)
-> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where where
EG: EntityGateway EG: EntityGateway
{ {