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

use anyhow for itemmanager

pbs
jake 4 years ago
parent
f7c6be48b2
commit
a3cc29b68f
5 changed files with 50 additions and 50 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. 38
      src/ship/items/manager.rs
  2. 2
      src/ship/packet/handler/auth.rs
  3. 24
      src/ship/packet/handler/direct_message.rs
  4. 6
      src/ship/packet/handler/lobby.rs
  5. 30
      src/ship/packet/handler/message.rs

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
{ {

Write Preview
Loading…
Cancel
Save